1 // Copyright 2012 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "net/quic/quic_chromium_client_session.h"
6
7 #include "base/base64.h"
8 #include "base/files/file_path.h"
9 #include "base/functional/bind.h"
10 #include "base/memory/ptr_util.h"
11 #include "base/memory/raw_ptr.h"
12 #include "base/run_loop.h"
13 #include "base/strings/strcat.h"
14 #include "base/task/single_thread_task_runner.h"
15 #include "base/test/scoped_feature_list.h"
16 #include "base/time/default_tick_clock.h"
17 #include "build/build_config.h"
18 #include "net/base/connection_endpoint_metadata.h"
19 #include "net/base/features.h"
20 #include "net/base/network_anonymization_key.h"
21 #include "net/base/privacy_mode.h"
22 #include "net/base/proxy_chain.h"
23 #include "net/base/proxy_server.h"
24 #include "net/base/schemeful_site.h"
25 #include "net/base/session_usage.h"
26 #include "net/base/test_completion_callback.h"
27 #include "net/cert/cert_verify_result.h"
28 #include "net/dns/public/host_resolver_results.h"
29 #include "net/dns/public/secure_dns_policy.h"
30 #include "net/http/transport_security_state.h"
31 #include "net/http/transport_security_state_test_util.h"
32 #include "net/log/net_log.h"
33 #include "net/log/net_log_source.h"
34 #include "net/quic/address_utils.h"
35 #include "net/quic/crypto/proof_verifier_chromium.h"
36 #include "net/quic/mock_crypto_client_stream_factory.h"
37 #include "net/quic/mock_quic_data.h"
38 #include "net/quic/quic_chromium_alarm_factory.h"
39 #include "net/quic/quic_chromium_client_session_peer.h"
40 #include "net/quic/quic_chromium_connection_helper.h"
41 #include "net/quic/quic_chromium_packet_reader.h"
42 #include "net/quic/quic_chromium_packet_writer.h"
43 #include "net/quic/quic_connectivity_monitor.h"
44 #include "net/quic/quic_context.h"
45 #include "net/quic/quic_crypto_client_config_handle.h"
46 #include "net/quic/quic_crypto_client_stream_factory.h"
47 #include "net/quic/quic_http_utils.h"
48 #include "net/quic/quic_server_info.h"
49 #include "net/quic/quic_session_key.h"
50 #include "net/quic/quic_test_packet_maker.h"
51 #include "net/quic/test_quic_crypto_client_config_handle.h"
52 #include "net/socket/datagram_client_socket.h"
53 #include "net/socket/socket_test_util.h"
54 #include "net/spdy/spdy_test_util_common.h"
55 #include "net/ssl/ssl_config_service_defaults.h"
56 #include "net/test/cert_test_util.h"
57 #include "net/test/gtest_util.h"
58 #include "net/test/test_data_directory.h"
59 #include "net/test/test_with_task_environment.h"
60 #include "net/third_party/quiche/src/quiche/quic/core/crypto/aes_128_gcm_12_encrypter.h"
61 #include "net/third_party/quiche/src/quiche/quic/core/crypto/crypto_protocol.h"
62 #include "net/third_party/quiche/src/quiche/quic/core/crypto/quic_decrypter.h"
63 #include "net/third_party/quiche/src/quiche/quic/core/crypto/quic_encrypter.h"
64 #include "net/third_party/quiche/src/quiche/quic/core/quic_connection_id.h"
65 #include "net/third_party/quiche/src/quiche/quic/core/quic_packet_writer.h"
66 #include "net/third_party/quiche/src/quiche/quic/core/quic_tag.h"
67 #include "net/third_party/quiche/src/quiche/quic/core/quic_utils.h"
68 #include "net/third_party/quiche/src/quiche/quic/platform/api/quic_flags.h"
69 #include "net/third_party/quiche/src/quiche/quic/platform/api/quic_test.h"
70 #include "net/third_party/quiche/src/quiche/quic/test_tools/crypto_test_utils.h"
71 #include "net/third_party/quiche/src/quiche/quic/test_tools/mock_connection_id_generator.h"
72 #include "net/third_party/quiche/src/quiche/quic/test_tools/qpack/qpack_test_utils.h"
73 #include "net/third_party/quiche/src/quiche/quic/test_tools/quic_connection_peer.h"
74 #include "net/third_party/quiche/src/quiche/quic/test_tools/quic_session_peer.h"
75 #include "net/third_party/quiche/src/quiche/quic/test_tools/quic_stream_peer.h"
76 #include "net/third_party/quiche/src/quiche/quic/test_tools/quic_test_utils.h"
77 #include "net/third_party/quiche/src/quiche/quic/test_tools/simple_quic_framer.h"
78 #include "net/third_party/quiche/src/quiche/spdy/test_tools/spdy_test_utils.h"
79 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
80 #include "testing/gmock/include/gmock/gmock.h"
81 #include "url/gurl.h"
82 #include "url/scheme_host_port.h"
83 #include "url/url_constants.h"
84
85 using testing::_;
86
87 namespace net::test {
88 namespace {
89
90 const IPEndPoint kIpEndPoint = IPEndPoint(IPAddress::IPv4AllZeros(), 0);
91 const char kServerHostname[] = "test.example.com";
92 const uint16_t kServerPort = 443;
93 const size_t kMaxReadersPerQuicSession = 5;
94
95 const handles::NetworkHandle kDefaultNetworkForTests = 1;
96 const handles::NetworkHandle kNewNetworkForTests = 2;
97
98 // A subclass of QuicChromiumClientSession that allows OnPathDegrading to be
99 // mocked.
100 class TestingQuicChromiumClientSession : public QuicChromiumClientSession {
101 public:
102 using QuicChromiumClientSession::QuicChromiumClientSession;
103
104 MOCK_METHOD(void, OnPathDegrading, (), (override));
105
ReallyOnPathDegrading()106 void ReallyOnPathDegrading() { QuicChromiumClientSession::OnPathDegrading(); }
107 };
108
109 class QuicChromiumClientSessionTest
110 : public ::testing::TestWithParam<quic::ParsedQuicVersion>,
111 public WithTaskEnvironment {
112 public:
QuicChromiumClientSessionTest()113 QuicChromiumClientSessionTest()
114 : version_(GetParam()),
115 config_(quic::test::DefaultQuicConfig()),
116 crypto_config_(
117 quic::test::crypto_test_utils::ProofVerifierForTesting()),
118 default_read_(
119 std::make_unique<MockRead>(SYNCHRONOUS, ERR_IO_PENDING, 0)),
120 socket_data_(std::make_unique<SequencedSocketData>(
121 base::make_span(default_read_.get(), 1u),
122 base::span<MockWrite>())),
123 helper_(&clock_, &random_),
124 transport_security_state_(std::make_unique<TransportSecurityState>()),
125 session_key_(kServerHostname,
126 kServerPort,
127 PRIVACY_MODE_DISABLED,
128 ProxyChain::Direct(),
129 SessionUsage::kDestination,
130 SocketTag(),
131 NetworkAnonymizationKey(),
132 SecureDnsPolicy::kAllow,
133 /*require_dns_https_alpn=*/false),
134 destination_(url::kHttpsScheme, kServerHostname, kServerPort),
135 default_network_(handles::kInvalidNetworkHandle),
136 client_maker_(version_,
137 quic::QuicUtils::CreateRandomConnectionId(&random_),
138 &clock_,
139 kServerHostname,
140 quic::Perspective::IS_CLIENT),
141 server_maker_(version_,
142 quic::QuicUtils::CreateRandomConnectionId(&random_),
143 &clock_,
144 kServerHostname,
145 quic::Perspective::IS_SERVER,
146 false) {
147 FLAGS_quic_enable_http3_grease_randomness = false;
148 quic::QuicEnableVersion(version_);
149 // Advance the time, because timers do not like uninitialized times.
150 clock_.AdvanceTime(quic::QuicTime::Delta::FromSeconds(1));
151 }
152
ResetHandleOnError(std::unique_ptr<QuicChromiumClientSession::Handle> * handle,int net_error)153 void ResetHandleOnError(
154 std::unique_ptr<QuicChromiumClientSession::Handle>* handle,
155 int net_error) {
156 EXPECT_NE(OK, net_error);
157 handle->reset();
158 }
159
160 protected:
Initialize()161 void Initialize() {
162 if (socket_data_)
163 socket_factory_.AddSocketDataProvider(socket_data_.get());
164 std::unique_ptr<DatagramClientSocket> socket =
165 socket_factory_.CreateDatagramClientSocket(
166 DatagramSocket::DEFAULT_BIND, NetLog::Get(), NetLogSource());
167 socket->Connect(kIpEndPoint);
168 QuicChromiumPacketWriter* writer = new net::QuicChromiumPacketWriter(
169 socket.get(), base::SingleThreadTaskRunner::GetCurrentDefault().get());
170 quic::QuicConnection* connection = new quic::QuicConnection(
171 quic::QuicUtils::CreateRandomConnectionId(&random_),
172 quic::QuicSocketAddress(), ToQuicSocketAddress(kIpEndPoint), &helper_,
173 &alarm_factory_, writer, true, quic::Perspective::IS_CLIENT,
174 quic::test::SupportedVersions(version_), connection_id_generator_);
175 session_ = std::make_unique<TestingQuicChromiumClientSession>(
176 connection, std::move(socket),
177 /*stream_factory=*/nullptr, &crypto_client_stream_factory_, &clock_,
178 transport_security_state_.get(), &ssl_config_service_,
179 base::WrapUnique(static_cast<QuicServerInfo*>(nullptr)), session_key_,
180 /*require_confirmation=*/false, migrate_session_early_v2_,
181 /*migrate_session_on_network_change_v2=*/false, default_network_,
182 quic::QuicTime::Delta::FromMilliseconds(
183 kDefaultRetransmittableOnWireTimeout.InMilliseconds()),
184 /*migrate_idle_session=*/false, allow_port_migration_,
185 kDefaultIdleSessionMigrationPeriod, /*multi_port_probing_interval=*/0,
186 kMaxTimeOnNonDefaultNetwork,
187 kMaxMigrationsToNonDefaultNetworkOnWriteError,
188 kMaxMigrationsToNonDefaultNetworkOnPathDegrading,
189 kQuicYieldAfterPacketsRead,
190 quic::QuicTime::Delta::FromMilliseconds(
191 kQuicYieldAfterDurationMilliseconds),
192 /*cert_verify_flags=*/0, config_,
193 std::make_unique<TestQuicCryptoClientConfigHandle>(&crypto_config_),
194 "CONNECTION_UNKNOWN", base::TimeTicks::Now(), base::TimeTicks::Now(),
195 base::DefaultTickClock::GetInstance(),
196 base::SingleThreadTaskRunner::GetCurrentDefault().get(),
197 /*socket_performance_watcher=*/nullptr, ConnectionEndpointMetadata(),
198 NetLogWithSource::Make(NetLogSourceType::NONE));
199 if (connectivity_monitor_) {
200 connectivity_monitor_->SetInitialDefaultNetwork(default_network_);
201 session_->AddConnectivityObserver(connectivity_monitor_.get());
202 }
203
204 scoped_refptr<X509Certificate> cert(
205 ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"));
206 verify_details_.cert_verify_result.verified_cert = cert;
207 verify_details_.cert_verify_result.is_issued_by_known_root = true;
208 session_->Initialize();
209 // Blackhole QPACK decoder stream instead of constructing mock writes.
210 session_->qpack_decoder()->set_qpack_stream_sender_delegate(
211 &noop_qpack_stream_sender_delegate_);
212 session_->StartReading();
213 writer->set_delegate(session_.get());
214 }
215
TearDown()216 void TearDown() override {
217 if (session_) {
218 if (connectivity_monitor_)
219 session_->RemoveConnectivityObserver(connectivity_monitor_.get());
220 session_->CloseSessionOnError(
221 ERR_ABORTED, quic::QUIC_INTERNAL_ERROR,
222 quic::ConnectionCloseBehavior::SILENT_CLOSE);
223 }
224 }
225
CompleteCryptoHandshake()226 void CompleteCryptoHandshake() {
227 ASSERT_THAT(session_->CryptoConnect(callback_.callback()), IsOk());
228 }
229
CreateQuicChromiumPacketWriter(DatagramClientSocket * socket,QuicChromiumClientSession * session) const230 std::unique_ptr<QuicChromiumPacketWriter> CreateQuicChromiumPacketWriter(
231 DatagramClientSocket* socket,
232 QuicChromiumClientSession* session) const {
233 auto writer = std::make_unique<QuicChromiumPacketWriter>(
234 socket, base::SingleThreadTaskRunner::GetCurrentDefault().get());
235 writer->set_delegate(session);
236 return writer;
237 }
238
GetNthClientInitiatedBidirectionalStreamId(int n)239 quic::QuicStreamId GetNthClientInitiatedBidirectionalStreamId(int n) {
240 return quic::test::GetNthClientInitiatedBidirectionalStreamId(
241 version_.transport_version, n);
242 }
243
GetNthServerInitiatedUnidirectionalStreamId(int n)244 quic::QuicStreamId GetNthServerInitiatedUnidirectionalStreamId(int n) {
245 return quic::test::GetNthServerInitiatedUnidirectionalStreamId(
246 version_.transport_version, n);
247 }
248
GetMaxAllowedOutgoingBidirectionalStreams()249 size_t GetMaxAllowedOutgoingBidirectionalStreams() {
250 return quic::test::QuicSessionPeer::ietf_streamid_manager(session_.get())
251 ->max_outgoing_bidirectional_streams();
252 }
253
254 const quic::ParsedQuicVersion version_;
255 quic::test::QuicFlagSaver flags_; // Save/restore all QUIC flag values.
256 quic::QuicConfig config_;
257 quic::QuicCryptoClientConfig crypto_config_;
258 NetLogWithSource net_log_with_source_{
259 NetLogWithSource::Make(NetLog::Get(), NetLogSourceType::NONE)};
260 MockClientSocketFactory socket_factory_;
261 std::unique_ptr<MockRead> default_read_;
262 std::unique_ptr<SequencedSocketData> socket_data_;
263 quic::MockClock clock_;
264 quic::test::MockRandom random_{0};
265 QuicChromiumConnectionHelper helper_;
266 quic::test::MockAlarmFactory alarm_factory_;
267 std::unique_ptr<TransportSecurityState> transport_security_state_;
268 MockCryptoClientStreamFactory crypto_client_stream_factory_;
269 SSLConfigServiceDefaults ssl_config_service_;
270 QuicSessionKey session_key_;
271 url::SchemeHostPort destination_;
272 std::unique_ptr<TestingQuicChromiumClientSession> session_;
273 handles::NetworkHandle default_network_;
274 std::unique_ptr<QuicConnectivityMonitor> connectivity_monitor_;
275 raw_ptr<quic::QuicConnectionVisitorInterface> visitor_;
276 TestCompletionCallback callback_;
277 QuicTestPacketMaker client_maker_;
278 QuicTestPacketMaker server_maker_;
279 ProofVerifyDetailsChromium verify_details_;
280 bool migrate_session_early_v2_ = false;
281 bool allow_port_migration_ = false;
282 quic::test::MockConnectionIdGenerator connection_id_generator_;
283 quic::test::NoopQpackStreamSenderDelegate noop_qpack_stream_sender_delegate_;
284 };
285
286 INSTANTIATE_TEST_SUITE_P(VersionIncludeStreamDependencySequence,
287 QuicChromiumClientSessionTest,
288 ::testing::ValuesIn(AllSupportedQuicVersions()),
289 ::testing::PrintToStringParamName());
290
291 // Basic test of ProofVerifyDetailsChromium is converted to SSLInfo retrieved
292 // through QuicChromiumClientSession::GetSSLInfo(). Doesn't test some of the
293 // more complicated fields.
TEST_P(QuicChromiumClientSessionTest,GetSSLInfo1)294 TEST_P(QuicChromiumClientSessionTest, GetSSLInfo1) {
295 MockQuicData quic_data(version_);
296 quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeInitialSettingsPacket(1));
297 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
298 quic_data.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
299 quic_data.AddSocketDataToFactory(&socket_factory_);
300
301 Initialize();
302
303 ProofVerifyDetailsChromium details;
304 details.is_fatal_cert_error = false;
305 details.cert_verify_result.verified_cert =
306 ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem");
307 details.cert_verify_result.is_issued_by_known_root = true;
308 details.cert_verify_result.policy_compliance =
309 ct::CTPolicyCompliance::CT_POLICY_COMPLIES_VIA_SCTS;
310
311 CompleteCryptoHandshake();
312 session_->OnProofVerifyDetailsAvailable(details);
313
314 SSLInfo ssl_info;
315 ASSERT_TRUE(session_->GetSSLInfo(&ssl_info));
316 EXPECT_TRUE(ssl_info.is_valid());
317
318 EXPECT_EQ(details.is_fatal_cert_error, ssl_info.is_fatal_cert_error);
319 EXPECT_TRUE(ssl_info.cert->EqualsIncludingChain(
320 details.cert_verify_result.verified_cert.get()));
321 EXPECT_EQ(details.cert_verify_result.cert_status, ssl_info.cert_status);
322 EXPECT_EQ(details.cert_verify_result.is_issued_by_known_root,
323 ssl_info.is_issued_by_known_root);
324 EXPECT_EQ(details.cert_verify_result.policy_compliance,
325 ssl_info.ct_policy_compliance);
326 }
327
328 // Just like GetSSLInfo1, but uses different values.
TEST_P(QuicChromiumClientSessionTest,GetSSLInfo2)329 TEST_P(QuicChromiumClientSessionTest, GetSSLInfo2) {
330 MockQuicData quic_data(version_);
331 quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeInitialSettingsPacket(1));
332 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
333 quic_data.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
334 quic_data.AddSocketDataToFactory(&socket_factory_);
335
336 Initialize();
337
338 ProofVerifyDetailsChromium details;
339 details.is_fatal_cert_error = false;
340 details.cert_verify_result.verified_cert =
341 ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem");
342 details.cert_verify_result.is_issued_by_known_root = false;
343 details.cert_verify_result.policy_compliance =
344 ct::CTPolicyCompliance::CT_POLICY_NOT_ENOUGH_SCTS;
345
346 CompleteCryptoHandshake();
347 session_->OnProofVerifyDetailsAvailable(details);
348
349 SSLInfo ssl_info;
350 ASSERT_TRUE(session_->GetSSLInfo(&ssl_info));
351 EXPECT_TRUE(ssl_info.is_valid());
352
353 EXPECT_EQ(details.is_fatal_cert_error, ssl_info.is_fatal_cert_error);
354 EXPECT_TRUE(ssl_info.cert->EqualsIncludingChain(
355 details.cert_verify_result.verified_cert.get()));
356 EXPECT_EQ(details.cert_verify_result.cert_status, ssl_info.cert_status);
357 EXPECT_EQ(details.cert_verify_result.is_issued_by_known_root,
358 ssl_info.is_issued_by_known_root);
359 EXPECT_EQ(details.cert_verify_result.policy_compliance,
360 ssl_info.ct_policy_compliance);
361 }
362
TEST_P(QuicChromiumClientSessionTest,IsFatalErrorNotSetForNonFatalError)363 TEST_P(QuicChromiumClientSessionTest, IsFatalErrorNotSetForNonFatalError) {
364 MockQuicData quic_data(version_);
365 quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeInitialSettingsPacket(1));
366 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
367 quic_data.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
368 quic_data.AddSocketDataToFactory(&socket_factory_);
369
370 Initialize();
371
372 SSLInfo ssl_info;
373 ProofVerifyDetailsChromium details;
374 details.cert_verify_result.verified_cert =
375 ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem");
376 details.cert_verify_result.cert_status = CERT_STATUS_DATE_INVALID;
377 details.is_fatal_cert_error = false;
378 CompleteCryptoHandshake();
379 session_->OnProofVerifyDetailsAvailable(details);
380
381 ASSERT_TRUE(session_->GetSSLInfo(&ssl_info));
382 EXPECT_FALSE(ssl_info.is_fatal_cert_error);
383 }
384
TEST_P(QuicChromiumClientSessionTest,IsFatalErrorSetForFatalError)385 TEST_P(QuicChromiumClientSessionTest, IsFatalErrorSetForFatalError) {
386 MockQuicData quic_data(version_);
387 quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeInitialSettingsPacket(1));
388 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
389 quic_data.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
390 quic_data.AddSocketDataToFactory(&socket_factory_);
391 Initialize();
392
393 SSLInfo ssl_info;
394 ProofVerifyDetailsChromium details;
395 details.cert_verify_result.verified_cert =
396 ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem");
397 details.cert_verify_result.cert_status = CERT_STATUS_DATE_INVALID;
398 details.is_fatal_cert_error = true;
399 CompleteCryptoHandshake();
400 session_->OnProofVerifyDetailsAvailable(details);
401 ASSERT_TRUE(session_->GetSSLInfo(&ssl_info));
402 EXPECT_TRUE(ssl_info.is_fatal_cert_error);
403 }
404
TEST_P(QuicChromiumClientSessionTest,CryptoConnect)405 TEST_P(QuicChromiumClientSessionTest, CryptoConnect) {
406 MockQuicData quic_data(version_);
407 quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeInitialSettingsPacket(1));
408 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
409 quic_data.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
410 quic_data.AddSocketDataToFactory(&socket_factory_);
411 Initialize();
412 CompleteCryptoHandshake();
413 }
414
TEST_P(QuicChromiumClientSessionTest,Handle)415 TEST_P(QuicChromiumClientSessionTest, Handle) {
416 MockQuicData quic_data(version_);
417 quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeInitialSettingsPacket(1));
418 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
419 quic_data.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
420 quic_data.AddSocketDataToFactory(&socket_factory_);
421
422 Initialize();
423
424 NetLogWithSource session_net_log = session_->net_log();
425 EXPECT_EQ(NetLogSourceType::QUIC_SESSION, session_net_log.source().type);
426 EXPECT_EQ(NetLog::Get(), session_net_log.net_log());
427
428 std::unique_ptr<QuicChromiumClientSession::Handle> handle =
429 session_->CreateHandle(destination_);
430 EXPECT_TRUE(handle->IsConnected());
431 EXPECT_FALSE(handle->OneRttKeysAvailable());
432 EXPECT_EQ(version_, handle->GetQuicVersion());
433 EXPECT_EQ(session_key_.server_id(), handle->server_id());
434 EXPECT_EQ(session_net_log.source().type, handle->net_log().source().type);
435 EXPECT_EQ(session_net_log.source().id, handle->net_log().source().id);
436 EXPECT_EQ(session_net_log.net_log(), handle->net_log().net_log());
437 IPEndPoint address;
438 EXPECT_EQ(OK, handle->GetPeerAddress(&address));
439 EXPECT_EQ(kIpEndPoint, address);
440 EXPECT_TRUE(handle->CreatePacketBundler().get() != nullptr);
441
442 CompleteCryptoHandshake();
443
444 EXPECT_TRUE(handle->OneRttKeysAvailable());
445
446 // Request a stream and verify that a stream was created.
447 TestCompletionCallback callback;
448 ASSERT_EQ(OK, handle->RequestStream(/*requires_confirmation=*/false,
449 callback.callback(),
450 TRAFFIC_ANNOTATION_FOR_TESTS));
451 EXPECT_TRUE(handle->ReleaseStream() != nullptr);
452
453 quic_data.Resume();
454 EXPECT_TRUE(quic_data.AllReadDataConsumed());
455 EXPECT_TRUE(quic_data.AllWriteDataConsumed());
456
457 // Veirfy that the handle works correctly after the session is closed.
458 EXPECT_FALSE(handle->IsConnected());
459 EXPECT_TRUE(handle->OneRttKeysAvailable());
460 EXPECT_EQ(version_, handle->GetQuicVersion());
461 EXPECT_EQ(session_key_.server_id(), handle->server_id());
462 EXPECT_EQ(session_net_log.source().type, handle->net_log().source().type);
463 EXPECT_EQ(session_net_log.source().id, handle->net_log().source().id);
464 EXPECT_EQ(session_net_log.net_log(), handle->net_log().net_log());
465 EXPECT_EQ(ERR_CONNECTION_CLOSED, handle->GetPeerAddress(&address));
466 EXPECT_TRUE(handle->CreatePacketBundler().get() == nullptr);
467 {
468 // Verify that CreateHandle() works even after the session is closed.
469 std::unique_ptr<QuicChromiumClientSession::Handle> handle2 =
470 session_->CreateHandle(destination_);
471 EXPECT_FALSE(handle2->IsConnected());
472 EXPECT_TRUE(handle2->OneRttKeysAvailable());
473 ASSERT_EQ(ERR_CONNECTION_CLOSED,
474 handle2->RequestStream(/*requires_confirmation=*/false,
475 callback.callback(),
476 TRAFFIC_ANNOTATION_FOR_TESTS));
477 }
478
479 session_.reset();
480
481 // Verify that the handle works correctly after the session is deleted.
482 EXPECT_FALSE(handle->IsConnected());
483 EXPECT_TRUE(handle->OneRttKeysAvailable());
484 EXPECT_EQ(version_, handle->GetQuicVersion());
485 EXPECT_EQ(session_key_.server_id(), handle->server_id());
486 EXPECT_EQ(session_net_log.source().type, handle->net_log().source().type);
487 EXPECT_EQ(session_net_log.source().id, handle->net_log().source().id);
488 EXPECT_EQ(session_net_log.net_log(), handle->net_log().net_log());
489 EXPECT_EQ(ERR_CONNECTION_CLOSED, handle->GetPeerAddress(&address));
490 EXPECT_TRUE(handle->CreatePacketBundler().get() == nullptr);
491 ASSERT_EQ(
492 ERR_CONNECTION_CLOSED,
493 handle->RequestStream(/*requires_confirmation=*/false,
494 callback.callback(), TRAFFIC_ANNOTATION_FOR_TESTS));
495 }
496
TEST_P(QuicChromiumClientSessionTest,StreamRequest)497 TEST_P(QuicChromiumClientSessionTest, StreamRequest) {
498 MockQuicData quic_data(version_);
499 quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeInitialSettingsPacket(1));
500 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
501 quic_data.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
502 quic_data.AddSocketDataToFactory(&socket_factory_);
503
504 Initialize();
505 CompleteCryptoHandshake();
506
507 // Request a stream and verify that a stream was created.
508 std::unique_ptr<QuicChromiumClientSession::Handle> handle =
509 session_->CreateHandle(destination_);
510 TestCompletionCallback callback;
511 ASSERT_EQ(OK, handle->RequestStream(/*requires_confirmation=*/false,
512 callback.callback(),
513 TRAFFIC_ANNOTATION_FOR_TESTS));
514 EXPECT_TRUE(handle->ReleaseStream() != nullptr);
515
516 quic_data.Resume();
517 EXPECT_TRUE(quic_data.AllReadDataConsumed());
518 EXPECT_TRUE(quic_data.AllWriteDataConsumed());
519 }
520
TEST_P(QuicChromiumClientSessionTest,ConfirmationRequiredStreamRequest)521 TEST_P(QuicChromiumClientSessionTest, ConfirmationRequiredStreamRequest) {
522 MockQuicData quic_data(version_);
523 quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeInitialSettingsPacket(1));
524 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
525 quic_data.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
526 quic_data.AddSocketDataToFactory(&socket_factory_);
527
528 Initialize();
529 CompleteCryptoHandshake();
530
531 // Request a stream and verify that a stream was created.
532 std::unique_ptr<QuicChromiumClientSession::Handle> handle =
533 session_->CreateHandle(destination_);
534 TestCompletionCallback callback;
535 ASSERT_EQ(OK, handle->RequestStream(/*requires_confirmation=*/true,
536 callback.callback(),
537 TRAFFIC_ANNOTATION_FOR_TESTS));
538 EXPECT_TRUE(handle->ReleaseStream() != nullptr);
539
540 quic_data.Resume();
541 EXPECT_TRUE(quic_data.AllReadDataConsumed());
542 EXPECT_TRUE(quic_data.AllWriteDataConsumed());
543 }
544
TEST_P(QuicChromiumClientSessionTest,StreamRequestBeforeConfirmation)545 TEST_P(QuicChromiumClientSessionTest, StreamRequestBeforeConfirmation) {
546 MockQuicData quic_data(version_);
547 quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeInitialSettingsPacket(1));
548 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
549 quic_data.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
550 quic_data.AddSocketDataToFactory(&socket_factory_);
551
552 Initialize();
553
554 // Request a stream and verify that a stream was created.
555 std::unique_ptr<QuicChromiumClientSession::Handle> handle =
556 session_->CreateHandle(destination_);
557 TestCompletionCallback callback;
558 ASSERT_EQ(
559 ERR_IO_PENDING,
560 handle->RequestStream(/*requires_confirmation=*/true, callback.callback(),
561 TRAFFIC_ANNOTATION_FOR_TESTS));
562
563 CompleteCryptoHandshake();
564
565 EXPECT_THAT(callback.WaitForResult(), IsOk());
566
567 EXPECT_TRUE(handle->ReleaseStream() != nullptr);
568
569 quic_data.Resume();
570 EXPECT_TRUE(quic_data.AllReadDataConsumed());
571 EXPECT_TRUE(quic_data.AllWriteDataConsumed());
572 }
573
TEST_P(QuicChromiumClientSessionTest,CancelStreamRequestBeforeRelease)574 TEST_P(QuicChromiumClientSessionTest, CancelStreamRequestBeforeRelease) {
575 MockQuicData quic_data(version_);
576 int packet_num = 1;
577 quic_data.AddWrite(SYNCHRONOUS,
578 client_maker_.MakeInitialSettingsPacket(packet_num++));
579 quic_data.AddWrite(
580 SYNCHRONOUS,
581 client_maker_.MakeRstPacket(packet_num++,
582 GetNthClientInitiatedBidirectionalStreamId(0),
583 quic::QUIC_STREAM_CANCELLED));
584 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
585 quic_data.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
586 quic_data.AddSocketDataToFactory(&socket_factory_);
587
588 Initialize();
589 CompleteCryptoHandshake();
590
591 // Request a stream and cancel it without releasing the stream.
592 std::unique_ptr<QuicChromiumClientSession::Handle> handle =
593 session_->CreateHandle(destination_);
594 TestCompletionCallback callback;
595 ASSERT_EQ(OK, handle->RequestStream(/*requires_confirmation=*/false,
596 callback.callback(),
597 TRAFFIC_ANNOTATION_FOR_TESTS));
598 handle.reset();
599
600 quic_data.Resume();
601 EXPECT_TRUE(quic_data.AllReadDataConsumed());
602 EXPECT_TRUE(quic_data.AllWriteDataConsumed());
603 }
604
TEST_P(QuicChromiumClientSessionTest,AsyncStreamRequest)605 TEST_P(QuicChromiumClientSessionTest, AsyncStreamRequest) {
606 MockQuicData quic_data(version_);
607 uint64_t packet_num = 1;
608 quic_data.AddWrite(SYNCHRONOUS,
609 client_maker_.MakeInitialSettingsPacket(packet_num++));
610 // The open stream limit is set to 50 by
611 // MockCryptoClientStream::SetConfigNegotiated() so when the 51st stream is
612 // requested, a STREAMS_BLOCKED will be sent, indicating that it's blocked
613 // at the limit of 50.
614 quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeStreamsBlockedPacket(
615 packet_num++, 50,
616 /*unidirectional=*/false));
617 // Similarly, requesting the 52nd stream will also send a STREAMS_BLOCKED.
618 quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeStreamsBlockedPacket(
619 packet_num++, 50,
620 /*unidirectional=*/false));
621 quic_data.AddWrite(
622 SYNCHRONOUS,
623 client_maker_.MakeRstPacket(packet_num++,
624 GetNthClientInitiatedBidirectionalStreamId(0),
625 quic::QUIC_STREAM_CANCELLED,
626 /*include_stop_sending_if_v99=*/false));
627 quic_data.AddWrite(
628 SYNCHRONOUS,
629 client_maker_.MakeRstPacket(packet_num++,
630 GetNthClientInitiatedBidirectionalStreamId(1),
631 quic::QUIC_STREAM_CANCELLED,
632 /*include_stop_sending_if_v99=*/false));
633 // After the STREAMS_BLOCKED is sent, receive a MAX_STREAMS to increase
634 // the limit to 100.
635 quic_data.AddRead(
636 ASYNC, server_maker_.MakeMaxStreamsPacket(1, 100,
637 /*unidirectional=*/false));
638 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
639 quic_data.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
640 quic_data.AddSocketDataToFactory(&socket_factory_);
641 Initialize();
642 CompleteCryptoHandshake();
643
644 // Open the maximum number of streams so that subsequent requests cannot
645 // proceed immediately.
646 EXPECT_EQ(GetMaxAllowedOutgoingBidirectionalStreams(), 50u);
647 for (size_t i = 0; i < 50; i++) {
648 QuicChromiumClientSessionPeer::CreateOutgoingStream(session_.get());
649 }
650 EXPECT_EQ(session_->GetNumActiveStreams(), 50u);
651
652 // Request a stream and verify that it's pending.
653 std::unique_ptr<QuicChromiumClientSession::Handle> handle =
654 session_->CreateHandle(destination_);
655 TestCompletionCallback callback;
656 ASSERT_EQ(
657 ERR_IO_PENDING,
658 handle->RequestStream(/*requires_confirmation=*/false,
659 callback.callback(), TRAFFIC_ANNOTATION_FOR_TESTS));
660 // Request a second stream and verify that it's also pending.
661 std::unique_ptr<QuicChromiumClientSession::Handle> handle2 =
662 session_->CreateHandle(destination_);
663 TestCompletionCallback callback2;
664 ASSERT_EQ(ERR_IO_PENDING,
665 handle2->RequestStream(/*requires_confirmation=*/false,
666 callback2.callback(),
667 TRAFFIC_ANNOTATION_FOR_TESTS));
668
669 // Close two stream to open up sending credits.
670 quic::QuicRstStreamFrame rst(quic::kInvalidControlFrameId,
671 GetNthClientInitiatedBidirectionalStreamId(0),
672 quic::QUIC_STREAM_CANCELLED, 0);
673 session_->OnRstStream(rst);
674 quic::QuicRstStreamFrame rst2(quic::kInvalidControlFrameId,
675 GetNthClientInitiatedBidirectionalStreamId(1),
676 quic::QUIC_STREAM_CANCELLED, 0);
677 session_->OnRstStream(rst2);
678 // To close the streams completely, we need to also receive STOP_SENDING
679 // frames.
680 quic::QuicStopSendingFrame stop_sending(
681 quic::kInvalidControlFrameId,
682 GetNthClientInitiatedBidirectionalStreamId(0),
683 quic::QUIC_STREAM_CANCELLED);
684 session_->OnStopSendingFrame(stop_sending);
685 quic::QuicStopSendingFrame stop_sending2(
686 quic::kInvalidControlFrameId,
687 GetNthClientInitiatedBidirectionalStreamId(1),
688 quic::QUIC_STREAM_CANCELLED);
689 session_->OnStopSendingFrame(stop_sending2);
690
691 EXPECT_FALSE(callback.have_result());
692 EXPECT_FALSE(callback2.have_result());
693
694 // Pump the message loop to read the packet containing the MAX_STREAMS frame.
695 base::RunLoop().RunUntilIdle();
696
697 // Make sure that both requests were unblocked.
698 ASSERT_TRUE(callback.have_result());
699 EXPECT_THAT(callback.WaitForResult(), IsOk());
700 EXPECT_TRUE(handle->ReleaseStream() != nullptr);
701 ASSERT_TRUE(callback2.have_result());
702 EXPECT_THAT(callback2.WaitForResult(), IsOk());
703 EXPECT_TRUE(handle2->ReleaseStream() != nullptr);
704
705 quic_data.Resume();
706 EXPECT_TRUE(quic_data.AllReadDataConsumed());
707 EXPECT_TRUE(quic_data.AllWriteDataConsumed());
708 }
709
710 // Regression test for https://crbug.com/1021938.
711 // When the connection is closed, there may be tasks queued in the message loop
712 // to read the last packet, reading that packet should not crash.
TEST_P(QuicChromiumClientSessionTest,ReadAfterConnectionClose)713 TEST_P(QuicChromiumClientSessionTest, ReadAfterConnectionClose) {
714 MockQuicData quic_data(version_);
715 quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeInitialSettingsPacket(1));
716 // The open stream limit is set to 50 by
717 // MockCryptoClientStream::SetConfigNegotiated() so when the 51st stream is
718 // requested, a STREAMS_BLOCKED will be sent, indicating that it's blocked
719 // at the limit of 50.
720 quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeStreamsBlockedPacket(
721 2, 50,
722 /*unidirectional=*/false));
723 quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeStreamsBlockedPacket(
724 3, 50,
725 /*unidirectional=*/false));
726 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
727 // This packet will be read after connection is closed.
728 quic_data.AddRead(
729 ASYNC, server_maker_.MakeConnectionClosePacket(
730 1, quic::QUIC_CRYPTO_VERSION_NOT_SUPPORTED, "Time to panic!"));
731 quic_data.AddSocketDataToFactory(&socket_factory_);
732
733 Initialize();
734 CompleteCryptoHandshake();
735
736 // Open the maximum number of streams so that a subsequent request
737 // can not proceed immediately.
738 const size_t kMaxOpenStreams = GetMaxAllowedOutgoingBidirectionalStreams();
739 for (size_t i = 0; i < kMaxOpenStreams; i++) {
740 QuicChromiumClientSessionPeer::CreateOutgoingStream(session_.get());
741 }
742 EXPECT_EQ(kMaxOpenStreams, session_->GetNumActiveStreams());
743
744 // Request two streams which will both be pending.
745 // In V99 each will generate a max stream id for each attempt.
746 std::unique_ptr<QuicChromiumClientSession::Handle> handle =
747 session_->CreateHandle(destination_);
748 std::unique_ptr<QuicChromiumClientSession::Handle> handle2 =
749 session_->CreateHandle(destination_);
750
751 ASSERT_EQ(
752 ERR_IO_PENDING,
753 handle->RequestStream(
754 /*requires_confirmation=*/false,
755 base::BindOnce(&QuicChromiumClientSessionTest::ResetHandleOnError,
756 base::Unretained(this), &handle2),
757 TRAFFIC_ANNOTATION_FOR_TESTS));
758
759 TestCompletionCallback callback2;
760 ASSERT_EQ(ERR_IO_PENDING,
761 handle2->RequestStream(/*requires_confirmation=*/false,
762 callback2.callback(),
763 TRAFFIC_ANNOTATION_FOR_TESTS));
764
765 session_->connection()->CloseConnection(
766 quic::QUIC_NETWORK_IDLE_TIMEOUT, "Timed out",
767 quic::ConnectionCloseBehavior::SILENT_CLOSE);
768
769 // Pump the message loop to read the connection close packet.
770 base::RunLoop().RunUntilIdle();
771 EXPECT_FALSE(handle2.get());
772 quic_data.Resume();
773 EXPECT_TRUE(quic_data.AllReadDataConsumed());
774 EXPECT_TRUE(quic_data.AllWriteDataConsumed());
775 }
776
TEST_P(QuicChromiumClientSessionTest,ClosedWithAsyncStreamRequest)777 TEST_P(QuicChromiumClientSessionTest, ClosedWithAsyncStreamRequest) {
778 MockQuicData quic_data(version_);
779 quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeInitialSettingsPacket(1));
780 // The open stream limit is set to 50 by
781 // MockCryptoClientStream::SetConfigNegotiated() so when the 51st stream is
782 // requested, a STREAMS_BLOCKED will be sent, indicating that it's blocked
783 // at the limit of 50.
784 quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeStreamsBlockedPacket(
785 2, 50,
786 /*unidirectional=*/false));
787 quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeStreamsBlockedPacket(
788 3, 50,
789 /*unidirectional=*/false));
790 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
791 quic_data.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
792 quic_data.AddSocketDataToFactory(&socket_factory_);
793
794 Initialize();
795 CompleteCryptoHandshake();
796
797 // Open the maximum number of streams so that a subsequent request
798 // can not proceed immediately.
799 const size_t kMaxOpenStreams = GetMaxAllowedOutgoingBidirectionalStreams();
800 for (size_t i = 0; i < kMaxOpenStreams; i++) {
801 QuicChromiumClientSessionPeer::CreateOutgoingStream(session_.get());
802 }
803 EXPECT_EQ(kMaxOpenStreams, session_->GetNumActiveStreams());
804
805 // Request two streams which will both be pending.
806 // In V99 each will generate a max stream id for each attempt.
807 std::unique_ptr<QuicChromiumClientSession::Handle> handle =
808 session_->CreateHandle(destination_);
809 std::unique_ptr<QuicChromiumClientSession::Handle> handle2 =
810 session_->CreateHandle(destination_);
811
812 ASSERT_EQ(
813 ERR_IO_PENDING,
814 handle->RequestStream(
815 /*requires_confirmation=*/false,
816 base::BindOnce(&QuicChromiumClientSessionTest::ResetHandleOnError,
817 base::Unretained(this), &handle2),
818 TRAFFIC_ANNOTATION_FOR_TESTS));
819
820 TestCompletionCallback callback2;
821 ASSERT_EQ(ERR_IO_PENDING,
822 handle2->RequestStream(/*requires_confirmation=*/false,
823 callback2.callback(),
824 TRAFFIC_ANNOTATION_FOR_TESTS));
825
826 session_->connection()->CloseConnection(
827 quic::QUIC_NETWORK_IDLE_TIMEOUT, "Timed out",
828 quic::ConnectionCloseBehavior::SILENT_CLOSE);
829
830 // Pump the message loop to read the connection close packet.
831 base::RunLoop().RunUntilIdle();
832 EXPECT_FALSE(handle2.get());
833 quic_data.Resume();
834 EXPECT_TRUE(quic_data.AllReadDataConsumed());
835 EXPECT_TRUE(quic_data.AllWriteDataConsumed());
836 }
837
TEST_P(QuicChromiumClientSessionTest,CancelPendingStreamRequest)838 TEST_P(QuicChromiumClientSessionTest, CancelPendingStreamRequest) {
839 MockQuicData quic_data(version_);
840 quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeInitialSettingsPacket(1));
841 // The open stream limit is set to 50 by
842 // MockCryptoClientStream::SetConfigNegotiated() so when the 51st stream is
843 // requested, a STREAMS_BLOCKED will be sent.
844 quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeStreamsBlockedPacket(
845 2, 50,
846 /*unidirectional=*/false));
847 // This node receives the RST_STREAM+STOP_SENDING, it responds
848 // with only a RST_STREAM.
849 quic_data.AddWrite(SYNCHRONOUS,
850 client_maker_.MakeRstPacket(
851 3, GetNthClientInitiatedBidirectionalStreamId(0),
852 quic::QUIC_STREAM_CANCELLED,
853 /*include_stop_sending_if_v99=*/false));
854 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
855 quic_data.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
856 quic_data.AddSocketDataToFactory(&socket_factory_);
857
858 Initialize();
859 CompleteCryptoHandshake();
860
861 // Open the maximum number of streams so that a subsequent request
862 // can not proceed immediately.
863 const size_t kMaxOpenStreams = GetMaxAllowedOutgoingBidirectionalStreams();
864 for (size_t i = 0; i < kMaxOpenStreams; i++) {
865 QuicChromiumClientSessionPeer::CreateOutgoingStream(session_.get());
866 }
867 EXPECT_EQ(kMaxOpenStreams, session_->GetNumActiveStreams());
868
869 // Request a stream and verify that it's pending.
870 std::unique_ptr<QuicChromiumClientSession::Handle> handle =
871 session_->CreateHandle(destination_);
872 TestCompletionCallback callback;
873 ASSERT_EQ(
874 ERR_IO_PENDING,
875 handle->RequestStream(/*requires_confirmation=*/false,
876 callback.callback(), TRAFFIC_ANNOTATION_FOR_TESTS));
877
878 // Cancel the pending stream request.
879 handle.reset();
880
881 // Close a stream and ensure that no new stream is created.
882 quic::QuicRstStreamFrame rst(quic::kInvalidControlFrameId,
883 GetNthClientInitiatedBidirectionalStreamId(0),
884 quic::QUIC_STREAM_CANCELLED, 0);
885 session_->OnRstStream(rst);
886 // We require a STOP_SENDING as well as a RESET_STREAM to fully close the
887 // stream.
888 quic::QuicStopSendingFrame stop_sending(
889 quic::kInvalidControlFrameId,
890 GetNthClientInitiatedBidirectionalStreamId(0),
891 quic::QUIC_STREAM_CANCELLED);
892 session_->OnStopSendingFrame(stop_sending);
893 EXPECT_EQ(kMaxOpenStreams - 1, session_->GetNumActiveStreams());
894
895 quic_data.Resume();
896 EXPECT_TRUE(quic_data.AllReadDataConsumed());
897 EXPECT_TRUE(quic_data.AllWriteDataConsumed());
898 }
899
TEST_P(QuicChromiumClientSessionTest,ConnectionCloseBeforeStreamRequest)900 TEST_P(QuicChromiumClientSessionTest, ConnectionCloseBeforeStreamRequest) {
901 MockQuicData quic_data(version_);
902 int packet_num = 1;
903 quic_data.AddWrite(SYNCHRONOUS,
904 client_maker_.MakeInitialSettingsPacket(packet_num++));
905 quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakePingPacket(packet_num++));
906 quic_data.AddRead(
907 ASYNC, server_maker_.MakeConnectionClosePacket(
908 1, quic::QUIC_CRYPTO_VERSION_NOT_SUPPORTED, "Time to panic!"));
909
910 quic_data.AddSocketDataToFactory(&socket_factory_);
911
912 Initialize();
913 CompleteCryptoHandshake();
914
915 // Send a ping so that client has outgoing traffic before receiving packets.
916 session_->connection()->SendPing();
917
918 // Pump the message loop to read the connection close packet.
919 base::RunLoop().RunUntilIdle();
920
921 // Request a stream and verify that it failed.
922 std::unique_ptr<QuicChromiumClientSession::Handle> handle =
923 session_->CreateHandle(destination_);
924 TestCompletionCallback callback;
925 ASSERT_EQ(
926 ERR_CONNECTION_CLOSED,
927 handle->RequestStream(/*requires_confirmation=*/false,
928 callback.callback(), TRAFFIC_ANNOTATION_FOR_TESTS));
929
930 EXPECT_TRUE(quic_data.AllReadDataConsumed());
931 EXPECT_TRUE(quic_data.AllWriteDataConsumed());
932 }
933
TEST_P(QuicChromiumClientSessionTest,ConnectionCloseBeforeHandshakeConfirmed)934 TEST_P(QuicChromiumClientSessionTest, ConnectionCloseBeforeHandshakeConfirmed) {
935 if (version_.UsesTls()) {
936 // TODO(nharper, b/112643533): Figure out why this test fails when TLS is
937 // enabled and fix it.
938 return;
939 }
940
941 // Force the connection close packet to use long headers with connection ID.
942 server_maker_.SetEncryptionLevel(quic::ENCRYPTION_INITIAL);
943
944 MockQuicData quic_data(version_);
945 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
946 quic_data.AddRead(
947 ASYNC, server_maker_.MakeConnectionClosePacket(
948 1, quic::QUIC_CRYPTO_VERSION_NOT_SUPPORTED, "Time to panic!"));
949 quic_data.AddSocketDataToFactory(&socket_factory_);
950
951 Initialize();
952
953 // Request a stream and verify that it's pending.
954 std::unique_ptr<QuicChromiumClientSession::Handle> handle =
955 session_->CreateHandle(destination_);
956 TestCompletionCallback callback;
957 ASSERT_EQ(
958 ERR_IO_PENDING,
959 handle->RequestStream(/*requires_confirmation=*/true, callback.callback(),
960 TRAFFIC_ANNOTATION_FOR_TESTS));
961
962 // Close the connection and verify that the StreamRequest completes with
963 // an error.
964 quic_data.Resume();
965 base::RunLoop().RunUntilIdle();
966
967 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_CLOSED));
968
969 EXPECT_TRUE(quic_data.AllReadDataConsumed());
970 EXPECT_TRUE(quic_data.AllWriteDataConsumed());
971 }
972
TEST_P(QuicChromiumClientSessionTest,ConnectionCloseWithPendingStreamRequest)973 TEST_P(QuicChromiumClientSessionTest, ConnectionCloseWithPendingStreamRequest) {
974 MockQuicData quic_data(version_);
975 int packet_num = 1;
976 quic_data.AddWrite(SYNCHRONOUS,
977 client_maker_.MakeInitialSettingsPacket(packet_num++));
978 quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakePingPacket(packet_num++));
979 quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeStreamsBlockedPacket(
980 packet_num++, 50,
981 /*unidirectional=*/false));
982 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
983 quic_data.AddRead(
984 ASYNC, server_maker_.MakeConnectionClosePacket(
985 1, quic::QUIC_CRYPTO_VERSION_NOT_SUPPORTED, "Time to panic!"));
986 quic_data.AddSocketDataToFactory(&socket_factory_);
987
988 Initialize();
989 CompleteCryptoHandshake();
990
991 // Send a ping so that client has outgoing traffic before receiving packets.
992 session_->connection()->SendPing();
993
994 // Open the maximum number of streams so that a subsequent request
995 // can not proceed immediately.
996 const size_t kMaxOpenStreams = GetMaxAllowedOutgoingBidirectionalStreams();
997 for (size_t i = 0; i < kMaxOpenStreams; i++) {
998 QuicChromiumClientSessionPeer::CreateOutgoingStream(session_.get());
999 }
1000 EXPECT_EQ(kMaxOpenStreams, session_->GetNumActiveStreams());
1001
1002 // Request a stream and verify that it's pending.
1003 std::unique_ptr<QuicChromiumClientSession::Handle> handle =
1004 session_->CreateHandle(destination_);
1005 TestCompletionCallback callback;
1006 ASSERT_EQ(
1007 ERR_IO_PENDING,
1008 handle->RequestStream(/*requires_confirmation=*/false,
1009 callback.callback(), TRAFFIC_ANNOTATION_FOR_TESTS));
1010
1011 // Close the connection and verify that the StreamRequest completes with
1012 // an error.
1013 quic_data.Resume();
1014 base::RunLoop().RunUntilIdle();
1015
1016 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_CLOSED));
1017
1018 EXPECT_TRUE(quic_data.AllReadDataConsumed());
1019 EXPECT_TRUE(quic_data.AllWriteDataConsumed());
1020 }
1021
TEST_P(QuicChromiumClientSessionTest,MaxNumStreams)1022 TEST_P(QuicChromiumClientSessionTest, MaxNumStreams) {
1023 MockQuicData quic_data(version_);
1024 quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeInitialSettingsPacket(1));
1025 // Initial configuration is 50 dynamic streams. Taking into account
1026 // the static stream (headers), expect to block on when hitting the limit
1027 // of 50 streams
1028 quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeStreamsBlockedPacket(
1029 2, 50,
1030 /*unidirectional=*/false));
1031 quic_data.AddWrite(SYNCHRONOUS,
1032 client_maker_.MakeRstPacket(
1033 3, GetNthClientInitiatedBidirectionalStreamId(0),
1034 quic::QUIC_RST_ACKNOWLEDGEMENT));
1035 // For the second CreateOutgoingStream that fails because of hitting the
1036 // stream count limit.
1037 quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeStreamsBlockedPacket(
1038 4, 50,
1039 /*unidirectional=*/false));
1040 quic_data.AddRead(
1041 ASYNC, server_maker_.MakeMaxStreamsPacket(1, 50 + 2,
1042 /*unidirectional=*/false));
1043 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
1044 quic_data.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
1045 quic_data.AddSocketDataToFactory(&socket_factory_);
1046
1047 Initialize();
1048 CompleteCryptoHandshake();
1049 const size_t kMaxOpenStreams = GetMaxAllowedOutgoingBidirectionalStreams();
1050
1051 std::vector<QuicChromiumClientStream*> streams;
1052 for (size_t i = 0; i < kMaxOpenStreams; i++) {
1053 QuicChromiumClientStream* stream =
1054 QuicChromiumClientSessionPeer::CreateOutgoingStream(session_.get());
1055 EXPECT_TRUE(stream);
1056 streams.push_back(stream);
1057 }
1058 // This stream, the 51st dynamic stream, can not be opened.
1059 EXPECT_FALSE(
1060 QuicChromiumClientSessionPeer::CreateOutgoingStream(session_.get()));
1061
1062 EXPECT_EQ(kMaxOpenStreams, session_->GetNumActiveStreams());
1063
1064 // Close a stream and ensure I can now open a new one.
1065 quic::QuicStreamId stream_id = streams[0]->id();
1066 session_->ResetStream(stream_id, quic::QUIC_RST_ACKNOWLEDGEMENT);
1067
1068 // Pump data, bringing in the max-stream-id
1069 base::RunLoop().RunUntilIdle();
1070
1071 EXPECT_FALSE(
1072 QuicChromiumClientSessionPeer::CreateOutgoingStream(session_.get()));
1073 quic::QuicRstStreamFrame rst1(quic::kInvalidControlFrameId, stream_id,
1074 quic::QUIC_STREAM_NO_ERROR, 0);
1075 session_->OnRstStream(rst1);
1076 EXPECT_EQ(kMaxOpenStreams - 1, session_->GetNumActiveStreams());
1077 base::RunLoop().RunUntilIdle();
1078 EXPECT_TRUE(
1079 QuicChromiumClientSessionPeer::CreateOutgoingStream(session_.get()));
1080 }
1081
1082 // Regression test for crbug.com/968621.
TEST_P(QuicChromiumClientSessionTest,PendingStreamOnRst)1083 TEST_P(QuicChromiumClientSessionTest, PendingStreamOnRst) {
1084 MockQuicData quic_data(version_);
1085 int packet_num = 1;
1086 quic_data.AddWrite(ASYNC,
1087 client_maker_.MakeInitialSettingsPacket(packet_num++));
1088 quic_data.AddWrite(
1089 ASYNC, client_maker_.MakeRstPacket(
1090 packet_num++, GetNthServerInitiatedUnidirectionalStreamId(0),
1091 quic::QUIC_RST_ACKNOWLEDGEMENT));
1092 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
1093 quic_data.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
1094 quic_data.AddSocketDataToFactory(&socket_factory_);
1095
1096 Initialize();
1097 CompleteCryptoHandshake();
1098
1099 quic::QuicStreamFrame data(GetNthServerInitiatedUnidirectionalStreamId(0),
1100 false, 1, std::string_view("SP"));
1101 session_->OnStreamFrame(data);
1102 EXPECT_EQ(0u, session_->GetNumActiveStreams());
1103 quic::QuicRstStreamFrame rst(quic::kInvalidControlFrameId,
1104 GetNthServerInitiatedUnidirectionalStreamId(0),
1105 quic::QUIC_STREAM_CANCELLED, 0);
1106 session_->OnRstStream(rst);
1107 }
1108
1109 // Regression test for crbug.com/971361.
TEST_P(QuicChromiumClientSessionTest,ClosePendingStream)1110 TEST_P(QuicChromiumClientSessionTest, ClosePendingStream) {
1111 MockQuicData quic_data(version_);
1112 int packet_num = 1;
1113 quic_data.AddWrite(ASYNC,
1114 client_maker_.MakeInitialSettingsPacket(packet_num++));
1115 quic_data.AddWrite(
1116 ASYNC, client_maker_.MakeRstPacket(
1117 packet_num++, GetNthServerInitiatedUnidirectionalStreamId(0),
1118 quic::QUIC_RST_ACKNOWLEDGEMENT));
1119 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
1120 quic_data.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
1121 quic_data.AddSocketDataToFactory(&socket_factory_);
1122
1123 Initialize();
1124 CompleteCryptoHandshake();
1125
1126 quic::QuicStreamId id = GetNthServerInitiatedUnidirectionalStreamId(0);
1127 quic::QuicStreamFrame data(id, false, 1, std::string_view("SP"));
1128 session_->OnStreamFrame(data);
1129 EXPECT_EQ(0u, session_->GetNumActiveStreams());
1130 session_->ResetStream(id, quic::QUIC_STREAM_NO_ERROR);
1131 }
1132
TEST_P(QuicChromiumClientSessionTest,MaxNumStreamsViaRequest)1133 TEST_P(QuicChromiumClientSessionTest, MaxNumStreamsViaRequest) {
1134 MockQuicData quic_data(version_);
1135 quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeInitialSettingsPacket(1));
1136 quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeStreamsBlockedPacket(
1137 2, 50,
1138 /*unidirectional=*/false));
1139 quic_data.AddWrite(SYNCHRONOUS,
1140 client_maker_.MakeRstPacket(
1141 3, GetNthClientInitiatedBidirectionalStreamId(0),
1142 quic::QUIC_RST_ACKNOWLEDGEMENT));
1143 quic_data.AddRead(
1144 ASYNC, server_maker_.MakeMaxStreamsPacket(1, 52,
1145 /*unidirectional=*/false));
1146 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
1147 quic_data.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
1148 quic_data.AddSocketDataToFactory(&socket_factory_);
1149
1150 Initialize();
1151 CompleteCryptoHandshake();
1152 const size_t kMaxOpenStreams = GetMaxAllowedOutgoingBidirectionalStreams();
1153 std::vector<QuicChromiumClientStream*> streams;
1154 for (size_t i = 0; i < kMaxOpenStreams; i++) {
1155 QuicChromiumClientStream* stream =
1156 QuicChromiumClientSessionPeer::CreateOutgoingStream(session_.get());
1157 EXPECT_TRUE(stream);
1158 streams.push_back(stream);
1159 }
1160
1161 std::unique_ptr<QuicChromiumClientSession::Handle> handle =
1162 session_->CreateHandle(destination_);
1163 TestCompletionCallback callback;
1164 ASSERT_EQ(
1165 ERR_IO_PENDING,
1166 handle->RequestStream(/*requires_confirmation=*/false,
1167 callback.callback(), TRAFFIC_ANNOTATION_FOR_TESTS));
1168
1169 // Close a stream and ensure I can now open a new one.
1170 quic::QuicStreamId stream_id = streams[0]->id();
1171 session_->ResetStream(stream_id, quic::QUIC_RST_ACKNOWLEDGEMENT);
1172 quic::QuicRstStreamFrame rst1(quic::kInvalidControlFrameId, stream_id,
1173 quic::QUIC_STREAM_NO_ERROR, 0);
1174 session_->OnRstStream(rst1);
1175 // Pump data, bringing in the max-stream-id
1176 base::RunLoop().RunUntilIdle();
1177 ASSERT_TRUE(callback.have_result());
1178 EXPECT_THAT(callback.WaitForResult(), IsOk());
1179 EXPECT_TRUE(handle->ReleaseStream() != nullptr);
1180 }
1181
TEST_P(QuicChromiumClientSessionTest,GoAwayReceived)1182 TEST_P(QuicChromiumClientSessionTest, GoAwayReceived) {
1183 MockQuicData quic_data(version_);
1184 quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeInitialSettingsPacket(1));
1185 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
1186 quic_data.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
1187 quic_data.AddSocketDataToFactory(&socket_factory_);
1188 Initialize();
1189 CompleteCryptoHandshake();
1190
1191 // After receiving a GoAway, I should no longer be able to create outgoing
1192 // streams.
1193 session_->OnHttp3GoAway(0);
1194 EXPECT_EQ(nullptr, QuicChromiumClientSessionPeer::CreateOutgoingStream(
1195 session_.get()));
1196 }
1197
TEST_P(QuicChromiumClientSessionTest,CanPool)1198 TEST_P(QuicChromiumClientSessionTest, CanPool) {
1199 MockQuicData quic_data(version_);
1200 quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeInitialSettingsPacket(1));
1201 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
1202 quic_data.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
1203 quic_data.AddSocketDataToFactory(&socket_factory_);
1204 Initialize();
1205 // Load a cert that is valid for:
1206 // www.example.org
1207 // mail.example.org
1208 // www.example.com
1209
1210 ProofVerifyDetailsChromium details;
1211 details.cert_verify_result.verified_cert =
1212 ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem");
1213 ASSERT_TRUE(details.cert_verify_result.verified_cert.get());
1214
1215 CompleteCryptoHandshake();
1216 session_->OnProofVerifyDetailsAvailable(details);
1217
1218 EXPECT_TRUE(session_->CanPool(
1219 "www.example.org",
1220 QuicSessionKey("foo", 1234, PRIVACY_MODE_DISABLED, ProxyChain::Direct(),
1221 SessionUsage::kDestination, SocketTag(),
1222 NetworkAnonymizationKey(), SecureDnsPolicy::kAllow,
1223 /*require_dns_https_alpn=*/false)));
1224 EXPECT_FALSE(session_->CanPool(
1225 "www.example.org",
1226 QuicSessionKey("foo", 1234, PRIVACY_MODE_ENABLED, ProxyChain::Direct(),
1227 SessionUsage::kDestination, SocketTag(),
1228 NetworkAnonymizationKey(), SecureDnsPolicy::kAllow,
1229 /*require_dns_https_alpn=*/false)));
1230 EXPECT_FALSE(session_->CanPool(
1231 "www.example.org",
1232 QuicSessionKey("foo", 1234, PRIVACY_MODE_DISABLED, ProxyChain::Direct(),
1233 SessionUsage::kDestination, SocketTag(),
1234 NetworkAnonymizationKey(), SecureDnsPolicy::kDisable,
1235 /*require_dns_https_alpn=*/false)));
1236 #if BUILDFLAG(IS_ANDROID)
1237 SocketTag tag1(SocketTag::UNSET_UID, 0x12345678);
1238 SocketTag tag2(getuid(), 0x87654321);
1239 EXPECT_FALSE(session_->CanPool(
1240 "www.example.org",
1241 QuicSessionKey("foo", 1234, PRIVACY_MODE_DISABLED, ProxyChain::Direct(),
1242 SessionUsage::kDestination, tag1,
1243 NetworkAnonymizationKey(), SecureDnsPolicy::kAllow,
1244 /*require_dns_https_alpn=*/false)));
1245 EXPECT_FALSE(session_->CanPool(
1246 "www.example.org",
1247 QuicSessionKey("foo", 1234, PRIVACY_MODE_DISABLED, ProxyChain::Direct(),
1248 SessionUsage::kDestination, tag2,
1249 NetworkAnonymizationKey(), SecureDnsPolicy::kAllow,
1250 /*require_dns_https_alpn=*/false)));
1251 #endif
1252 EXPECT_FALSE(session_->CanPool(
1253 "www.example.org",
1254 QuicSessionKey("foo", 1234, PRIVACY_MODE_DISABLED,
1255 ProxyChain::FromSchemeHostAndPort(ProxyServer::SCHEME_QUIC,
1256 "bar", 443),
1257 SessionUsage::kDestination, SocketTag(),
1258 NetworkAnonymizationKey(), SecureDnsPolicy::kAllow,
1259 /*require_dns_https_alpn=*/false)));
1260 EXPECT_FALSE(session_->CanPool(
1261 "www.example.org",
1262 QuicSessionKey("foo", 1234, PRIVACY_MODE_DISABLED, ProxyChain::Direct(),
1263 SessionUsage::kProxy, SocketTag(),
1264 NetworkAnonymizationKey(), SecureDnsPolicy::kAllow,
1265 /*require_dns_https_alpn=*/false)));
1266
1267 EXPECT_TRUE(session_->CanPool(
1268 "mail.example.org",
1269 QuicSessionKey("foo", 1234, PRIVACY_MODE_DISABLED, ProxyChain::Direct(),
1270 SessionUsage::kDestination, SocketTag(),
1271 NetworkAnonymizationKey(), SecureDnsPolicy::kAllow,
1272 /*require_dns_https_alpn=*/false)));
1273 EXPECT_TRUE(session_->CanPool(
1274 "mail.example.com",
1275 QuicSessionKey("foo", 1234, PRIVACY_MODE_DISABLED, ProxyChain::Direct(),
1276 SessionUsage::kDestination, SocketTag(),
1277 NetworkAnonymizationKey(), SecureDnsPolicy::kAllow,
1278 /*require_dns_https_alpn=*/false)));
1279 EXPECT_FALSE(session_->CanPool(
1280 "mail.google.com",
1281 QuicSessionKey("foo", 1234, PRIVACY_MODE_DISABLED, ProxyChain::Direct(),
1282 SessionUsage::kDestination, SocketTag(),
1283 NetworkAnonymizationKey(), SecureDnsPolicy::kAllow,
1284 /*require_dns_https_alpn=*/false)));
1285
1286 const SchemefulSite kSiteFoo(GURL("http://foo.test/"));
1287
1288 // Check that NetworkAnonymizationKey is respected when feature is enabled.
1289 {
1290 base::test::ScopedFeatureList feature_list;
1291 feature_list.InitAndDisableFeature(
1292 features::kPartitionConnectionsByNetworkIsolationKey);
1293 EXPECT_TRUE(session_->CanPool(
1294 "mail.example.com",
1295 QuicSessionKey("foo", 1234, PRIVACY_MODE_DISABLED, ProxyChain::Direct(),
1296 SessionUsage::kDestination, SocketTag(),
1297 NetworkAnonymizationKey::CreateSameSite(kSiteFoo),
1298 SecureDnsPolicy::kAllow,
1299 /*require_dns_https_alpn=*/false)));
1300 }
1301 {
1302 base::test::ScopedFeatureList feature_list;
1303 feature_list.InitAndEnableFeature(
1304 features::kPartitionConnectionsByNetworkIsolationKey);
1305 EXPECT_FALSE(session_->CanPool(
1306 "mail.example.com",
1307 QuicSessionKey("foo", 1234, PRIVACY_MODE_DISABLED, ProxyChain::Direct(),
1308 SessionUsage::kDestination, SocketTag(),
1309 NetworkAnonymizationKey::CreateSameSite(kSiteFoo),
1310 SecureDnsPolicy::kAllow,
1311 /*require_dns_https_alpn=*/false)));
1312 }
1313 }
1314
1315 // Much as above, but uses a non-empty NetworkAnonymizationKey.
TEST_P(QuicChromiumClientSessionTest,CanPoolWithNetworkAnonymizationKey)1316 TEST_P(QuicChromiumClientSessionTest, CanPoolWithNetworkAnonymizationKey) {
1317 base::test::ScopedFeatureList feature_list;
1318 feature_list.InitAndEnableFeature(
1319 features::kPartitionConnectionsByNetworkIsolationKey);
1320
1321 const SchemefulSite kSiteFoo(GURL("http://foo.test/"));
1322 const SchemefulSite kSiteBar(GURL("http://bar.test/"));
1323 const auto kNetworkAnonymizationKey1 =
1324 NetworkAnonymizationKey::CreateSameSite(kSiteFoo);
1325 const auto kNetworkAnonymizationKey2 =
1326 NetworkAnonymizationKey::CreateSameSite(kSiteBar);
1327
1328 session_key_ = QuicSessionKey(
1329 kServerHostname, kServerPort, PRIVACY_MODE_DISABLED, ProxyChain::Direct(),
1330 SessionUsage::kDestination, SocketTag(), kNetworkAnonymizationKey1,
1331 SecureDnsPolicy::kAllow,
1332 /*require_dns_https_alpn=*/false);
1333
1334 MockQuicData quic_data(version_);
1335 quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeInitialSettingsPacket(1));
1336 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
1337 quic_data.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
1338 quic_data.AddSocketDataToFactory(&socket_factory_);
1339 Initialize();
1340 // Load a cert that is valid for:
1341 // www.example.org
1342 // mail.example.org
1343 // www.example.com
1344
1345 ProofVerifyDetailsChromium details;
1346 details.cert_verify_result.verified_cert =
1347 ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem");
1348 ASSERT_TRUE(details.cert_verify_result.verified_cert.get());
1349
1350 CompleteCryptoHandshake();
1351 session_->OnProofVerifyDetailsAvailable(details);
1352
1353 EXPECT_TRUE(session_->CanPool(
1354 "www.example.org",
1355 QuicSessionKey("foo", 1234, PRIVACY_MODE_DISABLED, ProxyChain::Direct(),
1356 SessionUsage::kDestination, SocketTag(),
1357 kNetworkAnonymizationKey1, SecureDnsPolicy::kAllow,
1358 /*require_dns_https_alpn=*/false)));
1359 EXPECT_FALSE(session_->CanPool(
1360 "www.example.org",
1361 QuicSessionKey("foo", 1234, PRIVACY_MODE_ENABLED, ProxyChain::Direct(),
1362 SessionUsage::kDestination, SocketTag(),
1363 kNetworkAnonymizationKey1, SecureDnsPolicy::kAllow,
1364 /*require_dns_https_alpn=*/false)));
1365 #if BUILDFLAG(IS_ANDROID)
1366 SocketTag tag1(SocketTag::UNSET_UID, 0x12345678);
1367 SocketTag tag2(getuid(), 0x87654321);
1368 EXPECT_FALSE(session_->CanPool(
1369 "www.example.org",
1370 QuicSessionKey("foo", 1234, PRIVACY_MODE_DISABLED, ProxyChain::Direct(),
1371 SessionUsage::kDestination, tag1,
1372 kNetworkAnonymizationKey1, SecureDnsPolicy::kAllow,
1373 /*require_dns_https_alpn=*/false)));
1374 EXPECT_FALSE(session_->CanPool(
1375 "www.example.org",
1376 QuicSessionKey("foo", 1234, PRIVACY_MODE_DISABLED, ProxyChain::Direct(),
1377 SessionUsage::kDestination, tag2,
1378 kNetworkAnonymizationKey1, SecureDnsPolicy::kAllow,
1379 /*require_dns_https_alpn=*/false)));
1380 #endif
1381 EXPECT_TRUE(session_->CanPool(
1382 "mail.example.org",
1383 QuicSessionKey("foo", 1234, PRIVACY_MODE_DISABLED, ProxyChain::Direct(),
1384 SessionUsage::kDestination, SocketTag(),
1385 kNetworkAnonymizationKey1, SecureDnsPolicy::kAllow,
1386 /*require_dns_https_alpn=*/false)));
1387 EXPECT_TRUE(session_->CanPool(
1388 "mail.example.com",
1389 QuicSessionKey("foo", 1234, PRIVACY_MODE_DISABLED, ProxyChain::Direct(),
1390 SessionUsage::kDestination, SocketTag(),
1391 kNetworkAnonymizationKey1, SecureDnsPolicy::kAllow,
1392 /*require_dns_https_alpn=*/false)));
1393 EXPECT_FALSE(session_->CanPool(
1394 "mail.google.com",
1395 QuicSessionKey("foo", 1234, PRIVACY_MODE_DISABLED, ProxyChain::Direct(),
1396 SessionUsage::kDestination, SocketTag(),
1397 kNetworkAnonymizationKey1, SecureDnsPolicy::kAllow,
1398 /*require_dns_https_alpn=*/false)));
1399
1400 EXPECT_FALSE(session_->CanPool(
1401 "mail.example.com",
1402 QuicSessionKey("foo", 1234, PRIVACY_MODE_DISABLED, ProxyChain::Direct(),
1403 SessionUsage::kDestination, SocketTag(),
1404 kNetworkAnonymizationKey2, SecureDnsPolicy::kAllow,
1405 /*require_dns_https_alpn=*/false)));
1406 EXPECT_FALSE(session_->CanPool(
1407 "mail.example.com",
1408 QuicSessionKey("foo", 1234, PRIVACY_MODE_DISABLED, ProxyChain::Direct(),
1409 SessionUsage::kDestination, SocketTag(),
1410 NetworkAnonymizationKey(), SecureDnsPolicy::kAllow,
1411 /*require_dns_https_alpn=*/false)));
1412 }
1413
TEST_P(QuicChromiumClientSessionTest,ConnectionNotPooledWithDifferentPin)1414 TEST_P(QuicChromiumClientSessionTest, ConnectionNotPooledWithDifferentPin) {
1415 base::test::ScopedFeatureList scoped_feature_list_;
1416 scoped_feature_list_.InitAndEnableFeature(
1417 net::features::kStaticKeyPinningEnforcement);
1418 // Configure the TransportSecurityStateSource so that kPreloadedPKPHost will
1419 // have static PKP pins set.
1420 ScopedTransportSecurityStateSource scoped_security_state_source;
1421
1422 // |net::test_default::kHSTSSource| defines pins for kPreloadedPKPHost.
1423 // (This hostname must be in the spdy_pooling.pem SAN.)
1424 const char kPreloadedPKPHost[] = "www.example.org";
1425 // A hostname without any static state. (This hostname isn't in
1426 // spdy_pooling.pem SAN, but that's okay because the
1427 // ProofVerifyDetailsChromium are faked.)
1428 const char kNoPinsHost[] = "no-pkp.example.org";
1429
1430 MockQuicData quic_data(version_);
1431 quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeInitialSettingsPacket(1));
1432 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
1433 quic_data.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
1434 quic_data.AddSocketDataToFactory(&socket_factory_);
1435 Initialize();
1436
1437 transport_security_state_->EnableStaticPinsForTesting();
1438 transport_security_state_->SetPinningListAlwaysTimelyForTesting(true);
1439
1440 ProofVerifyDetailsChromium details;
1441 details.cert_verify_result.verified_cert =
1442 ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem");
1443 details.cert_verify_result.is_issued_by_known_root = true;
1444 uint8_t bad_pin = 3;
1445 details.cert_verify_result.public_key_hashes.push_back(
1446 GetTestHashValue(bad_pin));
1447
1448 ASSERT_TRUE(details.cert_verify_result.verified_cert.get());
1449
1450 CompleteCryptoHandshake();
1451 session_->OnProofVerifyDetailsAvailable(details);
1452 QuicChromiumClientSessionPeer::SetHostname(session_.get(), kNoPinsHost);
1453
1454 EXPECT_FALSE(session_->CanPool(
1455 kPreloadedPKPHost,
1456 QuicSessionKey("foo", 1234, PRIVACY_MODE_DISABLED, ProxyChain::Direct(),
1457 SessionUsage::kDestination, SocketTag(),
1458 NetworkAnonymizationKey(), SecureDnsPolicy::kAllow,
1459 /*require_dns_https_alpn=*/false)));
1460 }
1461
TEST_P(QuicChromiumClientSessionTest,ConnectionPooledWithMatchingPin)1462 TEST_P(QuicChromiumClientSessionTest, ConnectionPooledWithMatchingPin) {
1463 ScopedTransportSecurityStateSource scoped_security_state_source;
1464
1465 MockQuicData quic_data(version_);
1466 quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeInitialSettingsPacket(1));
1467 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
1468 quic_data.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
1469 quic_data.AddSocketDataToFactory(&socket_factory_);
1470 Initialize();
1471
1472 transport_security_state_->EnableStaticPinsForTesting();
1473
1474 ProofVerifyDetailsChromium details;
1475 details.cert_verify_result.verified_cert =
1476 ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem");
1477 details.cert_verify_result.is_issued_by_known_root = true;
1478 HashValue primary_pin(HASH_VALUE_SHA256);
1479 EXPECT_TRUE(primary_pin.FromString(
1480 "sha256/Nn8jk5By4Vkq6BeOVZ7R7AC6XUUBZsWmUbJR1f1Y5FY="));
1481 details.cert_verify_result.public_key_hashes.push_back(primary_pin);
1482
1483 ASSERT_TRUE(details.cert_verify_result.verified_cert.get());
1484
1485 CompleteCryptoHandshake();
1486 session_->OnProofVerifyDetailsAvailable(details);
1487 QuicChromiumClientSessionPeer::SetHostname(session_.get(), "www.example.org");
1488
1489 EXPECT_TRUE(session_->CanPool(
1490 "mail.example.org",
1491 QuicSessionKey("foo", 1234, PRIVACY_MODE_DISABLED, ProxyChain::Direct(),
1492 SessionUsage::kDestination, SocketTag(),
1493 NetworkAnonymizationKey(), SecureDnsPolicy::kAllow,
1494 /*require_dns_https_alpn=*/false)));
1495 }
1496
TEST_P(QuicChromiumClientSessionTest,MigrateToSocket)1497 TEST_P(QuicChromiumClientSessionTest, MigrateToSocket) {
1498 quic::QuicConnectionId cid_on_new_path =
1499 quic::test::TestConnectionId(12345678);
1500 MockQuicData quic_data(version_);
1501 int packet_num = 1;
1502 int peer_packet_num = 1;
1503 socket_data_.reset();
1504 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
1505 quic_data.AddWrite(ASYNC,
1506 client_maker_.MakeInitialSettingsPacket(packet_num++));
1507 quic_data.AddRead(ASYNC, server_maker_.MakeNewConnectionIdPacket(
1508 peer_packet_num++, cid_on_new_path,
1509 /*sequence_number=*/1u,
1510 /*retire_prior_to=*/0u));
1511 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
1512 quic_data.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
1513 quic_data.AddSocketDataToFactory(&socket_factory_);
1514 Initialize();
1515 CompleteCryptoHandshake();
1516
1517 // Make new connection ID available after handshake completion.
1518 quic_data.Resume();
1519 base::RunLoop().RunUntilIdle();
1520
1521 char data[] = "ABCD";
1522 MockQuicData quic_data2(version_);
1523 client_maker_.set_connection_id(cid_on_new_path);
1524 quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1525 quic_data2.AddWrite(SYNCHRONOUS, client_maker_.MakeAckAndPingPacket(
1526 packet_num++,
1527 /*largest_received=*/peer_packet_num - 1,
1528 /*smallest_received=*/1));
1529 quic_data2.AddWrite(
1530 SYNCHRONOUS,
1531 client_maker_.MakeDataPacket(
1532 packet_num++, GetNthClientInitiatedBidirectionalStreamId(0), false,
1533 std::string_view(data)));
1534 quic_data2.AddSocketDataToFactory(&socket_factory_);
1535 // Create connected socket.
1536 std::unique_ptr<DatagramClientSocket> new_socket =
1537 socket_factory_.CreateDatagramClientSocket(DatagramSocket::RANDOM_BIND,
1538 NetLog::Get(), NetLogSource());
1539 EXPECT_THAT(new_socket->Connect(kIpEndPoint), IsOk());
1540
1541 // Create reader and writer.
1542 auto new_reader = std::make_unique<QuicChromiumPacketReader>(
1543 std::move(new_socket), &clock_, session_.get(),
1544 kQuicYieldAfterPacketsRead,
1545 quic::QuicTime::Delta::FromMilliseconds(
1546 kQuicYieldAfterDurationMilliseconds),
1547 net_log_with_source_);
1548 new_reader->StartReading();
1549 std::unique_ptr<QuicChromiumPacketWriter> new_writer(
1550 CreateQuicChromiumPacketWriter(new_reader->socket(), session_.get()));
1551
1552 IPEndPoint local_address;
1553 new_reader->socket()->GetLocalAddress(&local_address);
1554 IPEndPoint peer_address;
1555 new_reader->socket()->GetPeerAddress(&peer_address);
1556 // Migrate session.
1557 EXPECT_TRUE(session_->MigrateToSocket(
1558 ToQuicSocketAddress(local_address), ToQuicSocketAddress(peer_address),
1559 std::move(new_reader), std::move(new_writer)));
1560 // Spin message loop to complete migration.
1561 base::RunLoop().RunUntilIdle();
1562
1563 // Write data to session.
1564 QuicChromiumClientStream* stream =
1565 QuicChromiumClientSessionPeer::CreateOutgoingStream(session_.get());
1566 quic::test::QuicStreamPeer::SendBuffer(stream).SaveStreamData(data);
1567 quic::test::QuicStreamPeer::SetStreamBytesWritten(4, stream);
1568 session_->WritevData(stream->id(), 4, 0, quic::NO_FIN,
1569 quic::NOT_RETRANSMISSION,
1570 quic::ENCRYPTION_FORWARD_SECURE);
1571
1572 EXPECT_TRUE(quic_data2.AllReadDataConsumed());
1573 EXPECT_TRUE(quic_data2.AllWriteDataConsumed());
1574 }
1575
TEST_P(QuicChromiumClientSessionTest,MigrateToSocketMaxReaders)1576 TEST_P(QuicChromiumClientSessionTest, MigrateToSocketMaxReaders) {
1577 MockQuicData quic_data(version_);
1578 socket_data_.reset();
1579 int packet_num = 1;
1580 int peer_packet_num = 1;
1581 quic::QuicConnectionId next_cid = quic::QuicUtils::CreateRandomConnectionId(
1582 quiche::QuicheRandom::GetInstance());
1583 uint64_t next_cid_sequence_number = 1u;
1584 quic_data.AddWrite(SYNCHRONOUS,
1585 client_maker_.MakeInitialSettingsPacket(packet_num++));
1586 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
1587 quic_data.AddRead(ASYNC,
1588 server_maker_.MakeNewConnectionIdPacket(
1589 peer_packet_num++, next_cid, next_cid_sequence_number,
1590 /*retire_prior_to=*/next_cid_sequence_number - 1));
1591 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
1592 quic_data.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
1593 quic_data.AddSocketDataToFactory(&socket_factory_);
1594 Initialize();
1595 CompleteCryptoHandshake();
1596
1597 // Make connection ID available for the first migration.
1598 quic_data.Resume();
1599
1600 /* Migration succeeds when maximum number of readers is not reached.*/
1601 for (size_t i = 0; i < kMaxReadersPerQuicSession - 1; ++i) {
1602 MockQuicData quic_data2(version_);
1603 client_maker_.set_connection_id(next_cid);
1604 quic_data2.AddWrite(SYNCHRONOUS,
1605 client_maker_.MakeAckAndPingPacket(
1606 packet_num++,
1607 /*largest_received=*/peer_packet_num - 1,
1608 /*smallest_received=*/1));
1609 quic_data2.AddRead(ASYNC, ERR_IO_PENDING);
1610 quic_data2.AddWrite(ASYNC,
1611 client_maker_.MakeRetireConnectionIdPacket(
1612 packet_num++,
1613 /*sequence_number=*/next_cid_sequence_number - 1));
1614 next_cid = quic::QuicUtils::CreateRandomConnectionId(
1615 quiche::QuicheRandom::GetInstance());
1616 ++next_cid_sequence_number;
1617 quic_data2.AddRead(
1618 ASYNC, server_maker_.MakeNewConnectionIdPacket(
1619 peer_packet_num++, next_cid, next_cid_sequence_number,
1620 /*retire_prior_to=*/next_cid_sequence_number - 1));
1621 quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read.
1622 quic_data2.AddSocketDataToFactory(&socket_factory_);
1623
1624 // Create connected socket.
1625 std::unique_ptr<DatagramClientSocket> new_socket =
1626 socket_factory_.CreateDatagramClientSocket(
1627 DatagramSocket::RANDOM_BIND, NetLog::Get(), NetLogSource());
1628 EXPECT_THAT(new_socket->Connect(kIpEndPoint), IsOk());
1629
1630 // Create reader and writer.
1631 auto new_reader = std::make_unique<QuicChromiumPacketReader>(
1632 std::move(new_socket), &clock_, session_.get(),
1633 kQuicYieldAfterPacketsRead,
1634 quic::QuicTime::Delta::FromMilliseconds(
1635 kQuicYieldAfterDurationMilliseconds),
1636 net_log_with_source_);
1637 new_reader->StartReading();
1638 std::unique_ptr<QuicChromiumPacketWriter> new_writer(
1639 CreateQuicChromiumPacketWriter(new_reader->socket(), session_.get()));
1640
1641 IPEndPoint local_address;
1642 new_reader->socket()->GetLocalAddress(&local_address);
1643 IPEndPoint peer_address;
1644 new_reader->socket()->GetPeerAddress(&peer_address);
1645 // Migrate session.
1646 EXPECT_TRUE(session_->MigrateToSocket(
1647 ToQuicSocketAddress(local_address), ToQuicSocketAddress(peer_address),
1648 std::move(new_reader), std::move(new_writer)));
1649 // Spin message loop to complete migration.
1650 base::RunLoop().RunUntilIdle();
1651 alarm_factory_.FireAlarm(
1652 quic::test::QuicConnectionPeer::GetRetirePeerIssuedConnectionIdAlarm(
1653 session_->connection()));
1654 // Make new connection ID available for subsequent migration.
1655 quic_data2.Resume();
1656 base::RunLoop().RunUntilIdle();
1657 EXPECT_TRUE(quic_data2.AllReadDataConsumed());
1658 EXPECT_TRUE(quic_data2.AllWriteDataConsumed());
1659 }
1660
1661 /* Migration fails when maximum number of readers is reached.*/
1662 MockQuicData quic_data2(version_);
1663 quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read.
1664 quic_data2.AddSocketDataToFactory(&socket_factory_);
1665 // Create connected socket.
1666 std::unique_ptr<DatagramClientSocket> new_socket =
1667 socket_factory_.CreateDatagramClientSocket(DatagramSocket::RANDOM_BIND,
1668 NetLog::Get(), NetLogSource());
1669 EXPECT_THAT(new_socket->Connect(kIpEndPoint), IsOk());
1670
1671 // Create reader and writer.
1672 auto new_reader = std::make_unique<QuicChromiumPacketReader>(
1673 std::move(new_socket), &clock_, session_.get(),
1674 kQuicYieldAfterPacketsRead,
1675 quic::QuicTime::Delta::FromMilliseconds(
1676 kQuicYieldAfterDurationMilliseconds),
1677 net_log_with_source_);
1678 new_reader->StartReading();
1679 std::unique_ptr<QuicChromiumPacketWriter> new_writer(
1680 CreateQuicChromiumPacketWriter(new_reader->socket(), session_.get()));
1681
1682 IPEndPoint local_address;
1683 new_reader->socket()->GetLocalAddress(&local_address);
1684 IPEndPoint peer_address;
1685 new_reader->socket()->GetPeerAddress(&peer_address);
1686 EXPECT_FALSE(session_->MigrateToSocket(
1687 ToQuicSocketAddress(local_address), ToQuicSocketAddress(peer_address),
1688 std::move(new_reader), std::move(new_writer)));
1689 EXPECT_TRUE(quic_data2.AllReadDataConsumed());
1690 EXPECT_TRUE(quic_data2.AllWriteDataConsumed());
1691 }
1692
TEST_P(QuicChromiumClientSessionTest,MigrateToSocketReadError)1693 TEST_P(QuicChromiumClientSessionTest, MigrateToSocketReadError) {
1694 MockQuicData quic_data(version_);
1695 socket_data_.reset();
1696 int packet_num = 1;
1697 int peer_packet_num = 1;
1698
1699 quic::QuicConnectionId cid_on_new_path =
1700 quic::test::TestConnectionId(12345678);
1701 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
1702 quic_data.AddWrite(ASYNC,
1703 client_maker_.MakeInitialSettingsPacket(packet_num++));
1704 quic_data.AddRead(ASYNC, server_maker_.MakeNewConnectionIdPacket(
1705 peer_packet_num++, cid_on_new_path,
1706 /*sequence_number=*/1u,
1707 /*retire_prior_to=*/0u));
1708 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
1709 quic_data.AddRead(ASYNC, ERR_NETWORK_CHANGED);
1710
1711 quic_data.AddSocketDataToFactory(&socket_factory_);
1712 Initialize();
1713 CompleteCryptoHandshake();
1714
1715 // Make new connection ID available after handshake completion.
1716 quic_data.Resume();
1717 base::RunLoop().RunUntilIdle();
1718
1719 MockQuicData quic_data2(version_);
1720 client_maker_.set_connection_id(cid_on_new_path);
1721 quic_data2.AddWrite(SYNCHRONOUS, client_maker_.MakeAckAndPingPacket(
1722 packet_num++,
1723
1724 /*largest_received=*/peer_packet_num - 1,
1725 /*smallest_received=*/1));
1726 quic_data2.AddRead(ASYNC, ERR_IO_PENDING);
1727 quic_data2.AddRead(ASYNC, server_maker_.MakePingPacket(1));
1728 quic_data2.AddRead(ASYNC, ERR_IO_PENDING);
1729 quic_data2.AddRead(ASYNC, ERR_NETWORK_CHANGED);
1730 quic_data2.AddSocketDataToFactory(&socket_factory_);
1731
1732 // Create connected socket.
1733 std::unique_ptr<DatagramClientSocket> new_socket =
1734 socket_factory_.CreateDatagramClientSocket(DatagramSocket::RANDOM_BIND,
1735 NetLog::Get(), NetLogSource());
1736 EXPECT_THAT(new_socket->Connect(kIpEndPoint), IsOk());
1737
1738 // Create reader and writer.
1739 auto new_reader = std::make_unique<QuicChromiumPacketReader>(
1740 std::move(new_socket), &clock_, session_.get(),
1741 kQuicYieldAfterPacketsRead,
1742 quic::QuicTime::Delta::FromMilliseconds(
1743 kQuicYieldAfterDurationMilliseconds),
1744 net_log_with_source_);
1745 new_reader->StartReading();
1746 std::unique_ptr<QuicChromiumPacketWriter> new_writer(
1747 CreateQuicChromiumPacketWriter(new_reader->socket(), session_.get()));
1748
1749 IPEndPoint local_address;
1750 new_reader->socket()->GetLocalAddress(&local_address);
1751 IPEndPoint peer_address;
1752 new_reader->socket()->GetPeerAddress(&peer_address);
1753 // Store old socket and migrate session.
1754 EXPECT_TRUE(session_->MigrateToSocket(
1755 ToQuicSocketAddress(local_address), ToQuicSocketAddress(peer_address),
1756 std::move(new_reader), std::move(new_writer)));
1757 // Spin message loop to complete migration.
1758 base::RunLoop().RunUntilIdle();
1759 EXPECT_TRUE(
1760 quic::test::QuicConnectionPeer::GetRetirePeerIssuedConnectionIdAlarm(
1761 session_->connection())
1762 ->IsSet());
1763
1764 // Read error on old socket does not impact session.
1765 quic_data.Resume();
1766 EXPECT_TRUE(session_->connection()->connected());
1767 quic_data2.Resume();
1768
1769 // Read error on new socket causes session close.
1770 EXPECT_TRUE(session_->connection()->connected());
1771 quic_data2.Resume();
1772 EXPECT_FALSE(session_->connection()->connected());
1773
1774 EXPECT_TRUE(quic_data.AllReadDataConsumed());
1775 EXPECT_TRUE(quic_data.AllWriteDataConsumed());
1776 EXPECT_TRUE(quic_data2.AllReadDataConsumed());
1777 EXPECT_TRUE(quic_data2.AllWriteDataConsumed());
1778 }
1779
TEST_P(QuicChromiumClientSessionTest,RetransmittableOnWireTimeout)1780 TEST_P(QuicChromiumClientSessionTest, RetransmittableOnWireTimeout) {
1781 migrate_session_early_v2_ = true;
1782
1783 MockQuicData quic_data(version_);
1784 int packet_num = 1;
1785 quic_data.AddWrite(SYNCHRONOUS,
1786 client_maker_.MakeInitialSettingsPacket(packet_num++));
1787 quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakePingPacket(packet_num++));
1788
1789 quic_data.AddRead(ASYNC, server_maker_.MakeAckPacket(1, packet_num - 1, 1));
1790
1791 quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakePingPacket(packet_num++));
1792 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
1793 quic_data.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
1794 quic_data.AddSocketDataToFactory(&socket_factory_);
1795
1796 Initialize();
1797 CompleteCryptoHandshake();
1798
1799 // Open a stream since the connection only sends PINGs to keep a
1800 // retransmittable packet on the wire if there's an open stream.
1801 EXPECT_TRUE(
1802 QuicChromiumClientSessionPeer::CreateOutgoingStream(session_.get()));
1803
1804 quic::QuicAlarm* alarm =
1805 quic::test::QuicConnectionPeer::GetPingAlarm(session_->connection());
1806 EXPECT_FALSE(alarm->IsSet());
1807
1808 // Send PING, which will be ACKed by the server. After the ACK, there will be
1809 // no retransmittable packets on the wire, so the alarm should be set.
1810 session_->connection()->SendPing();
1811 base::RunLoop().RunUntilIdle();
1812 EXPECT_TRUE(alarm->IsSet());
1813 EXPECT_EQ(
1814 clock_.ApproximateNow() + quic::QuicTime::Delta::FromMilliseconds(200),
1815 alarm->deadline());
1816
1817 // Advance clock and simulate the alarm firing. This should cause a PING to be
1818 // sent.
1819 clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(200));
1820 alarm_factory_.FireAlarm(alarm);
1821 base::RunLoop().RunUntilIdle();
1822
1823 quic_data.Resume();
1824 EXPECT_TRUE(quic_data.AllReadDataConsumed());
1825 EXPECT_TRUE(quic_data.AllWriteDataConsumed());
1826 }
1827
1828 // Regression test for https://crbug.com/1043531.
TEST_P(QuicChromiumClientSessionTest,ResetOnEmptyResponseHeaders)1829 TEST_P(QuicChromiumClientSessionTest, ResetOnEmptyResponseHeaders) {
1830 MockQuicData quic_data(version_);
1831 int packet_num = 1;
1832 quic_data.AddWrite(ASYNC,
1833 client_maker_.MakeInitialSettingsPacket(packet_num++));
1834 quic_data.AddWrite(
1835 ASYNC, client_maker_.MakeRstPacket(
1836 packet_num++, GetNthClientInitiatedBidirectionalStreamId(0),
1837 quic::QUIC_STREAM_GENERAL_PROTOCOL_ERROR));
1838 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
1839 quic_data.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
1840 quic_data.AddSocketDataToFactory(&socket_factory_);
1841 Initialize();
1842
1843 ProofVerifyDetailsChromium details;
1844 details.cert_verify_result.verified_cert =
1845 ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem");
1846 ASSERT_TRUE(details.cert_verify_result.verified_cert.get());
1847
1848 CompleteCryptoHandshake();
1849 session_->OnProofVerifyDetailsAvailable(details);
1850
1851 auto session_handle = session_->CreateHandle(destination_);
1852 TestCompletionCallback callback;
1853 EXPECT_EQ(OK, session_handle->RequestStream(/*requires_confirmation=*/false,
1854 callback.callback(),
1855 TRAFFIC_ANNOTATION_FOR_TESTS));
1856
1857 auto stream_handle = session_handle->ReleaseStream();
1858 EXPECT_TRUE(stream_handle->IsOpen());
1859
1860 auto* stream = quic::test::QuicSessionPeer::GetOrCreateStream(
1861 session_.get(), stream_handle->id());
1862
1863 const quic::QuicHeaderList empty_response_headers;
1864 static_cast<quic::QuicSpdyStream*>(stream)->OnStreamHeaderList(
1865 /* fin = */ false, /* frame_len = */ 0, empty_response_headers);
1866
1867 // QuicSpdyStream::OnStreamHeaderList() calls
1868 // QuicChromiumClientStream::OnInitialHeadersComplete() with the empty
1869 // header list, and QuicChromiumClientStream signals an error.
1870 spdy::Http2HeaderBlock header_block;
1871 int rv = stream_handle->ReadInitialHeaders(&header_block,
1872 CompletionOnceCallback());
1873 EXPECT_THAT(rv, IsError(net::ERR_QUIC_PROTOCOL_ERROR));
1874
1875 base::RunLoop().RunUntilIdle();
1876 quic_data.Resume();
1877 EXPECT_TRUE(quic_data.AllReadDataConsumed());
1878 EXPECT_TRUE(quic_data.AllWriteDataConsumed());
1879 }
1880
1881 // This test verifies that when handles::NetworkHandle is not supported and
1882 // there is no network change, session reports to the connectivity monitor
1883 // correctly on path degrading detection and recovery.
TEST_P(QuicChromiumClientSessionTest,DegradingWithoutNetworkChange_NoNetworkHandle)1884 TEST_P(QuicChromiumClientSessionTest,
1885 DegradingWithoutNetworkChange_NoNetworkHandle) {
1886 // Add a connectivity monitor for testing.
1887 default_network_ = handles::kInvalidNetworkHandle;
1888 connectivity_monitor_ =
1889 std::make_unique<QuicConnectivityMonitor>(default_network_);
1890
1891 Initialize();
1892
1893 // Fire path degrading detection.
1894 session_->ReallyOnPathDegrading();
1895 EXPECT_EQ(1u, connectivity_monitor_->GetNumDegradingSessions());
1896
1897 session_->OnForwardProgressMadeAfterPathDegrading();
1898 EXPECT_EQ(0u, connectivity_monitor_->GetNumDegradingSessions());
1899
1900 // Fire again.
1901 session_->ReallyOnPathDegrading();
1902 EXPECT_EQ(1u, connectivity_monitor_->GetNumDegradingSessions());
1903
1904 // Close the session but keep the session around, the connectivity monitor
1905 // will not remove the tracking immediately.
1906 session_->CloseSessionOnError(ERR_ABORTED, quic::QUIC_INTERNAL_ERROR,
1907 quic::ConnectionCloseBehavior::SILENT_CLOSE);
1908 EXPECT_EQ(1u, connectivity_monitor_->GetNumDegradingSessions());
1909
1910 // Delete the session will remove the degrading count in connectivity
1911 // monitor.
1912 session_.reset();
1913 EXPECT_EQ(0u, connectivity_monitor_->GetNumDegradingSessions());
1914 }
1915
1916 // This test verifies that when multi-port and port migration is enabled, path
1917 // degrading won't trigger port migration.
TEST_P(QuicChromiumClientSessionTest,DegradingWithMultiPortEnabled)1918 TEST_P(QuicChromiumClientSessionTest, DegradingWithMultiPortEnabled) {
1919 // Default network is always set to handles::kInvalidNetworkHandle.
1920 default_network_ = handles::kInvalidNetworkHandle;
1921 connectivity_monitor_ =
1922 std::make_unique<QuicConnectivityMonitor>(default_network_);
1923 allow_port_migration_ = true;
1924 auto options = config_.SendConnectionOptions();
1925 config_.SetClientConnectionOptions(quic::QuicTagVector{quic::kMPQC});
1926 config_.SetConnectionOptionsToSend(options);
1927
1928 Initialize();
1929 EXPECT_TRUE(session_->connection()->multi_port_stats());
1930
1931 session_->ReallyOnPathDegrading();
1932 EXPECT_EQ(1u, connectivity_monitor_->GetNumDegradingSessions());
1933
1934 EXPECT_EQ(
1935 UNKNOWN_CAUSE,
1936 QuicChromiumClientSessionPeer::GetCurrentMigrationCause(session_.get()));
1937 }
1938
1939 // This test verifies that when the handles::NetworkHandle is not supported, and
1940 // there are speculated network change reported via OnIPAddressChange, session
1941 // still reports to the connectivity monitor correctly on path degrading
1942 // detection and recovery.
TEST_P(QuicChromiumClientSessionTest,DegradingWithIPAddressChange)1943 TEST_P(QuicChromiumClientSessionTest, DegradingWithIPAddressChange) {
1944 // Default network is always set to handles::kInvalidNetworkHandle.
1945 default_network_ = handles::kInvalidNetworkHandle;
1946 connectivity_monitor_ =
1947 std::make_unique<QuicConnectivityMonitor>(default_network_);
1948
1949 Initialize();
1950
1951 session_->ReallyOnPathDegrading();
1952 EXPECT_EQ(1u, connectivity_monitor_->GetNumDegradingSessions());
1953
1954 session_->OnForwardProgressMadeAfterPathDegrading();
1955 EXPECT_EQ(0u, connectivity_monitor_->GetNumDegradingSessions());
1956
1957 session_->ReallyOnPathDegrading();
1958 EXPECT_EQ(1u, connectivity_monitor_->GetNumDegradingSessions());
1959
1960 // When handles::NetworkHandle is not supported, network change is notified
1961 // via IP address change.
1962 connectivity_monitor_->OnIPAddressChanged();
1963 EXPECT_EQ(0u, connectivity_monitor_->GetNumDegradingSessions());
1964
1965 // When handles::NetworkHandle is not supported and IP address changes,
1966 // session either goes away or gets closed. When it goes away,
1967 // reporting to connectivity monitor is disabled.
1968 connectivity_monitor_->OnSessionGoingAwayOnIPAddressChange(session_.get());
1969
1970 // Even if session detects recovery or degradation, this session is no longer
1971 // on the default network and connectivity monitor will not update.
1972 session_->OnForwardProgressMadeAfterPathDegrading();
1973 EXPECT_EQ(0u, connectivity_monitor_->GetNumDegradingSessions());
1974 session_->ReallyOnPathDegrading();
1975 EXPECT_EQ(0u, connectivity_monitor_->GetNumDegradingSessions());
1976
1977 session_->CloseSessionOnError(ERR_ABORTED, quic::QUIC_INTERNAL_ERROR,
1978 quic::ConnectionCloseBehavior::SILENT_CLOSE);
1979 EXPECT_EQ(0u, connectivity_monitor_->GetNumDegradingSessions());
1980
1981 session_.reset();
1982 EXPECT_EQ(0u, connectivity_monitor_->GetNumDegradingSessions());
1983 }
1984
1985 // This test verifies that when handles::NetworkHandle is supported but
1986 // migration is not supported and there's no network change, session reports to
1987 // connectivity monitor correctly on path degrading detection or recovery.
1988 // Default network change is currently reported with valid
1989 // handles::NetworkHandles while session's current network interface is tracked
1990 // by |default_network_|.
TEST_P(QuicChromiumClientSessionTest,DegradingOnDeafultNetwork_WithoutMigration)1991 TEST_P(QuicChromiumClientSessionTest,
1992 DegradingOnDeafultNetwork_WithoutMigration) {
1993 default_network_ = kDefaultNetworkForTests;
1994 connectivity_monitor_ =
1995 std::make_unique<QuicConnectivityMonitor>(default_network_);
1996
1997 Initialize();
1998
1999 session_->ReallyOnPathDegrading();
2000 EXPECT_EQ(1u, connectivity_monitor_->GetNumDegradingSessions());
2001
2002 session_->OnForwardProgressMadeAfterPathDegrading();
2003 EXPECT_EQ(0u, connectivity_monitor_->GetNumDegradingSessions());
2004
2005 session_->ReallyOnPathDegrading();
2006 EXPECT_EQ(1u, connectivity_monitor_->GetNumDegradingSessions());
2007 // Close the session but keep the session around, the connectivity monitor
2008 // should not remove the count immediately.
2009 session_->CloseSessionOnError(ERR_ABORTED, quic::QUIC_INTERNAL_ERROR,
2010 quic::ConnectionCloseBehavior::SILENT_CLOSE);
2011 EXPECT_EQ(1u, connectivity_monitor_->GetNumDegradingSessions());
2012
2013 // Delete the session will remove the degrading count in connectivity
2014 // monitor.
2015 session_.reset();
2016 EXPECT_EQ(0u, connectivity_monitor_->GetNumDegradingSessions());
2017 }
2018
2019 // This test verifies that when handles::NetworkHandle is supported but
2020 // migrations is not supported and there is network changes, session reports to
2021 // the connectivity monitor correctly on path degrading detection or recovery.
TEST_P(QuicChromiumClientSessionTest,DegradingWithDeafultNetworkChange_WithoutMigration)2022 TEST_P(QuicChromiumClientSessionTest,
2023 DegradingWithDeafultNetworkChange_WithoutMigration) {
2024 default_network_ = kDefaultNetworkForTests;
2025 connectivity_monitor_ =
2026 std::make_unique<QuicConnectivityMonitor>(default_network_);
2027
2028 Initialize();
2029
2030 session_->ReallyOnPathDegrading();
2031 EXPECT_EQ(1u, connectivity_monitor_->GetNumDegradingSessions());
2032
2033 session_->OnForwardProgressMadeAfterPathDegrading();
2034 EXPECT_EQ(0u, connectivity_monitor_->GetNumDegradingSessions());
2035
2036 session_->ReallyOnPathDegrading();
2037 EXPECT_EQ(1u, connectivity_monitor_->GetNumDegradingSessions());
2038
2039 // Simulate the default network change.
2040 connectivity_monitor_->OnDefaultNetworkUpdated(kNewNetworkForTests);
2041 EXPECT_EQ(0u, connectivity_monitor_->GetNumDegradingSessions());
2042 session_->OnNetworkMadeDefault(kNewNetworkForTests);
2043
2044 // Session stays on the old default network, and recovers.
2045 session_->OnForwardProgressMadeAfterPathDegrading();
2046 EXPECT_EQ(0u, connectivity_monitor_->GetNumDegradingSessions());
2047
2048 // Session degrades again on the old default.
2049 session_->ReallyOnPathDegrading();
2050 EXPECT_EQ(0u, connectivity_monitor_->GetNumDegradingSessions());
2051
2052 // Simulate that default network switches back to the old default.
2053 connectivity_monitor_->OnDefaultNetworkUpdated(kDefaultNetworkForTests);
2054 EXPECT_EQ(0u, connectivity_monitor_->GetNumDegradingSessions());
2055 session_->OnNetworkMadeDefault(kDefaultNetworkForTests);
2056
2057 // Session recovers again on the (old) default.
2058 session_->OnForwardProgressMadeAfterPathDegrading();
2059 EXPECT_EQ(0u, connectivity_monitor_->GetNumDegradingSessions());
2060
2061 // Session degrades again on the (old) default.
2062 session_->ReallyOnPathDegrading();
2063 EXPECT_EQ(1u, connectivity_monitor_->GetNumDegradingSessions());
2064
2065 session_->CloseSessionOnError(ERR_ABORTED, quic::QUIC_INTERNAL_ERROR,
2066 quic::ConnectionCloseBehavior::SILENT_CLOSE);
2067 EXPECT_EQ(1u, connectivity_monitor_->GetNumDegradingSessions());
2068
2069 session_.reset();
2070 EXPECT_EQ(0u, connectivity_monitor_->GetNumDegradingSessions());
2071 }
2072
TEST_P(QuicChromiumClientSessionTest,WriteErrorDuringCryptoConnect)2073 TEST_P(QuicChromiumClientSessionTest, WriteErrorDuringCryptoConnect) {
2074 // Add a connectivity monitor for testing.
2075 default_network_ = kDefaultNetworkForTests;
2076 connectivity_monitor_ =
2077 std::make_unique<QuicConnectivityMonitor>(default_network_);
2078
2079 // Use unmocked crypto stream to do crypto connect.
2080 crypto_client_stream_factory_.set_handshake_mode(
2081 MockCryptoClientStream::COLD_START_WITH_CHLO_SENT);
2082
2083 MockQuicData quic_data(version_);
2084 // Trigger a packet write error when sending packets in crypto connect.
2085 quic_data.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE);
2086 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
2087 quic_data.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
2088 quic_data.AddSocketDataToFactory(&socket_factory_);
2089
2090 Initialize();
2091 ASSERT_THAT(session_->CryptoConnect(callback_.callback()),
2092 IsError(ERR_QUIC_HANDSHAKE_FAILED));
2093 // Verify error count is properly recorded.
2094 EXPECT_EQ(1u, connectivity_monitor_->GetCountForWriteErrorCode(
2095 ERR_ADDRESS_UNREACHABLE));
2096 EXPECT_EQ(0u, connectivity_monitor_->GetCountForWriteErrorCode(
2097 ERR_CONNECTION_RESET));
2098
2099 // Simulate a default network change, write error stats should be reset.
2100 connectivity_monitor_->OnDefaultNetworkUpdated(kNewNetworkForTests);
2101 EXPECT_EQ(0u, connectivity_monitor_->GetCountForWriteErrorCode(
2102 ERR_ADDRESS_UNREACHABLE));
2103 }
2104
TEST_P(QuicChromiumClientSessionTest,WriteErrorAfterHandshakeConfirmed)2105 TEST_P(QuicChromiumClientSessionTest, WriteErrorAfterHandshakeConfirmed) {
2106 // Add a connectivity monitor for testing.
2107 default_network_ = handles::kInvalidNetworkHandle;
2108 connectivity_monitor_ =
2109 std::make_unique<QuicConnectivityMonitor>(default_network_);
2110
2111 MockQuicData quic_data(version_);
2112 int packet_num = 1;
2113 quic_data.AddWrite(SYNCHRONOUS,
2114 client_maker_.MakeInitialSettingsPacket(packet_num++));
2115 // When sending the PING packet, trigger a packet write error.
2116 quic_data.AddWrite(SYNCHRONOUS, ERR_CONNECTION_RESET);
2117 quic_data.AddRead(ASYNC, ERR_IO_PENDING);
2118 quic_data.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
2119 quic_data.AddSocketDataToFactory(&socket_factory_);
2120
2121 Initialize();
2122 CompleteCryptoHandshake();
2123
2124 // Send a ping so that client has outgoing traffic before receiving packets.
2125 session_->connection()->SendPing();
2126
2127 // Verify error count is properly recorded.
2128 EXPECT_EQ(1u, connectivity_monitor_->GetCountForWriteErrorCode(
2129 ERR_CONNECTION_RESET));
2130 EXPECT_EQ(0u, connectivity_monitor_->GetCountForWriteErrorCode(
2131 ERR_ADDRESS_UNREACHABLE));
2132
2133 connectivity_monitor_->OnIPAddressChanged();
2134
2135 // If network handle is supported, IP Address change is a no-op. Otherwise it
2136 // clears all stats.
2137 size_t expected_error_count =
2138 NetworkChangeNotifier::AreNetworkHandlesSupported() ? 1u : 0u;
2139 EXPECT_EQ(
2140 expected_error_count,
2141 connectivity_monitor_->GetCountForWriteErrorCode(ERR_CONNECTION_RESET));
2142 }
2143
2144 // Much like above, but checking that ECN marks are reported.
TEST_P(QuicChromiumClientSessionTest,ReportsReceivedEcn)2145 TEST_P(QuicChromiumClientSessionTest, ReportsReceivedEcn) {
2146 base::test::ScopedFeatureList scoped_feature_list_;
2147 scoped_feature_list_.InitAndEnableFeature(net::features::kReceiveEcn);
2148
2149 MockQuicData mock_quic_data(version_);
2150 int write_packet_num = 1, read_packet_num = 0;
2151 quic::QuicEcnCounts ecn(1, 0, 0); // 1 ECT(0) packet received
2152 mock_quic_data.AddWrite(
2153 ASYNC, client_maker_.MakeInitialSettingsPacket(write_packet_num++));
2154 mock_quic_data.AddRead(
2155 ASYNC, server_maker_.MakeInitialSettingsPacket(read_packet_num++));
2156 server_maker_.set_ecn_codepoint(quic::ECN_ECT0);
2157 mock_quic_data.AddRead(ASYNC,
2158 server_maker_.MakePingPacket(read_packet_num++));
2159 mock_quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeAckPacket(
2160 write_packet_num++, 0, 1, 0, ecn));
2161 server_maker_.set_ecn_codepoint(quic::ECN_ECT1);
2162 mock_quic_data.AddRead(ASYNC,
2163 server_maker_.MakePingPacket(read_packet_num++));
2164 server_maker_.set_ecn_codepoint(quic::ECN_CE);
2165 mock_quic_data.AddRead(ASYNC,
2166 server_maker_.MakePingPacket(read_packet_num++));
2167 ecn.ect1 = 1;
2168 ecn.ce = 1;
2169 mock_quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeAckPacket(
2170 write_packet_num++, 0, 3, 0, ecn));
2171 mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
2172
2173 mock_quic_data.AddSocketDataToFactory(&socket_factory_);
2174 Initialize();
2175 CompleteCryptoHandshake();
2176 base::RunLoop().RunUntilIdle();
2177 EXPECT_TRUE(mock_quic_data.AllReadDataConsumed());
2178 EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed());
2179 }
2180
2181 } // namespace
2182 } // namespace net::test
2183