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