1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
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_stream_factory.h"
6
7 #include <memory>
8 #include <ostream>
9 #include <utility>
10
11 #include "base/bind.h"
12 #include "base/callback.h"
13 #include "base/macros.h"
14 #include "base/run_loop.h"
15 #include "base/strings/strcat.h"
16 #include "base/strings/string_number_conversions.h"
17 #include "base/strings/string_util.h"
18 #include "base/strings/stringprintf.h"
19 #include "base/test/scoped_feature_list.h"
20 #include "base/test/simple_test_tick_clock.h"
21 #include "base/test/test_mock_time_task_runner.h"
22 #include "build/build_config.h"
23 #include "net/base/features.h"
24 #include "net/base/load_flags.h"
25 #include "net/base/mock_network_change_notifier.h"
26 #include "net/base/network_isolation_key.h"
27 #include "net/cert/ct_policy_enforcer.h"
28 #include "net/cert/do_nothing_ct_verifier.h"
29 #include "net/cert/mock_cert_verifier.h"
30 #include "net/dns/host_resolver_source.h"
31 #include "net/dns/mock_host_resolver.h"
32 #include "net/dns/public/dns_query_type.h"
33 #include "net/dns/public/secure_dns_mode.h"
34 #include "net/http/http_response_headers.h"
35 #include "net/http/http_response_info.h"
36 #include "net/http/http_server_properties.h"
37 #include "net/http/http_util.h"
38 #include "net/http/transport_security_state.h"
39 #include "net/http/transport_security_state_test_util.h"
40 #include "net/quic/address_utils.h"
41 #include "net/quic/crypto/proof_verifier_chromium.h"
42 #include "net/quic/mock_crypto_client_stream_factory.h"
43 #include "net/quic/mock_quic_context.h"
44 #include "net/quic/mock_quic_data.h"
45 #include "net/quic/properties_based_quic_server_info.h"
46 #include "net/quic/quic_chromium_alarm_factory.h"
47 #include "net/quic/quic_chromium_client_session_peer.h"
48 #include "net/quic/quic_http_stream.h"
49 #include "net/quic/quic_http_utils.h"
50 #include "net/quic/quic_server_info.h"
51 #include "net/quic/quic_stream_factory_peer.h"
52 #include "net/quic/quic_test_packet_maker.h"
53 #include "net/quic/quic_test_packet_printer.h"
54 #include "net/quic/test_task_runner.h"
55 #include "net/socket/next_proto.h"
56 #include "net/socket/socket_test_util.h"
57 #include "net/spdy/spdy_session_test_util.h"
58 #include "net/spdy/spdy_test_util_common.h"
59 #include "net/ssl/ssl_config_service_defaults.h"
60 #include "net/test/cert_test_util.h"
61 #include "net/test/gtest_util.h"
62 #include "net/test/test_data_directory.h"
63 #include "net/test/test_with_task_environment.h"
64 #include "net/third_party/quiche/src/quic/core/crypto/crypto_handshake.h"
65 #include "net/third_party/quiche/src/quic/core/crypto/quic_crypto_client_config.h"
66 #include "net/third_party/quiche/src/quic/core/crypto/quic_decrypter.h"
67 #include "net/third_party/quiche/src/quic/core/crypto/quic_encrypter.h"
68 #include "net/third_party/quiche/src/quic/core/http/quic_client_promised_info.h"
69 #include "net/third_party/quiche/src/quic/core/quic_constants.h"
70 #include "net/third_party/quiche/src/quic/core/quic_utils.h"
71 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
72 #include "net/third_party/quiche/src/quic/test_tools/mock_clock.h"
73 #include "net/third_party/quiche/src/quic/test_tools/mock_random.h"
74 #include "net/third_party/quiche/src/quic/test_tools/quic_config_peer.h"
75 #include "net/third_party/quiche/src/quic/test_tools/quic_spdy_session_peer.h"
76 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
77 #include "net/third_party/quiche/src/spdy/core/spdy_test_utils.h"
78 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
79 #include "testing/gmock/include/gmock/gmock.h"
80 #include "testing/gtest/include/gtest/gtest.h"
81 #include "url/gurl.h"
82
83 using std::string;
84
85 namespace net {
86
87 namespace test {
88
89 namespace {
90
91 enum DestinationType {
92 // In pooling tests with two requests for different origins to the same
93 // destination, the destination should be
94 SAME_AS_FIRST, // the same as the first origin,
95 SAME_AS_SECOND, // the same as the second origin, or
96 DIFFERENT, // different from both.
97 };
98
99 const char kDefaultServerHostName[] = "www.example.org";
100 const char kServer2HostName[] = "mail.example.org";
101 const char kDifferentHostname[] = "different.example.com";
102 const int kDefaultServerPort = 443;
103 const char kDefaultUrl[] = "https://www.example.org/";
104 const char kServer2Url[] = "https://mail.example.org/";
105 const char kServer3Url[] = "https://docs.example.org/";
106 const char kServer4Url[] = "https://images.example.org/";
107 const int kDefaultRTTMilliSecs = 300;
108 const size_t kMinRetryTimeForDefaultNetworkSecs = 1;
109 const size_t kWaitTimeForNewNetworkSecs = 10;
110 const IPAddress kCachedIPAddress = IPAddress(192, 168, 0, 2);
111 const char kNonCachedIPAddress[] = "192.168.0.1";
112
113 // Run QuicStreamFactoryTest instances with all value combinations of version
114 // and enable_connection_racting.
115 struct TestParams {
116 quic::ParsedQuicVersion version;
117 bool client_headers_include_h2_stream_dependency;
118 };
119
120 // Used by ::testing::PrintToStringParamName().
PrintToString(const TestParams & p)121 std::string PrintToString(const TestParams& p) {
122 return base::StrCat(
123 {ParsedQuicVersionToString(p.version), "_",
124 (p.client_headers_include_h2_stream_dependency ? "" : "No"),
125 "Dependency"});
126 }
127
GetTestParams()128 std::vector<TestParams> GetTestParams() {
129 std::vector<TestParams> params;
130 quic::ParsedQuicVersionVector all_supported_versions =
131 quic::AllSupportedVersions();
132 for (const auto& version : all_supported_versions) {
133 params.push_back(TestParams{version, false});
134 params.push_back(TestParams{version, true});
135 }
136 return params;
137 }
138
139 // Run QuicStreamFactoryWithDestinationTest instances with all value
140 // combinations of version, enable_connection_racting, and destination_type.
141 struct PoolingTestParams {
142 quic::ParsedQuicVersion version;
143 DestinationType destination_type;
144 bool client_headers_include_h2_stream_dependency;
145 };
146
147 // Used by ::testing::PrintToStringParamName().
PrintToString(const PoolingTestParams & p)148 std::string PrintToString(const PoolingTestParams& p) {
149 const char* destination_string = "";
150 switch (p.destination_type) {
151 case SAME_AS_FIRST:
152 destination_string = "SAME_AS_FIRST";
153 break;
154 case SAME_AS_SECOND:
155 destination_string = "SAME_AS_SECOND";
156 break;
157 case DIFFERENT:
158 destination_string = "DIFFERENT";
159 break;
160 }
161 return base::StrCat(
162 {ParsedQuicVersionToString(p.version), "_", destination_string, "_",
163 (p.client_headers_include_h2_stream_dependency ? "" : "No"),
164 "Dependency"});
165 }
166
GetPoolingTestParams()167 std::vector<PoolingTestParams> GetPoolingTestParams() {
168 std::vector<PoolingTestParams> params;
169 quic::ParsedQuicVersionVector all_supported_versions =
170 quic::AllSupportedVersions();
171 for (const quic::ParsedQuicVersion& version : all_supported_versions) {
172 params.push_back(PoolingTestParams{version, SAME_AS_FIRST, false});
173 params.push_back(PoolingTestParams{version, SAME_AS_FIRST, true});
174 params.push_back(PoolingTestParams{version, SAME_AS_SECOND, false});
175 params.push_back(PoolingTestParams{version, SAME_AS_SECOND, true});
176 params.push_back(PoolingTestParams{version, DIFFERENT, false});
177 params.push_back(PoolingTestParams{version, DIFFERENT, true});
178 }
179 return params;
180 }
181
182 } // namespace
183
184 class QuicHttpStreamPeer {
185 public:
GetSessionHandle(HttpStream * stream)186 static QuicChromiumClientSession::Handle* GetSessionHandle(
187 HttpStream* stream) {
188 return static_cast<QuicHttpStream*>(stream)->quic_session();
189 }
190 };
191
192 // TestMigrationSocketFactory will vend sockets with incremental port number.
193 class TestMigrationSocketFactory : public MockClientSocketFactory {
194 public:
TestMigrationSocketFactory()195 TestMigrationSocketFactory() : next_source_port_num_(1u) {}
~TestMigrationSocketFactory()196 ~TestMigrationSocketFactory() override {}
197
CreateDatagramClientSocket(DatagramSocket::BindType bind_type,NetLog * net_log,const NetLogSource & source)198 std::unique_ptr<DatagramClientSocket> CreateDatagramClientSocket(
199 DatagramSocket::BindType bind_type,
200 NetLog* net_log,
201 const NetLogSource& source) override {
202 SocketDataProvider* data_provider = mock_data().GetNext();
203 std::unique_ptr<MockUDPClientSocket> socket(
204 new MockUDPClientSocket(data_provider, net_log));
205 socket->set_source_port(next_source_port_num_++);
206 return std::move(socket);
207 }
208
209 private:
210 uint16_t next_source_port_num_;
211
212 DISALLOW_COPY_AND_ASSIGN(TestMigrationSocketFactory);
213 };
214
215 class QuicStreamFactoryTestBase : public WithTaskEnvironment {
216 protected:
QuicStreamFactoryTestBase(quic::ParsedQuicVersion version,bool client_headers_include_h2_stream_dependency)217 QuicStreamFactoryTestBase(quic::ParsedQuicVersion version,
218 bool client_headers_include_h2_stream_dependency)
219 : host_resolver_(new MockHostResolver),
220 ssl_config_service_(new SSLConfigServiceDefaults),
221 socket_factory_(new MockClientSocketFactory),
222 runner_(new TestTaskRunner(context_.mock_clock())),
223 version_(version),
224 client_maker_(version_,
225 quic::QuicUtils::CreateRandomConnectionId(
226 context_.random_generator()),
227 context_.clock(),
228 kDefaultServerHostName,
229 quic::Perspective::IS_CLIENT,
230 client_headers_include_h2_stream_dependency),
231 server_maker_(version_,
232 quic::QuicUtils::CreateRandomConnectionId(
233 context_.random_generator()),
234 context_.clock(),
235 kDefaultServerHostName,
236 quic::Perspective::IS_SERVER,
237 false),
238 http_server_properties_(std::make_unique<HttpServerProperties>()),
239 cert_verifier_(std::make_unique<MockCertVerifier>()),
240 cert_transparency_verifier_(std::make_unique<DoNothingCTVerifier>()),
241 scoped_mock_network_change_notifier_(nullptr),
242 factory_(nullptr),
243 host_port_pair_(kDefaultServerHostName, kDefaultServerPort),
244 url_(kDefaultUrl),
245 url2_(kServer2Url),
246 url3_(kServer3Url),
247 url4_(kServer4Url),
248 privacy_mode_(PRIVACY_MODE_DISABLED),
249 failed_on_default_network_callback_(base::BindRepeating(
250 &QuicStreamFactoryTestBase::OnFailedOnDefaultNetwork,
251 base::Unretained(this))),
252 failed_on_default_network_(false),
253 quic_params_(context_.params()) {
254 FLAGS_quic_enable_http3_grease_randomness = false;
255 quic_params_->headers_include_h2_stream_dependency =
256 client_headers_include_h2_stream_dependency;
257 context_.AdvanceTime(quic::QuicTime::Delta::FromSeconds(1));
258 }
259
Initialize()260 void Initialize() {
261 DCHECK(!factory_);
262 factory_ = std::make_unique<QuicStreamFactory>(
263 net_log_.net_log(), host_resolver_.get(), ssl_config_service_.get(),
264 socket_factory_.get(), http_server_properties_.get(),
265 cert_verifier_.get(), &ct_policy_enforcer_, &transport_security_state_,
266 cert_transparency_verifier_.get(), /*sct_auditing_delegate=*/nullptr,
267 /*SocketPerformanceWatcherFactory*/ nullptr,
268 &crypto_client_stream_factory_, &context_);
269 }
270
InitializeConnectionMigrationV2Test(NetworkChangeNotifier::NetworkList connected_networks)271 void InitializeConnectionMigrationV2Test(
272 NetworkChangeNotifier::NetworkList connected_networks) {
273 scoped_mock_network_change_notifier_.reset(
274 new ScopedMockNetworkChangeNotifier());
275 MockNetworkChangeNotifier* mock_ncn =
276 scoped_mock_network_change_notifier_->mock_network_change_notifier();
277 mock_ncn->ForceNetworkHandlesSupported();
278 mock_ncn->SetConnectedNetworksList(connected_networks);
279 quic_params_->migrate_sessions_on_network_change_v2 = true;
280 quic_params_->migrate_sessions_early_v2 = true;
281 quic_params_->allow_port_migration = false;
282 socket_factory_.reset(new TestMigrationSocketFactory);
283 Initialize();
284 }
285
CreateStream(QuicStreamRequest * request)286 std::unique_ptr<HttpStream> CreateStream(QuicStreamRequest* request) {
287 std::unique_ptr<QuicChromiumClientSession::Handle> session =
288 request->ReleaseSessionHandle();
289 if (!session || !session->IsConnected())
290 return nullptr;
291
292 return std::make_unique<QuicHttpStream>(std::move(session));
293 }
294
HasActiveSession(const HostPortPair & host_port_pair,const NetworkIsolationKey & network_isolation_key=NetworkIsolationKey ())295 bool HasActiveSession(const HostPortPair& host_port_pair,
296 const NetworkIsolationKey& network_isolation_key =
297 NetworkIsolationKey()) {
298 quic::QuicServerId server_id(host_port_pair.host(), host_port_pair.port(),
299 false);
300 return QuicStreamFactoryPeer::HasActiveSession(factory_.get(), server_id,
301 network_isolation_key);
302 }
303
HasLiveSession(const HostPortPair & host_port_pair)304 bool HasLiveSession(const HostPortPair& host_port_pair) {
305 quic::QuicServerId server_id(host_port_pair.host(), host_port_pair.port(),
306 false);
307 return QuicStreamFactoryPeer::HasLiveSession(factory_.get(), host_port_pair,
308 server_id);
309 }
310
HasActiveJob(const HostPortPair & host_port_pair,const PrivacyMode privacy_mode)311 bool HasActiveJob(const HostPortPair& host_port_pair,
312 const PrivacyMode privacy_mode) {
313 quic::QuicServerId server_id(host_port_pair.host(), host_port_pair.port(),
314 privacy_mode == PRIVACY_MODE_ENABLED);
315 return QuicStreamFactoryPeer::HasActiveJob(factory_.get(), server_id);
316 }
317
318 // Get the pending, not activated session, if there is only one session alive.
GetPendingSession(const HostPortPair & host_port_pair)319 QuicChromiumClientSession* GetPendingSession(
320 const HostPortPair& host_port_pair) {
321 quic::QuicServerId server_id(host_port_pair.host(), host_port_pair.port(),
322 false);
323 return QuicStreamFactoryPeer::GetPendingSession(factory_.get(), server_id,
324 host_port_pair);
325 }
326
GetActiveSession(const HostPortPair & host_port_pair,const NetworkIsolationKey & network_isolation_key=NetworkIsolationKey ())327 QuicChromiumClientSession* GetActiveSession(
328 const HostPortPair& host_port_pair,
329 const NetworkIsolationKey& network_isolation_key =
330 NetworkIsolationKey()) {
331 quic::QuicServerId server_id(host_port_pair.host(), host_port_pair.port(),
332 false);
333 return QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server_id,
334 network_isolation_key);
335 }
336
GetSourcePortForNewSession(const HostPortPair & destination)337 int GetSourcePortForNewSession(const HostPortPair& destination) {
338 return GetSourcePortForNewSessionInner(destination, false);
339 }
340
GetSourcePortForNewSessionAndGoAway(const HostPortPair & destination)341 int GetSourcePortForNewSessionAndGoAway(const HostPortPair& destination) {
342 return GetSourcePortForNewSessionInner(destination, true);
343 }
344
GetSourcePortForNewSessionInner(const HostPortPair & destination,bool goaway_received)345 int GetSourcePortForNewSessionInner(const HostPortPair& destination,
346 bool goaway_received) {
347 // Should only be called if there is no active session for this destination.
348 EXPECT_FALSE(HasActiveSession(destination));
349 size_t socket_count = socket_factory_->udp_client_socket_ports().size();
350
351 MockQuicData socket_data(version_);
352 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
353 if (VersionUsesHttp3(version_.transport_version))
354 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
355 socket_data.AddSocketDataToFactory(socket_factory_.get());
356
357 QuicStreamRequest request(factory_.get());
358 GURL url("https://" + destination.host() + "/");
359 EXPECT_EQ(
360 ERR_IO_PENDING,
361 request.Request(
362 destination, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
363 NetworkIsolationKey(), false /* disable_secure_dns */,
364 /*cert_verify_flags=*/0, url, net_log_, &net_error_details_,
365 failed_on_default_network_callback_, callback_.callback()));
366
367 EXPECT_THAT(callback_.WaitForResult(), IsOk());
368 std::unique_ptr<HttpStream> stream = CreateStream(&request);
369 EXPECT_TRUE(stream.get());
370 stream.reset();
371
372 QuicChromiumClientSession* session = GetActiveSession(destination);
373
374 if (socket_count + 1 != socket_factory_->udp_client_socket_ports().size()) {
375 ADD_FAILURE();
376 return 0;
377 }
378
379 if (goaway_received) {
380 quic::QuicGoAwayFrame goaway(quic::kInvalidControlFrameId,
381 quic::QUIC_NO_ERROR, 1, "");
382 session->connection()->OnGoAwayFrame(goaway);
383 }
384
385 factory_->OnSessionClosed(session);
386 EXPECT_FALSE(HasActiveSession(destination));
387 EXPECT_TRUE(socket_data.AllReadDataConsumed());
388 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
389 return socket_factory_->udp_client_socket_ports()[socket_count];
390 }
391
392 std::unique_ptr<quic::QuicEncryptedPacket>
ConstructClientConnectionClosePacket(uint64_t num)393 ConstructClientConnectionClosePacket(uint64_t num) {
394 return client_maker_.MakeConnectionClosePacket(
395 num, false, quic::QUIC_CRYPTO_VERSION_NOT_SUPPORTED, "Time to panic!");
396 }
397
ConstructClientRstPacket(uint64_t packet_number,quic::QuicRstStreamErrorCode error_code)398 std::unique_ptr<quic::QuicEncryptedPacket> ConstructClientRstPacket(
399 uint64_t packet_number,
400 quic::QuicRstStreamErrorCode error_code) {
401 quic::QuicStreamId stream_id =
402 GetNthClientInitiatedBidirectionalStreamId(0);
403 return client_maker_.MakeRstPacket(packet_number, true, stream_id,
404 error_code);
405 }
406
DefaultProofVerifyDetails()407 static ProofVerifyDetailsChromium DefaultProofVerifyDetails() {
408 // Load a certificate that is valid for *.example.org
409 scoped_refptr<X509Certificate> test_cert(
410 ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem"));
411 EXPECT_TRUE(test_cert.get());
412 ProofVerifyDetailsChromium verify_details;
413 verify_details.cert_verify_result.verified_cert = test_cert;
414 verify_details.cert_verify_result.is_issued_by_known_root = true;
415 return verify_details;
416 }
417
NotifyIPAddressChanged()418 void NotifyIPAddressChanged() {
419 NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
420 // Spin the message loop so the notification is delivered.
421 base::RunLoop().RunUntilIdle();
422 }
423
ConstructGetRequestPacket(uint64_t packet_number,quic::QuicStreamId stream_id,bool should_include_version,bool fin)424 std::unique_ptr<quic::QuicEncryptedPacket> ConstructGetRequestPacket(
425 uint64_t packet_number,
426 quic::QuicStreamId stream_id,
427 bool should_include_version,
428 bool fin) {
429 spdy::Http2HeaderBlock headers =
430 client_maker_.GetRequestHeaders("GET", "https", "/");
431 spdy::SpdyPriority priority =
432 ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY);
433 size_t spdy_headers_frame_len;
434 return client_maker_.MakeRequestHeadersPacket(
435 packet_number, stream_id, should_include_version, fin, priority,
436 std::move(headers), 0, &spdy_headers_frame_len);
437 }
438
ConstructGetRequestPacket(uint64_t packet_number,quic::QuicStreamId stream_id,quic::QuicStreamId parent_stream_id,bool should_include_version,bool fin)439 std::unique_ptr<quic::QuicEncryptedPacket> ConstructGetRequestPacket(
440 uint64_t packet_number,
441 quic::QuicStreamId stream_id,
442 quic::QuicStreamId parent_stream_id,
443 bool should_include_version,
444 bool fin) {
445 spdy::Http2HeaderBlock headers =
446 client_maker_.GetRequestHeaders("GET", "https", "/");
447 spdy::SpdyPriority priority =
448 ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY);
449 size_t spdy_headers_frame_len;
450 return client_maker_.MakeRequestHeadersPacket(
451 packet_number, stream_id, should_include_version, fin, priority,
452 std::move(headers), parent_stream_id, &spdy_headers_frame_len);
453 }
454
ConstructOkResponsePacket(uint64_t packet_number,quic::QuicStreamId stream_id,bool should_include_version,bool fin)455 std::unique_ptr<quic::QuicEncryptedPacket> ConstructOkResponsePacket(
456 uint64_t packet_number,
457 quic::QuicStreamId stream_id,
458 bool should_include_version,
459 bool fin) {
460 spdy::Http2HeaderBlock headers = server_maker_.GetResponseHeaders("200 OK");
461 size_t spdy_headers_frame_len;
462 return server_maker_.MakeResponseHeadersPacket(
463 packet_number, stream_id, should_include_version, fin,
464 std::move(headers), &spdy_headers_frame_len);
465 }
466
ConstructInitialSettingsPacket()467 std::unique_ptr<quic::QuicReceivedPacket> ConstructInitialSettingsPacket() {
468 return client_maker_.MakeInitialSettingsPacket(1);
469 }
470
ConstructInitialSettingsPacket(uint64_t packet_number)471 std::unique_ptr<quic::QuicReceivedPacket> ConstructInitialSettingsPacket(
472 uint64_t packet_number) {
473 return client_maker_.MakeInitialSettingsPacket(packet_number);
474 }
475
476 // Helper method for server migration tests.
VerifyServerMigration(const quic::QuicConfig & config,IPEndPoint expected_address)477 void VerifyServerMigration(const quic::QuicConfig& config,
478 IPEndPoint expected_address) {
479 quic_params_->allow_server_migration = true;
480 Initialize();
481
482 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
483 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
484 crypto_client_stream_factory_.SetConfig(config);
485
486 // Set up first socket data provider.
487 MockQuicData socket_data1(version_);
488 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
489 socket_data1.AddSocketDataToFactory(socket_factory_.get());
490
491 // Set up second socket data provider that is used after
492 // migration.
493 MockQuicData socket_data2(version_);
494 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
495 int packet_num = 1;
496 if (VersionUsesHttp3(version_.transport_version)) {
497 socket_data2.AddWrite(SYNCHRONOUS,
498 ConstructInitialSettingsPacket(packet_num++));
499 }
500 socket_data2.AddWrite(
501 SYNCHRONOUS,
502 client_maker_.MakePingPacket(packet_num++, /*include_version=*/true));
503 if (VersionUsesHttp3(version_.transport_version)) {
504 socket_data2.AddWrite(
505 SYNCHRONOUS, client_maker_.MakeDataPacket(
506 packet_num++, GetQpackDecoderStreamId(), true, false,
507 StreamCancellationQpackDecoderInstruction(0)));
508 }
509 socket_data2.AddWrite(
510 SYNCHRONOUS,
511 client_maker_.MakeRstPacket(
512 packet_num++, true, GetNthClientInitiatedBidirectionalStreamId(0),
513 quic::QUIC_STREAM_CANCELLED));
514 socket_data2.AddSocketDataToFactory(socket_factory_.get());
515
516 // Create request and QuicHttpStream.
517 QuicStreamRequest request(factory_.get());
518 EXPECT_EQ(
519 ERR_IO_PENDING,
520 request.Request(
521 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
522 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
523 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
524 failed_on_default_network_callback_, callback_.callback()));
525 EXPECT_EQ(OK, callback_.WaitForResult());
526
527 // Run QuicChromiumClientSession::WriteToNewSocket()
528 // posted by QuicChromiumClientSession::MigrateToSocket().
529 base::RunLoop().RunUntilIdle();
530
531 std::unique_ptr<HttpStream> stream = CreateStream(&request);
532 EXPECT_TRUE(stream.get());
533
534 // Cause QUIC stream to be created.
535 HttpRequestInfo request_info;
536 request_info.method = "GET";
537 request_info.url = GURL("https://www.example.org/");
538 request_info.traffic_annotation =
539 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
540 EXPECT_EQ(OK,
541 stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
542 net_log_, CompletionOnceCallback()));
543 // Ensure that session is alive and active.
544 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
545 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
546 EXPECT_TRUE(HasActiveSession(host_port_pair_));
547
548 IPEndPoint actual_address;
549 session->GetDefaultSocket()->GetPeerAddress(&actual_address);
550 EXPECT_EQ(actual_address, expected_address);
551 DVLOG(1) << "Socket connected to: " << actual_address.address().ToString()
552 << " " << actual_address.port();
553 DVLOG(1) << "Expected address: " << expected_address.address().ToString()
554 << " " << expected_address.port();
555
556 stream.reset();
557 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
558 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
559 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
560 }
561
562 // Verifies that the QUIC stream factory is initialized correctly.
563 // If |vary_network_isolation_key| is true, stores data for two different
564 // NetworkIsolationKeys, but the same server. If false, stores data for two
565 // different servers, using the same NetworkIsolationKey.
VerifyInitialization(bool vary_network_isolation_key)566 void VerifyInitialization(bool vary_network_isolation_key) {
567 const url::Origin kOrigin1 = url::Origin::Create(GURL("https://foo.test/"));
568 const url::Origin kOrigin2 = url::Origin::Create(GURL("https://bar.test/"));
569
570 NetworkIsolationKey network_isolation_key1(kOrigin1, kOrigin1);
571 quic::QuicServerId quic_server_id1(
572 kDefaultServerHostName, kDefaultServerPort, PRIVACY_MODE_DISABLED);
573
574 NetworkIsolationKey network_isolation_key2;
575 quic::QuicServerId quic_server_id2;
576
577 if (vary_network_isolation_key) {
578 network_isolation_key2 = NetworkIsolationKey(kOrigin2, kOrigin2);
579 quic_server_id2 = quic_server_id1;
580 } else {
581 network_isolation_key2 = network_isolation_key1;
582 quic_server_id2 = quic::QuicServerId(kServer2HostName, kDefaultServerPort,
583 PRIVACY_MODE_DISABLED);
584 }
585
586 quic_params_->max_server_configs_stored_in_properties = 1;
587 quic_params_->idle_connection_timeout = base::TimeDelta::FromSeconds(500);
588 Initialize();
589 factory_->set_is_quic_known_to_work_on_current_network(true);
590 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
591 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
592 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
593 crypto_client_stream_factory_.set_handshake_mode(
594 MockCryptoClientStream::ZERO_RTT);
595 const quic::QuicConfig* config =
596 QuicStreamFactoryPeer::GetConfig(factory_.get());
597 EXPECT_EQ(500, config->IdleNetworkTimeout().ToSeconds());
598
599 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), runner_.get());
600
601 const AlternativeService alternative_service1(
602 kProtoQUIC, host_port_pair_.host(), host_port_pair_.port());
603 AlternativeServiceInfoVector alternative_service_info_vector;
604 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
605 alternative_service_info_vector.push_back(
606 AlternativeServiceInfo::CreateQuicAlternativeServiceInfo(
607 alternative_service1, expiration, {version_}));
608 http_server_properties_->SetAlternativeServices(
609 url::SchemeHostPort("https", quic_server_id1.host(),
610 quic_server_id1.port()),
611 network_isolation_key1, alternative_service_info_vector);
612
613 const AlternativeService alternative_service2(
614 kProtoQUIC, quic_server_id2.host(), quic_server_id2.port());
615 AlternativeServiceInfoVector alternative_service_info_vector2;
616 alternative_service_info_vector2.push_back(
617 AlternativeServiceInfo::CreateQuicAlternativeServiceInfo(
618 alternative_service2, expiration, {version_}));
619
620 http_server_properties_->SetAlternativeServices(
621 url::SchemeHostPort("https", quic_server_id2.host(),
622 quic_server_id2.port()),
623 network_isolation_key2, alternative_service_info_vector2);
624 // Verify that the properties of both QUIC servers are stored in the
625 // HTTP properties map.
626 EXPECT_EQ(2U,
627 http_server_properties_->server_info_map_for_testing().size());
628
629 http_server_properties_->SetMaxServerConfigsStoredInProperties(
630 kDefaultMaxQuicServerEntries);
631
632 std::unique_ptr<QuicServerInfo> quic_server_info =
633 std::make_unique<PropertiesBasedQuicServerInfo>(
634 quic_server_id1, network_isolation_key1,
635 http_server_properties_.get());
636
637 // Update quic_server_info's server_config and persist it.
638 QuicServerInfo::State* state = quic_server_info->mutable_state();
639 // Minimum SCFG that passes config validation checks.
640 const char scfg[] = {// SCFG
641 0x53, 0x43, 0x46, 0x47,
642 // num entries
643 0x01, 0x00,
644 // padding
645 0x00, 0x00,
646 // EXPY
647 0x45, 0x58, 0x50, 0x59,
648 // EXPY end offset
649 0x08, 0x00, 0x00, 0x00,
650 // Value
651 '1', '2', '3', '4', '5', '6', '7', '8'};
652
653 // Create temporary strings because Persist() clears string data in |state|.
654 string server_config(reinterpret_cast<const char*>(&scfg), sizeof(scfg));
655 string source_address_token("test_source_address_token");
656 string cert_sct("test_cert_sct");
657 string chlo_hash("test_chlo_hash");
658 string signature("test_signature");
659 string test_cert("test_cert");
660 std::vector<string> certs;
661 certs.push_back(test_cert);
662 state->server_config = server_config;
663 state->source_address_token = source_address_token;
664 state->cert_sct = cert_sct;
665 state->chlo_hash = chlo_hash;
666 state->server_config_sig = signature;
667 state->certs = certs;
668
669 quic_server_info->Persist();
670
671 std::unique_ptr<QuicServerInfo> quic_server_info2 =
672 std::make_unique<PropertiesBasedQuicServerInfo>(
673 quic_server_id2, network_isolation_key2,
674 http_server_properties_.get());
675 // Update quic_server_info2's server_config and persist it.
676 QuicServerInfo::State* state2 = quic_server_info2->mutable_state();
677
678 // Minimum SCFG that passes config validation checks.
679 const char scfg2[] = {// SCFG
680 0x53, 0x43, 0x46, 0x47,
681 // num entries
682 0x01, 0x00,
683 // padding
684 0x00, 0x00,
685 // EXPY
686 0x45, 0x58, 0x50, 0x59,
687 // EXPY end offset
688 0x08, 0x00, 0x00, 0x00,
689 // Value
690 '8', '7', '3', '4', '5', '6', '2', '1'};
691
692 // Create temporary strings because Persist() clears string data in
693 // |state2|.
694 string server_config2(reinterpret_cast<const char*>(&scfg2), sizeof(scfg2));
695 string source_address_token2("test_source_address_token2");
696 string cert_sct2("test_cert_sct2");
697 string chlo_hash2("test_chlo_hash2");
698 string signature2("test_signature2");
699 string test_cert2("test_cert2");
700 std::vector<string> certs2;
701 certs2.push_back(test_cert2);
702 state2->server_config = server_config2;
703 state2->source_address_token = source_address_token2;
704 state2->cert_sct = cert_sct2;
705 state2->chlo_hash = chlo_hash2;
706 state2->server_config_sig = signature2;
707 state2->certs = certs2;
708
709 quic_server_info2->Persist();
710
711 // Verify the MRU order is maintained.
712 const HttpServerProperties::QuicServerInfoMap& quic_server_info_map =
713 http_server_properties_->quic_server_info_map();
714 EXPECT_EQ(2u, quic_server_info_map.size());
715 auto quic_server_info_map_it = quic_server_info_map.begin();
716 EXPECT_EQ(quic_server_info_map_it->first.server_id, quic_server_id2);
717 ++quic_server_info_map_it;
718 EXPECT_EQ(quic_server_info_map_it->first.server_id, quic_server_id1);
719
720 host_resolver_->rules()->AddIPLiteralRule(host_port_pair_.host(),
721 "192.168.0.1", "");
722
723 // Create a session and verify that the cached state is loaded.
724 MockQuicData socket_data(version_);
725 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
726 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
727 if (VersionUsesHttp3(version_.transport_version))
728 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
729 socket_data.AddSocketDataToFactory(socket_factory_.get());
730
731 QuicStreamRequest request(factory_.get());
732 EXPECT_EQ(ERR_IO_PENDING,
733 request.Request(
734 HostPortPair(quic_server_id1.host(), quic_server_id1.port()),
735 version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
736 network_isolation_key1, false /* disable_secure_dns */,
737 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
738 failed_on_default_network_callback_, callback_.callback()));
739 EXPECT_THAT(callback_.WaitForResult(), IsOk());
740
741 EXPECT_FALSE(QuicStreamFactoryPeer::CryptoConfigCacheIsEmpty(
742 factory_.get(), quic_server_id1, network_isolation_key1));
743
744 std::unique_ptr<QuicCryptoClientConfigHandle> crypto_config_handle1 =
745 QuicStreamFactoryPeer::GetCryptoConfig(factory_.get(),
746 network_isolation_key1);
747 quic::QuicCryptoClientConfig::CachedState* cached =
748 crypto_config_handle1->GetConfig()->LookupOrCreate(quic_server_id1);
749 EXPECT_FALSE(cached->server_config().empty());
750 EXPECT_TRUE(cached->GetServerConfig());
751 EXPECT_EQ(server_config, cached->server_config());
752 EXPECT_EQ(source_address_token, cached->source_address_token());
753 EXPECT_EQ(cert_sct, cached->cert_sct());
754 EXPECT_EQ(chlo_hash, cached->chlo_hash());
755 EXPECT_EQ(signature, cached->signature());
756 ASSERT_EQ(1U, cached->certs().size());
757 EXPECT_EQ(test_cert, cached->certs()[0]);
758
759 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
760
761 // Create a session and verify that the cached state is loaded.
762 MockQuicData socket_data2(version_);
763 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
764 client_maker_.Reset();
765 if (VersionUsesHttp3(version_.transport_version))
766 socket_data2.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
767 socket_data2.AddSocketDataToFactory(socket_factory_.get());
768
769 host_resolver_->rules()->AddIPLiteralRule(host_port_pair_.host(),
770 "192.168.0.2", "");
771
772 QuicStreamRequest request2(factory_.get());
773 EXPECT_EQ(
774 ERR_IO_PENDING,
775 request2.Request(
776 HostPortPair(quic_server_id2.host(), quic_server_id2.port()),
777 version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
778 network_isolation_key2, false /* disable_secure_dns */,
779 /*cert_verify_flags=*/0,
780 vary_network_isolation_key ? url_
781 : GURL("https://mail.example.org/"),
782 net_log_, &net_error_details_, failed_on_default_network_callback_,
783 callback_.callback()));
784 EXPECT_THAT(callback_.WaitForResult(), IsOk());
785
786 EXPECT_FALSE(QuicStreamFactoryPeer::CryptoConfigCacheIsEmpty(
787 factory_.get(), quic_server_id2, network_isolation_key2));
788 std::unique_ptr<QuicCryptoClientConfigHandle> crypto_config_handle2 =
789 QuicStreamFactoryPeer::GetCryptoConfig(factory_.get(),
790 network_isolation_key2);
791 quic::QuicCryptoClientConfig::CachedState* cached2 =
792 crypto_config_handle2->GetConfig()->LookupOrCreate(quic_server_id2);
793 EXPECT_FALSE(cached2->server_config().empty());
794 EXPECT_TRUE(cached2->GetServerConfig());
795 EXPECT_EQ(server_config2, cached2->server_config());
796 EXPECT_EQ(source_address_token2, cached2->source_address_token());
797 EXPECT_EQ(cert_sct2, cached2->cert_sct());
798 EXPECT_EQ(chlo_hash2, cached2->chlo_hash());
799 EXPECT_EQ(signature2, cached2->signature());
800 ASSERT_EQ(1U, cached->certs().size());
801 EXPECT_EQ(test_cert2, cached2->certs()[0]);
802 }
803
RunTestLoopUntilIdle()804 void RunTestLoopUntilIdle() {
805 while (!runner_->GetPostedTasks().empty())
806 runner_->RunNextTask();
807 }
808
GetNthClientInitiatedBidirectionalStreamId(int n) const809 quic::QuicStreamId GetNthClientInitiatedBidirectionalStreamId(int n) const {
810 return quic::test::GetNthClientInitiatedBidirectionalStreamId(
811 version_.transport_version, n);
812 }
813
GetQpackDecoderStreamId() const814 quic::QuicStreamId GetQpackDecoderStreamId() const {
815 return quic::test::GetNthClientInitiatedUnidirectionalStreamId(
816 version_.transport_version, 1);
817 }
818
StreamCancellationQpackDecoderInstruction(int n) const819 std::string StreamCancellationQpackDecoderInstruction(int n) const {
820 return StreamCancellationQpackDecoderInstruction(n, true);
821 }
822
StreamCancellationQpackDecoderInstruction(int n,bool create_stream) const823 std::string StreamCancellationQpackDecoderInstruction(
824 int n,
825 bool create_stream) const {
826 const quic::QuicStreamId cancelled_stream_id =
827 GetNthClientInitiatedBidirectionalStreamId(n);
828 EXPECT_LT(cancelled_stream_id, 63u);
829
830 const unsigned char opcode = 0x40;
831 if (create_stream) {
832 return {0x03, opcode | static_cast<unsigned char>(cancelled_stream_id)};
833 } else {
834 return {opcode | static_cast<unsigned char>(cancelled_stream_id)};
835 }
836 }
837
ConstructDataHeader(size_t body_len)838 std::string ConstructDataHeader(size_t body_len) {
839 if (!version_.HasIetfQuicFrames()) {
840 return "";
841 }
842 std::unique_ptr<char[]> buffer;
843 auto header_length =
844 quic::HttpEncoder::SerializeDataFrameHeader(body_len, &buffer);
845 return std::string(buffer.get(), header_length);
846 }
847
ConstructServerDataPacket(uint64_t packet_number,quic::QuicStreamId stream_id,bool should_include_version,bool fin,absl::string_view data)848 std::unique_ptr<quic::QuicEncryptedPacket> ConstructServerDataPacket(
849 uint64_t packet_number,
850 quic::QuicStreamId stream_id,
851 bool should_include_version,
852 bool fin,
853 absl::string_view data) {
854 return server_maker_.MakeDataPacket(packet_number, stream_id,
855 should_include_version, fin, data);
856 }
857
GetNthServerInitiatedUnidirectionalStreamId(int n)858 quic::QuicStreamId GetNthServerInitiatedUnidirectionalStreamId(int n) {
859 return quic::test::GetNthServerInitiatedUnidirectionalStreamId(
860 version_.transport_version, n);
861 }
862
OnFailedOnDefaultNetwork(int rv)863 void OnFailedOnDefaultNetwork(int rv) { failed_on_default_network_ = true; }
864
865 // Helper methods for tests of connection migration on write error.
866 void TestMigrationOnWriteErrorNonMigratableStream(IoMode write_error_mode,
867 bool migrate_idle_sessions);
868 // Migratable stream triggers write error.
869 void TestMigrationOnWriteErrorMixedStreams(IoMode write_error_mode);
870 // Non-migratable stream triggers write error.
871 void TestMigrationOnWriteErrorMixedStreams2(IoMode write_error_mode);
872 void TestMigrationOnWriteErrorMigrationDisabled(IoMode write_error_mode);
873 void TestMigrationOnWriteError(IoMode write_error_mode);
874 void TestMigrationOnWriteErrorWithMultipleRequests(IoMode write_error_mode);
875 void TestMigrationOnWriteErrorNoNewNetwork(IoMode write_error_mode);
876 void TestMigrationOnMultipleWriteErrors(
877 IoMode write_error_mode_on_old_network,
878 IoMode write_error_mode_on_new_network);
879 void TestMigrationOnNetworkNotificationWithWriteErrorQueuedLater(
880 bool disconnected);
881 void TestMigrationOnWriteErrorWithNotificationQueuedLater(bool disconnected);
882 void TestMigrationOnNetworkDisconnected(bool async_write_before);
883 void TestMigrationOnNetworkMadeDefault(IoMode write_mode);
884 void TestMigrationOnPathDegrading(bool async_write_before);
885 void TestMigrateSessionWithDrainingStream(
886 IoMode write_mode_for_queued_packet);
887 void TestMigrationOnWriteErrorPauseBeforeConnected(IoMode write_error_mode);
888 void TestMigrationOnWriteErrorWithMultipleNotifications(
889 IoMode write_error_mode,
890 bool disconnect_before_connect);
891 void TestNoAlternateNetworkBeforeHandshake(quic::QuicErrorCode error);
892 void TestNewConnectionOnAlternateNetworkBeforeHandshake(
893 quic::QuicErrorCode error);
894 void TestOnNetworkMadeDefaultNonMigratableStream(bool migrate_idle_sessions);
895 void TestMigrateSessionEarlyNonMigratableStream(bool migrate_idle_sessions);
896 void TestOnNetworkDisconnectedNoOpenStreams(bool migrate_idle_sessions);
897 void TestOnNetworkMadeDefaultNoOpenStreams(bool migrate_idle_sessions);
898 void TestOnNetworkDisconnectedNonMigratableStream(bool migrate_idle_sessions);
899
900 // Port migrations.
901 void TestSimplePortMigrationOnPathDegrading();
902
903 QuicFlagSaver flags_; // Save/restore all QUIC flag values.
904 std::unique_ptr<MockHostResolverBase> host_resolver_;
905 std::unique_ptr<SSLConfigService> ssl_config_service_;
906 std::unique_ptr<MockClientSocketFactory> socket_factory_;
907 MockCryptoClientStreamFactory crypto_client_stream_factory_;
908 MockQuicContext context_;
909 scoped_refptr<TestTaskRunner> runner_;
910 const quic::ParsedQuicVersion version_;
911 QuicTestPacketMaker client_maker_;
912 QuicTestPacketMaker server_maker_;
913 std::unique_ptr<HttpServerProperties> http_server_properties_;
914 std::unique_ptr<CertVerifier> cert_verifier_;
915 TransportSecurityState transport_security_state_;
916 std::unique_ptr<CTVerifier> cert_transparency_verifier_;
917 DefaultCTPolicyEnforcer ct_policy_enforcer_;
918 std::unique_ptr<ScopedMockNetworkChangeNotifier>
919 scoped_mock_network_change_notifier_;
920 std::unique_ptr<QuicStreamFactory> factory_;
921 HostPortPair host_port_pair_;
922 GURL url_;
923 GURL url2_;
924 GURL url3_;
925 GURL url4_;
926
927 PrivacyMode privacy_mode_;
928 NetLogWithSource net_log_;
929 TestCompletionCallback callback_;
930 const CompletionRepeatingCallback failed_on_default_network_callback_;
931 bool failed_on_default_network_;
932 NetErrorDetails net_error_details_;
933
934 QuicParams* quic_params_;
935 };
936
937 class QuicStreamFactoryTest : public QuicStreamFactoryTestBase,
938 public ::testing::TestWithParam<TestParams> {
939 protected:
QuicStreamFactoryTest()940 QuicStreamFactoryTest()
941 : QuicStreamFactoryTestBase(
942 GetParam().version,
943 GetParam().client_headers_include_h2_stream_dependency) {}
944 };
945
946 INSTANTIATE_TEST_SUITE_P(VersionIncludeStreamDependencySequence,
947 QuicStreamFactoryTest,
948 ::testing::ValuesIn(GetTestParams()),
949 ::testing::PrintToStringParamName());
950
TEST_P(QuicStreamFactoryTest,Create)951 TEST_P(QuicStreamFactoryTest, Create) {
952 Initialize();
953 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
954 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
955
956 MockQuicData socket_data(version_);
957 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
958 if (VersionUsesHttp3(version_.transport_version))
959 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
960 socket_data.AddSocketDataToFactory(socket_factory_.get());
961
962 QuicStreamRequest request(factory_.get());
963 EXPECT_EQ(
964 ERR_IO_PENDING,
965 request.Request(
966 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
967 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
968 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
969 failed_on_default_network_callback_, callback_.callback()));
970
971 EXPECT_THAT(callback_.WaitForResult(), IsOk());
972 std::unique_ptr<HttpStream> stream = CreateStream(&request);
973 EXPECT_TRUE(stream.get());
974
975 EXPECT_EQ(DEFAULT_PRIORITY, host_resolver_->last_request_priority());
976
977 QuicStreamRequest request2(factory_.get());
978 EXPECT_EQ(
979 OK,
980 request2.Request(
981 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
982 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
983 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
984 failed_on_default_network_callback_, callback_.callback()));
985 // Will reset stream 3.
986 stream = CreateStream(&request2);
987
988 EXPECT_TRUE(stream.get());
989
990 // TODO(rtenneti): We should probably have a tests that HTTP and HTTPS result
991 // in streams on different sessions.
992 QuicStreamRequest request3(factory_.get());
993 EXPECT_EQ(
994 OK,
995 request3.Request(
996 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
997 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
998 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
999 failed_on_default_network_callback_, callback_.callback()));
1000 stream = CreateStream(&request3); // Will reset stream 5.
1001 stream.reset(); // Will reset stream 7.
1002
1003 EXPECT_TRUE(socket_data.AllReadDataConsumed());
1004 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1005 }
1006
TEST_P(QuicStreamFactoryTest,CreateZeroRtt)1007 TEST_P(QuicStreamFactoryTest, CreateZeroRtt) {
1008 Initialize();
1009 factory_->set_is_quic_known_to_work_on_current_network(true);
1010 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
1011 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
1012
1013 MockQuicData socket_data(version_);
1014 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1015 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
1016 if (VersionUsesHttp3(version_.transport_version))
1017 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
1018 socket_data.AddSocketDataToFactory(socket_factory_.get());
1019
1020 crypto_client_stream_factory_.set_handshake_mode(
1021 MockCryptoClientStream::ZERO_RTT);
1022 host_resolver_->set_synchronous_mode(true);
1023 host_resolver_->rules()->AddIPLiteralRule(host_port_pair_.host(),
1024 "192.168.0.1", "");
1025
1026 QuicStreamRequest request(factory_.get());
1027 EXPECT_EQ(
1028 OK,
1029 request.Request(
1030 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
1031 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
1032 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
1033 failed_on_default_network_callback_, callback_.callback()));
1034
1035 std::unique_ptr<HttpStream> stream = CreateStream(&request);
1036 EXPECT_TRUE(stream.get());
1037 EXPECT_TRUE(socket_data.AllReadDataConsumed());
1038 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1039 }
1040
1041 // Regression test for crbug.com/1117331.
TEST_P(QuicStreamFactoryTest,AsyncZeroRtt)1042 TEST_P(QuicStreamFactoryTest, AsyncZeroRtt) {
1043 Initialize();
1044
1045 if (!version_.UsesTls())
1046 return;
1047
1048 factory_->set_is_quic_known_to_work_on_current_network(true);
1049 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
1050 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
1051
1052 MockQuicData socket_data(version_);
1053 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1054 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
1055 if (VersionUsesHttp3(version_.transport_version))
1056 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
1057 socket_data.AddSocketDataToFactory(socket_factory_.get());
1058
1059 crypto_client_stream_factory_.set_handshake_mode(
1060 MockCryptoClientStream::ASYNC_ZERO_RTT);
1061 host_resolver_->set_synchronous_mode(true);
1062 host_resolver_->rules()->AddIPLiteralRule(host_port_pair_.host(),
1063 "192.168.0.1", "");
1064
1065 QuicStreamRequest request(factory_.get());
1066 EXPECT_EQ(
1067 ERR_IO_PENDING,
1068 request.Request(
1069 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
1070 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
1071 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
1072 failed_on_default_network_callback_, callback_.callback()));
1073 EXPECT_FALSE(HasActiveSession(host_port_pair_));
1074 EXPECT_EQ(nullptr, CreateStream(&request));
1075
1076 crypto_client_stream_factory_.last_stream()->NotifySessionZeroRttComplete();
1077 EXPECT_TRUE(HasActiveSession(host_port_pair_));
1078
1079 EXPECT_THAT(callback_.WaitForResult(), IsOk());
1080
1081 std::unique_ptr<HttpStream> stream = CreateStream(&request);
1082 EXPECT_TRUE(stream.get());
1083 EXPECT_TRUE(socket_data.AllReadDataConsumed());
1084 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1085 }
1086
TEST_P(QuicStreamFactoryTest,DefaultInitialRtt)1087 TEST_P(QuicStreamFactoryTest, DefaultInitialRtt) {
1088 Initialize();
1089 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
1090 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
1091
1092 MockQuicData socket_data(version_);
1093 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1094 if (VersionUsesHttp3(version_.transport_version))
1095 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
1096 socket_data.AddSocketDataToFactory(socket_factory_.get());
1097
1098 QuicStreamRequest request(factory_.get());
1099 EXPECT_EQ(
1100 ERR_IO_PENDING,
1101 request.Request(
1102 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
1103 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
1104 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
1105 failed_on_default_network_callback_, callback_.callback()));
1106
1107 EXPECT_THAT(callback_.WaitForResult(), IsOk());
1108 std::unique_ptr<HttpStream> stream = CreateStream(&request);
1109 EXPECT_TRUE(stream.get());
1110
1111 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
1112 EXPECT_TRUE(session->require_confirmation());
1113 EXPECT_EQ(100000u, session->connection()->GetStats().srtt_us);
1114 ASSERT_FALSE(session->config()->HasInitialRoundTripTimeUsToSend());
1115 }
1116
TEST_P(QuicStreamFactoryTest,FactoryDestroyedWhenJobPending)1117 TEST_P(QuicStreamFactoryTest, FactoryDestroyedWhenJobPending) {
1118 Initialize();
1119 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
1120 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
1121
1122 MockQuicData socket_data(version_);
1123 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1124 if (VersionUsesHttp3(version_.transport_version))
1125 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
1126 socket_data.AddSocketDataToFactory(socket_factory_.get());
1127
1128 auto request = std::make_unique<QuicStreamRequest>(factory_.get());
1129 EXPECT_EQ(
1130 ERR_IO_PENDING,
1131 request->Request(
1132 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
1133 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
1134 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
1135 failed_on_default_network_callback_, callback_.callback()));
1136 request.reset();
1137 EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_));
1138 // Tearing down a QuicStreamFactory with a pending Job should not cause any
1139 // crash. crbug.com/768343.
1140 factory_.reset();
1141 }
1142
TEST_P(QuicStreamFactoryTest,RequireConfirmation)1143 TEST_P(QuicStreamFactoryTest, RequireConfirmation) {
1144 crypto_client_stream_factory_.set_handshake_mode(
1145 MockCryptoClientStream::ZERO_RTT);
1146 host_resolver_->set_synchronous_mode(true);
1147 host_resolver_->rules()->AddIPLiteralRule(host_port_pair_.host(),
1148 "192.168.0.1", "");
1149 Initialize();
1150 factory_->set_is_quic_known_to_work_on_current_network(false);
1151 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
1152 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
1153
1154 MockQuicData socket_data(version_);
1155 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1156 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
1157 if (VersionUsesHttp3(version_.transport_version))
1158 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
1159 socket_data.AddSocketDataToFactory(socket_factory_.get());
1160
1161 QuicStreamRequest request(factory_.get());
1162 EXPECT_EQ(
1163 ERR_IO_PENDING,
1164 request.Request(
1165 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
1166 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
1167 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
1168 failed_on_default_network_callback_, callback_.callback()));
1169
1170 EXPECT_FALSE(http_server_properties_->HasLastLocalAddressWhenQuicWorked());
1171
1172 crypto_client_stream_factory_.last_stream()
1173 ->NotifySessionOneRttKeyAvailable();
1174
1175 EXPECT_TRUE(http_server_properties_->HasLastLocalAddressWhenQuicWorked());
1176
1177 EXPECT_THAT(callback_.WaitForResult(), IsOk());
1178 std::unique_ptr<HttpStream> stream = CreateStream(&request);
1179 EXPECT_TRUE(stream.get());
1180
1181 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
1182 EXPECT_TRUE(session->require_confirmation());
1183 }
1184
TEST_P(QuicStreamFactoryTest,DontRequireConfirmationFromSameIP)1185 TEST_P(QuicStreamFactoryTest, DontRequireConfirmationFromSameIP) {
1186 crypto_client_stream_factory_.set_handshake_mode(
1187 MockCryptoClientStream::ZERO_RTT);
1188 host_resolver_->set_synchronous_mode(true);
1189 host_resolver_->rules()->AddIPLiteralRule(host_port_pair_.host(),
1190 "192.168.0.1", "");
1191 Initialize();
1192 factory_->set_is_quic_known_to_work_on_current_network(false);
1193 http_server_properties_->SetLastLocalAddressWhenQuicWorked(
1194 IPAddress(192, 0, 2, 33));
1195
1196 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
1197 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
1198
1199 MockQuicData socket_data(version_);
1200 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1201 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
1202 if (VersionUsesHttp3(version_.transport_version))
1203 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
1204 socket_data.AddSocketDataToFactory(socket_factory_.get());
1205
1206 QuicStreamRequest request(factory_.get());
1207 EXPECT_THAT(
1208 request.Request(
1209 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
1210 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
1211 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
1212 failed_on_default_network_callback_, callback_.callback()),
1213 IsOk());
1214
1215 EXPECT_FALSE(http_server_properties_->HasLastLocalAddressWhenQuicWorked());
1216
1217 std::unique_ptr<HttpStream> stream = CreateStream(&request);
1218 EXPECT_TRUE(stream.get());
1219
1220 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
1221 EXPECT_FALSE(session->require_confirmation());
1222
1223 crypto_client_stream_factory_.last_stream()
1224 ->NotifySessionOneRttKeyAvailable();
1225
1226 EXPECT_TRUE(http_server_properties_->HasLastLocalAddressWhenQuicWorked());
1227 }
1228
TEST_P(QuicStreamFactoryTest,CachedInitialRtt)1229 TEST_P(QuicStreamFactoryTest, CachedInitialRtt) {
1230 ServerNetworkStats stats;
1231 stats.srtt = base::TimeDelta::FromMilliseconds(10);
1232 http_server_properties_->SetServerNetworkStats(url::SchemeHostPort(url_),
1233 NetworkIsolationKey(), stats);
1234 quic_params_->estimate_initial_rtt = true;
1235
1236 Initialize();
1237 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
1238 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
1239
1240 MockQuicData socket_data(version_);
1241 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1242 if (VersionUsesHttp3(version_.transport_version))
1243 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
1244 socket_data.AddSocketDataToFactory(socket_factory_.get());
1245
1246 QuicStreamRequest request(factory_.get());
1247 EXPECT_EQ(
1248 ERR_IO_PENDING,
1249 request.Request(
1250 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
1251 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
1252 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
1253 failed_on_default_network_callback_, callback_.callback()));
1254
1255 EXPECT_THAT(callback_.WaitForResult(), IsOk());
1256 std::unique_ptr<HttpStream> stream = CreateStream(&request);
1257 EXPECT_TRUE(stream.get());
1258
1259 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
1260 EXPECT_EQ(10000u, session->connection()->GetStats().srtt_us);
1261 ASSERT_TRUE(session->config()->HasInitialRoundTripTimeUsToSend());
1262 EXPECT_EQ(10000u, session->config()->GetInitialRoundTripTimeUsToSend());
1263 }
1264
1265 // Test that QUIC sessions use the cached RTT from HttpServerProperties for the
1266 // correct NetworkIsolationKey.
TEST_P(QuicStreamFactoryTest,CachedInitialRttWithNetworkIsolationKey)1267 TEST_P(QuicStreamFactoryTest, CachedInitialRttWithNetworkIsolationKey) {
1268 const url::Origin kOrigin1 = url::Origin::Create(GURL("https://foo.test/"));
1269 const url::Origin kOrigin2 = url::Origin::Create(GURL("https://bar.test/"));
1270 const NetworkIsolationKey kNetworkIsolationKey1(kOrigin1, kOrigin1);
1271 const NetworkIsolationKey kNetworkIsolationKey2(kOrigin2, kOrigin2);
1272
1273 base::test::ScopedFeatureList feature_list;
1274 feature_list.InitWithFeatures(
1275 // enabled_features
1276 {features::kPartitionHttpServerPropertiesByNetworkIsolationKey,
1277 // Need to partition connections by NetworkIsolationKey for
1278 // QuicSessionAliasKey to include NetworkIsolationKeys.
1279 features::kPartitionConnectionsByNetworkIsolationKey},
1280 // disabled_features
1281 {});
1282 // Since HttpServerProperties caches the feature value, have to create a new
1283 // one.
1284 http_server_properties_ = std::make_unique<HttpServerProperties>();
1285
1286 ServerNetworkStats stats;
1287 stats.srtt = base::TimeDelta::FromMilliseconds(10);
1288 http_server_properties_->SetServerNetworkStats(url::SchemeHostPort(url_),
1289 kNetworkIsolationKey1, stats);
1290 quic_params_->estimate_initial_rtt = true;
1291 Initialize();
1292
1293 for (const auto& network_isolation_key :
1294 {kNetworkIsolationKey1, kNetworkIsolationKey2, NetworkIsolationKey()}) {
1295 SCOPED_TRACE(network_isolation_key.ToString());
1296
1297 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
1298 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
1299
1300 QuicTestPacketMaker packet_maker(
1301 version_,
1302 quic::QuicUtils::CreateRandomConnectionId(context_.random_generator()),
1303 context_.clock(), kDefaultServerHostName, quic::Perspective::IS_CLIENT,
1304 quic_params_->headers_include_h2_stream_dependency);
1305
1306 MockQuicData socket_data(version_);
1307 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1308 if (VersionUsesHttp3(version_.transport_version)) {
1309 socket_data.AddWrite(SYNCHRONOUS,
1310 packet_maker.MakeInitialSettingsPacket(1));
1311 }
1312 socket_data.AddSocketDataToFactory(socket_factory_.get());
1313
1314 QuicStreamRequest request(factory_.get());
1315 EXPECT_EQ(
1316 ERR_IO_PENDING,
1317 request.Request(
1318 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
1319 SocketTag(), network_isolation_key, false /* disable_secure_dns */,
1320 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
1321 failed_on_default_network_callback_, callback_.callback()));
1322
1323 EXPECT_THAT(callback_.WaitForResult(), IsOk());
1324 std::unique_ptr<HttpStream> stream = CreateStream(&request);
1325 EXPECT_TRUE(stream.get());
1326
1327 QuicChromiumClientSession* session =
1328 GetActiveSession(host_port_pair_, network_isolation_key);
1329 if (network_isolation_key == kNetworkIsolationKey1) {
1330 EXPECT_EQ(10000, session->connection()->GetStats().srtt_us);
1331 ASSERT_TRUE(session->config()->HasInitialRoundTripTimeUsToSend());
1332 EXPECT_EQ(10000u, session->config()->GetInitialRoundTripTimeUsToSend());
1333 } else {
1334 EXPECT_EQ(quic::kInitialRttMs * 1000,
1335 session->connection()->GetStats().srtt_us);
1336 EXPECT_FALSE(session->config()->HasInitialRoundTripTimeUsToSend());
1337 }
1338 }
1339 }
1340
1341 TEST_P(QuicStreamFactoryTest, 2gInitialRtt) {
1342 ScopedMockNetworkChangeNotifier notifier;
1343 notifier.mock_network_change_notifier()->SetConnectionType(
1344 NetworkChangeNotifier::CONNECTION_2G);
1345 quic_params_->estimate_initial_rtt = true;
1346
1347 Initialize();
1348 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
1349 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
1350
1351 MockQuicData socket_data(version_);
1352 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1353 if (VersionUsesHttp3(version_.transport_version))
1354 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
1355 socket_data.AddSocketDataToFactory(socket_factory_.get());
1356
1357 QuicStreamRequest request(factory_.get());
1358 EXPECT_EQ(
1359 ERR_IO_PENDING,
1360 request.Request(
1361 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
1362 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
1363 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
1364 failed_on_default_network_callback_, callback_.callback()));
1365
1366 EXPECT_THAT(callback_.WaitForResult(), IsOk());
1367 std::unique_ptr<HttpStream> stream = CreateStream(&request);
1368 EXPECT_TRUE(stream.get());
1369
1370 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
1371 EXPECT_EQ(1000000u, session->connection()->GetStats().srtt_us);
1372 ASSERT_TRUE(session->config()->HasInitialRoundTripTimeUsToSend());
1373 EXPECT_EQ(1200000u, session->config()->GetInitialRoundTripTimeUsToSend());
1374 }
1375
1376 TEST_P(QuicStreamFactoryTest, 3gInitialRtt) {
1377 ScopedMockNetworkChangeNotifier notifier;
1378 notifier.mock_network_change_notifier()->SetConnectionType(
1379 NetworkChangeNotifier::CONNECTION_3G);
1380 quic_params_->estimate_initial_rtt = true;
1381
1382 Initialize();
1383 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
1384 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
1385
1386 MockQuicData socket_data(version_);
1387 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1388 if (VersionUsesHttp3(version_.transport_version))
1389 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
1390 socket_data.AddSocketDataToFactory(socket_factory_.get());
1391
1392 QuicStreamRequest request(factory_.get());
1393 EXPECT_EQ(
1394 ERR_IO_PENDING,
1395 request.Request(
1396 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
1397 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
1398 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
1399 failed_on_default_network_callback_, callback_.callback()));
1400
1401 EXPECT_THAT(callback_.WaitForResult(), IsOk());
1402 std::unique_ptr<HttpStream> stream = CreateStream(&request);
1403 EXPECT_TRUE(stream.get());
1404
1405 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
1406 EXPECT_EQ(400000u, session->connection()->GetStats().srtt_us);
1407 ASSERT_TRUE(session->config()->HasInitialRoundTripTimeUsToSend());
1408 EXPECT_EQ(400000u, session->config()->GetInitialRoundTripTimeUsToSend());
1409 }
1410
TEST_P(QuicStreamFactoryTest,GoAway)1411 TEST_P(QuicStreamFactoryTest, GoAway) {
1412 Initialize();
1413 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
1414 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
1415
1416 MockQuicData socket_data(version_);
1417 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1418 if (VersionUsesHttp3(version_.transport_version))
1419 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
1420 socket_data.AddSocketDataToFactory(socket_factory_.get());
1421
1422 QuicStreamRequest request(factory_.get());
1423 EXPECT_EQ(
1424 ERR_IO_PENDING,
1425 request.Request(
1426 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
1427 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
1428 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
1429 failed_on_default_network_callback_, callback_.callback()));
1430
1431 EXPECT_THAT(callback_.WaitForResult(), IsOk());
1432 std::unique_ptr<HttpStream> stream = CreateStream(&request);
1433 EXPECT_TRUE(stream.get());
1434
1435 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
1436
1437 if (version_.UsesHttp3()) {
1438 session->OnHttp3GoAway(0);
1439 } else {
1440 session->OnGoAway(quic::QuicGoAwayFrame());
1441 }
1442
1443 EXPECT_FALSE(HasActiveSession(host_port_pair_));
1444
1445 EXPECT_TRUE(socket_data.AllReadDataConsumed());
1446 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1447 }
1448
TEST_P(QuicStreamFactoryTest,GoAwayForConnectionMigrationWithPortOnly)1449 TEST_P(QuicStreamFactoryTest, GoAwayForConnectionMigrationWithPortOnly) {
1450 Initialize();
1451 // GoAway in HTTP/3 doesn't contain error code. Thus the session can't do
1452 // error code specific handling.
1453 if (version_.UsesHttp3()) {
1454 return;
1455 }
1456 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
1457 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
1458
1459 MockQuicData socket_data(version_);
1460 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1461 if (VersionUsesHttp3(version_.transport_version))
1462 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
1463 socket_data.AddSocketDataToFactory(socket_factory_.get());
1464
1465 QuicStreamRequest request(factory_.get());
1466 EXPECT_EQ(
1467 ERR_IO_PENDING,
1468 request.Request(
1469 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
1470 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
1471 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
1472 failed_on_default_network_callback_, callback_.callback()));
1473
1474 EXPECT_THAT(callback_.WaitForResult(), IsOk());
1475 std::unique_ptr<HttpStream> stream = CreateStream(&request);
1476 EXPECT_TRUE(stream.get());
1477
1478 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
1479
1480 session->OnGoAway(quic::QuicGoAwayFrame(
1481 quic::kInvalidControlFrameId, quic::QUIC_ERROR_MIGRATING_PORT, 0,
1482 "peer connection migration due to port change only"));
1483 NetErrorDetails details;
1484 EXPECT_FALSE(details.quic_port_migration_detected);
1485 session->PopulateNetErrorDetails(&details);
1486 EXPECT_TRUE(details.quic_port_migration_detected);
1487 details.quic_port_migration_detected = false;
1488 stream->PopulateNetErrorDetails(&details);
1489 EXPECT_TRUE(details.quic_port_migration_detected);
1490
1491 EXPECT_FALSE(HasActiveSession(host_port_pair_));
1492
1493 EXPECT_TRUE(socket_data.AllReadDataConsumed());
1494 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1495 }
1496
1497 // Makes sure that setting and clearing ServerNetworkStats respects the
1498 // NetworkIsolationKey.
TEST_P(QuicStreamFactoryTest,ServerNetworkStatsWithNetworkIsolationKey)1499 TEST_P(QuicStreamFactoryTest, ServerNetworkStatsWithNetworkIsolationKey) {
1500 const url::Origin kOrigin1 = url::Origin::Create(GURL("https://foo.test/"));
1501 const url::Origin kOrigin2 = url::Origin::Create(GURL("https://bar.test/"));
1502 const NetworkIsolationKey kNetworkIsolationKey1(kOrigin1, kOrigin1);
1503 const NetworkIsolationKey kNetworkIsolationKey2(kOrigin2, kOrigin2);
1504
1505 const NetworkIsolationKey kNetworkIsolationKeys[] = {
1506 kNetworkIsolationKey1, kNetworkIsolationKey2, NetworkIsolationKey()};
1507
1508 base::test::ScopedFeatureList feature_list;
1509 feature_list.InitWithFeatures(
1510 // enabled_features
1511 {features::kPartitionHttpServerPropertiesByNetworkIsolationKey,
1512 // Need to partition connections by NetworkIsolationKey for
1513 // QuicSessionAliasKey to include NetworkIsolationKeys.
1514 features::kPartitionConnectionsByNetworkIsolationKey},
1515 // disabled_features
1516 {});
1517 // Since HttpServerProperties caches the feature value, have to create a new
1518 // one.
1519 http_server_properties_ = std::make_unique<HttpServerProperties>();
1520 Initialize();
1521
1522 // For each server, set up and tear down a QUIC session cleanly, and check
1523 // that stats have been added to HttpServerProperties using the correct
1524 // NetworkIsolationKey.
1525 for (size_t i = 0; i < base::size(kNetworkIsolationKeys); ++i) {
1526 SCOPED_TRACE(i);
1527
1528 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
1529 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
1530
1531 QuicTestPacketMaker packet_maker(
1532 version_,
1533 quic::QuicUtils::CreateRandomConnectionId(context_.random_generator()),
1534 context_.clock(), kDefaultServerHostName, quic::Perspective::IS_CLIENT,
1535 quic_params_->headers_include_h2_stream_dependency);
1536
1537 MockQuicData socket_data(version_);
1538 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1539 if (VersionUsesHttp3(version_.transport_version)) {
1540 socket_data.AddWrite(SYNCHRONOUS,
1541 packet_maker.MakeInitialSettingsPacket(1));
1542 }
1543 socket_data.AddSocketDataToFactory(socket_factory_.get());
1544
1545 QuicStreamRequest request(factory_.get());
1546 EXPECT_EQ(ERR_IO_PENDING,
1547 request.Request(
1548 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
1549 SocketTag(), kNetworkIsolationKeys[i],
1550 false /* disable_secure_dns */,
1551 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
1552 failed_on_default_network_callback_, callback_.callback()));
1553
1554 EXPECT_THAT(callback_.WaitForResult(), IsOk());
1555 std::unique_ptr<HttpStream> stream = CreateStream(&request);
1556 EXPECT_TRUE(stream.get());
1557
1558 QuicChromiumClientSession* session =
1559 GetActiveSession(host_port_pair_, kNetworkIsolationKeys[i]);
1560
1561 if (version_.UsesHttp3()) {
1562 session->OnHttp3GoAway(0);
1563 } else {
1564 session->OnGoAway(quic::QuicGoAwayFrame());
1565 }
1566
1567 EXPECT_FALSE(HasActiveSession(host_port_pair_, kNetworkIsolationKeys[i]));
1568
1569 EXPECT_TRUE(socket_data.AllReadDataConsumed());
1570 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1571
1572 for (size_t j = 0; j < base::size(kNetworkIsolationKeys); ++j) {
1573 // Stats up to kNetworkIsolationKeys[j] should have been populated, all
1574 // others should remain empty.
1575 if (j <= i) {
1576 EXPECT_TRUE(http_server_properties_->GetServerNetworkStats(
1577 url::SchemeHostPort(url_), kNetworkIsolationKeys[j]));
1578 } else {
1579 EXPECT_FALSE(http_server_properties_->GetServerNetworkStats(
1580 url::SchemeHostPort(url_), kNetworkIsolationKeys[j]));
1581 }
1582 }
1583 }
1584
1585 // Use unmocked crypto stream to do crypto connect, since crypto errors result
1586 // in deleting network stats..
1587 crypto_client_stream_factory_.set_handshake_mode(
1588 MockCryptoClientStream::COLD_START_WITH_CHLO_SENT);
1589
1590 // For each server, simulate an error during session creation, and check that
1591 // stats have been deleted from HttpServerProperties using the correct
1592 // NetworkIsolationKey.
1593 for (size_t i = 0; i < base::size(kNetworkIsolationKeys); ++i) {
1594 SCOPED_TRACE(i);
1595
1596 MockQuicData socket_data(version_);
1597 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1598 // Trigger PACKET_WRITE_ERROR when sending packets in crypto connect.
1599 socket_data.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE);
1600 socket_data.AddSocketDataToFactory(socket_factory_.get());
1601
1602 QuicStreamRequest request(factory_.get());
1603 EXPECT_EQ(ERR_IO_PENDING,
1604 request.Request(
1605 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
1606 SocketTag(), kNetworkIsolationKeys[i],
1607 false /* disable_secure_dns */,
1608 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
1609 failed_on_default_network_callback_, callback_.callback()));
1610
1611 EXPECT_THAT(callback_.WaitForResult(), IsError(ERR_QUIC_HANDSHAKE_FAILED));
1612
1613 EXPECT_FALSE(HasActiveSession(host_port_pair_, kNetworkIsolationKeys[i]));
1614
1615 for (size_t j = 0; j < base::size(kNetworkIsolationKeys); ++j) {
1616 // Stats up to kNetworkIsolationKeys[j] should have been deleted, all
1617 // others should still be populated.
1618 if (j <= i) {
1619 EXPECT_FALSE(http_server_properties_->GetServerNetworkStats(
1620 url::SchemeHostPort(url_), kNetworkIsolationKeys[j]));
1621 } else {
1622 EXPECT_TRUE(http_server_properties_->GetServerNetworkStats(
1623 url::SchemeHostPort(url_), kNetworkIsolationKeys[j]));
1624 }
1625 }
1626 }
1627 }
1628
TEST_P(QuicStreamFactoryTest,Pooling)1629 TEST_P(QuicStreamFactoryTest, Pooling) {
1630 Initialize();
1631 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
1632 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
1633
1634 MockQuicData socket_data(version_);
1635 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1636 if (VersionUsesHttp3(version_.transport_version))
1637 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
1638 socket_data.AddSocketDataToFactory(socket_factory_.get());
1639
1640 HostPortPair server2(kServer2HostName, kDefaultServerPort);
1641 host_resolver_->set_synchronous_mode(true);
1642 host_resolver_->rules()->AddIPLiteralRule(host_port_pair_.host(),
1643 "192.168.0.1", "");
1644 host_resolver_->rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
1645
1646 QuicStreamRequest request(factory_.get());
1647 EXPECT_EQ(
1648 OK,
1649 request.Request(
1650 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
1651 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
1652 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
1653 failed_on_default_network_callback_, callback_.callback()));
1654 std::unique_ptr<HttpStream> stream = CreateStream(&request);
1655 EXPECT_TRUE(stream.get());
1656
1657 TestCompletionCallback callback;
1658 QuicStreamRequest request2(factory_.get());
1659 EXPECT_EQ(OK,
1660 request2.Request(
1661 server2, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
1662 NetworkIsolationKey(), false /* disable_secure_dns */,
1663 /*cert_verify_flags=*/0, url2_, net_log_, &net_error_details_,
1664 failed_on_default_network_callback_, callback.callback()));
1665 std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
1666 EXPECT_TRUE(stream2.get());
1667
1668 EXPECT_EQ(GetActiveSession(host_port_pair_), GetActiveSession(server2));
1669
1670 EXPECT_TRUE(socket_data.AllReadDataConsumed());
1671 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1672 }
1673
TEST_P(QuicStreamFactoryTest,PoolingWithServerMigration)1674 TEST_P(QuicStreamFactoryTest, PoolingWithServerMigration) {
1675 // Set up session to migrate.
1676 host_resolver_->rules()->AddIPLiteralRule(host_port_pair_.host(),
1677 "192.168.0.1", "");
1678 IPEndPoint alt_address = IPEndPoint(IPAddress(1, 2, 3, 4), 443);
1679 quic::QuicConfig config;
1680 config.SetIPv4AlternateServerAddressToSend(ToQuicSocketAddress(alt_address));
1681
1682 VerifyServerMigration(config, alt_address);
1683
1684 // Close server-migrated session.
1685 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
1686 session->CloseSessionOnError(0u, quic::QUIC_NO_ERROR,
1687 quic::ConnectionCloseBehavior::SILENT_CLOSE);
1688
1689 client_maker_.Reset();
1690 // Set up server IP, socket, proof, and config for new session.
1691 HostPortPair server2(kServer2HostName, kDefaultServerPort);
1692 host_resolver_->rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
1693
1694 MockQuicData socket_data1(version_);
1695 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1696 if (VersionUsesHttp3(version_.transport_version)) {
1697 socket_data1.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
1698 }
1699 socket_data1.AddSocketDataToFactory(socket_factory_.get());
1700
1701 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
1702 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
1703 quic::QuicConfig config2;
1704 crypto_client_stream_factory_.SetConfig(config2);
1705
1706 // Create new request to cause new session creation.
1707 TestCompletionCallback callback;
1708 QuicStreamRequest request2(factory_.get());
1709 EXPECT_EQ(ERR_IO_PENDING,
1710 request2.Request(
1711 server2, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
1712 NetworkIsolationKey(), false /* disable_secure_dns */,
1713 /*cert_verify_flags=*/0, url2_, net_log_, &net_error_details_,
1714 failed_on_default_network_callback_, callback.callback()));
1715 EXPECT_EQ(OK, callback.WaitForResult());
1716 std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
1717 EXPECT_TRUE(stream2.get());
1718
1719 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
1720 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
1721 // EXPECT_EQ(GetActiveSession(host_port_pair_), GetActiveSession(server2));
1722 }
1723
TEST_P(QuicStreamFactoryTest,NoPoolingAfterGoAway)1724 TEST_P(QuicStreamFactoryTest, NoPoolingAfterGoAway) {
1725 Initialize();
1726 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
1727 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
1728 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
1729
1730 MockQuicData socket_data1(version_);
1731 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1732 if (VersionUsesHttp3(version_.transport_version))
1733 socket_data1.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
1734 socket_data1.AddSocketDataToFactory(socket_factory_.get());
1735 client_maker_.Reset();
1736 MockQuicData socket_data2(version_);
1737 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1738 if (VersionUsesHttp3(version_.transport_version))
1739 socket_data2.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
1740 socket_data2.AddSocketDataToFactory(socket_factory_.get());
1741
1742 HostPortPair server2(kServer2HostName, kDefaultServerPort);
1743 host_resolver_->set_synchronous_mode(true);
1744 host_resolver_->rules()->AddIPLiteralRule(host_port_pair_.host(),
1745 "192.168.0.1", "");
1746 host_resolver_->rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
1747
1748 QuicStreamRequest request(factory_.get());
1749 EXPECT_EQ(
1750 OK,
1751 request.Request(
1752 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
1753 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
1754 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
1755 failed_on_default_network_callback_, callback_.callback()));
1756 std::unique_ptr<HttpStream> stream = CreateStream(&request);
1757 EXPECT_TRUE(stream.get());
1758
1759 TestCompletionCallback callback;
1760 QuicStreamRequest request2(factory_.get());
1761 EXPECT_EQ(OK,
1762 request2.Request(
1763 server2, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
1764 NetworkIsolationKey(), false /* disable_secure_dns */,
1765 /*cert_verify_flags=*/0, url2_, net_log_, &net_error_details_,
1766 failed_on_default_network_callback_, callback.callback()));
1767 std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
1768 EXPECT_TRUE(stream2.get());
1769
1770 factory_->OnSessionGoingAway(GetActiveSession(host_port_pair_));
1771 EXPECT_FALSE(HasActiveSession(host_port_pair_));
1772 EXPECT_FALSE(HasActiveSession(server2));
1773
1774 TestCompletionCallback callback3;
1775 QuicStreamRequest request3(factory_.get());
1776 EXPECT_EQ(OK,
1777 request3.Request(
1778 server2, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
1779 NetworkIsolationKey(), false /* disable_secure_dns */,
1780 /*cert_verify_flags=*/0, url2_, net_log_, &net_error_details_,
1781 failed_on_default_network_callback_, callback3.callback()));
1782 std::unique_ptr<HttpStream> stream3 = CreateStream(&request3);
1783 EXPECT_TRUE(stream3.get());
1784
1785 EXPECT_TRUE(HasActiveSession(server2));
1786
1787 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
1788 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
1789 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
1790 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
1791 }
1792
TEST_P(QuicStreamFactoryTest,HttpsPooling)1793 TEST_P(QuicStreamFactoryTest, HttpsPooling) {
1794 Initialize();
1795
1796 MockQuicData socket_data(version_);
1797 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1798 if (VersionUsesHttp3(version_.transport_version))
1799 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
1800 socket_data.AddSocketDataToFactory(socket_factory_.get());
1801
1802 HostPortPair server1(kDefaultServerHostName, 443);
1803 HostPortPair server2(kServer2HostName, 443);
1804
1805 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
1806 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
1807
1808 host_resolver_->set_synchronous_mode(true);
1809 host_resolver_->rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", "");
1810 host_resolver_->rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
1811
1812 QuicStreamRequest request(factory_.get());
1813 EXPECT_EQ(OK,
1814 request.Request(
1815 server1, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
1816 NetworkIsolationKey(), false /* disable_secure_dns */,
1817 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
1818 failed_on_default_network_callback_, callback_.callback()));
1819 std::unique_ptr<HttpStream> stream = CreateStream(&request);
1820 EXPECT_TRUE(stream.get());
1821
1822 TestCompletionCallback callback;
1823 QuicStreamRequest request2(factory_.get());
1824 EXPECT_EQ(OK,
1825 request2.Request(
1826 server2, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
1827 NetworkIsolationKey(), false /* disable_secure_dns */,
1828 /*cert_verify_flags=*/0, url2_, net_log_, &net_error_details_,
1829 failed_on_default_network_callback_, callback_.callback()));
1830 std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
1831 EXPECT_TRUE(stream2.get());
1832
1833 EXPECT_EQ(GetActiveSession(server1), GetActiveSession(server2));
1834
1835 EXPECT_TRUE(socket_data.AllReadDataConsumed());
1836 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1837 }
1838
TEST_P(QuicStreamFactoryTest,HttpsPoolingWithMatchingPins)1839 TEST_P(QuicStreamFactoryTest, HttpsPoolingWithMatchingPins) {
1840 Initialize();
1841 MockQuicData socket_data(version_);
1842 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1843 if (VersionUsesHttp3(version_.transport_version))
1844 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
1845 socket_data.AddSocketDataToFactory(socket_factory_.get());
1846
1847 HostPortPair server1(kDefaultServerHostName, 443);
1848 HostPortPair server2(kServer2HostName, 443);
1849 transport_security_state_.EnableStaticPinsForTesting();
1850 ScopedTransportSecurityStateSource scoped_security_state_source;
1851
1852 HashValue primary_pin(HASH_VALUE_SHA256);
1853 EXPECT_TRUE(primary_pin.FromString(
1854 "sha256/Nn8jk5By4Vkq6BeOVZ7R7AC6XUUBZsWmUbJR1f1Y5FY="));
1855 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
1856 verify_details.cert_verify_result.public_key_hashes.push_back(primary_pin);
1857 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
1858
1859 host_resolver_->set_synchronous_mode(true);
1860 host_resolver_->rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", "");
1861 host_resolver_->rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
1862
1863 QuicStreamRequest request(factory_.get());
1864 EXPECT_EQ(OK,
1865 request.Request(
1866 server1, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
1867 NetworkIsolationKey(), false /* disable_secure_dns */,
1868 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
1869 failed_on_default_network_callback_, callback_.callback()));
1870 std::unique_ptr<HttpStream> stream = CreateStream(&request);
1871 EXPECT_TRUE(stream.get());
1872
1873 TestCompletionCallback callback;
1874 QuicStreamRequest request2(factory_.get());
1875 EXPECT_EQ(OK,
1876 request2.Request(
1877 server2, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
1878 NetworkIsolationKey(), false /* disable_secure_dns */,
1879 /*cert_verify_flags=*/0, url2_, net_log_, &net_error_details_,
1880 failed_on_default_network_callback_, callback_.callback()));
1881 std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
1882 EXPECT_TRUE(stream2.get());
1883
1884 EXPECT_EQ(GetActiveSession(server1), GetActiveSession(server2));
1885
1886 EXPECT_TRUE(socket_data.AllReadDataConsumed());
1887 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1888 }
1889
TEST_P(QuicStreamFactoryTest,NoHttpsPoolingWithDifferentPins)1890 TEST_P(QuicStreamFactoryTest, NoHttpsPoolingWithDifferentPins) {
1891 Initialize();
1892
1893 MockQuicData socket_data1(version_);
1894 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1895 if (VersionUsesHttp3(version_.transport_version))
1896 socket_data1.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
1897 socket_data1.AddSocketDataToFactory(socket_factory_.get());
1898 client_maker_.Reset();
1899 MockQuicData socket_data2(version_);
1900 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1901 if (VersionUsesHttp3(version_.transport_version))
1902 socket_data2.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
1903 socket_data2.AddSocketDataToFactory(socket_factory_.get());
1904
1905 HostPortPair server1(kDefaultServerHostName, 443);
1906 HostPortPair server2(kServer2HostName, 443);
1907 transport_security_state_.EnableStaticPinsForTesting();
1908 ScopedTransportSecurityStateSource scoped_security_state_source;
1909
1910 ProofVerifyDetailsChromium verify_details1 = DefaultProofVerifyDetails();
1911 uint8_t bad_pin = 3;
1912 verify_details1.cert_verify_result.public_key_hashes.push_back(
1913 test::GetTestHashValue(bad_pin));
1914 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details1);
1915
1916 HashValue primary_pin(HASH_VALUE_SHA256);
1917 EXPECT_TRUE(primary_pin.FromString(
1918 "sha256/Nn8jk5By4Vkq6BeOVZ7R7AC6XUUBZsWmUbJR1f1Y5FY="));
1919 ProofVerifyDetailsChromium verify_details2 = DefaultProofVerifyDetails();
1920 verify_details2.cert_verify_result.public_key_hashes.push_back(primary_pin);
1921 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details2);
1922
1923 host_resolver_->set_synchronous_mode(true);
1924 host_resolver_->rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", "");
1925 host_resolver_->rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
1926
1927 QuicStreamRequest request(factory_.get());
1928 EXPECT_EQ(OK,
1929 request.Request(
1930 server1, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
1931 NetworkIsolationKey(), false /* disable_secure_dns */,
1932 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
1933 failed_on_default_network_callback_, callback_.callback()));
1934 std::unique_ptr<HttpStream> stream = CreateStream(&request);
1935 EXPECT_TRUE(stream.get());
1936
1937 TestCompletionCallback callback;
1938 QuicStreamRequest request2(factory_.get());
1939 EXPECT_EQ(OK,
1940 request2.Request(
1941 server2, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
1942 NetworkIsolationKey(), false /* disable_secure_dns */,
1943 /*cert_verify_flags=*/0, url2_, net_log_, &net_error_details_,
1944 failed_on_default_network_callback_, callback_.callback()));
1945 std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
1946 EXPECT_TRUE(stream2.get());
1947
1948 EXPECT_NE(GetActiveSession(server1), GetActiveSession(server2));
1949
1950 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
1951 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
1952 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
1953 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
1954 }
1955
TEST_P(QuicStreamFactoryTest,Goaway)1956 TEST_P(QuicStreamFactoryTest, Goaway) {
1957 Initialize();
1958 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
1959 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
1960 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
1961
1962 MockQuicData socket_data(version_);
1963 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1964 if (VersionUsesHttp3(version_.transport_version))
1965 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
1966 socket_data.AddSocketDataToFactory(socket_factory_.get());
1967 client_maker_.Reset();
1968 MockQuicData socket_data2(version_);
1969 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
1970 if (VersionUsesHttp3(version_.transport_version))
1971 socket_data2.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
1972 socket_data2.AddSocketDataToFactory(socket_factory_.get());
1973
1974 QuicStreamRequest request(factory_.get());
1975 EXPECT_EQ(
1976 ERR_IO_PENDING,
1977 request.Request(
1978 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
1979 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
1980 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
1981 failed_on_default_network_callback_, callback_.callback()));
1982
1983 EXPECT_THAT(callback_.WaitForResult(), IsOk());
1984 std::unique_ptr<HttpStream> stream = CreateStream(&request);
1985 EXPECT_TRUE(stream.get());
1986
1987 // Mark the session as going away. Ensure that while it is still alive
1988 // that it is no longer active.
1989 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
1990 factory_->OnSessionGoingAway(session);
1991 EXPECT_EQ(true,
1992 QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
1993 EXPECT_FALSE(HasActiveSession(host_port_pair_));
1994
1995 // Create a new request for the same destination and verify that a
1996 // new session is created.
1997 QuicStreamRequest request2(factory_.get());
1998 EXPECT_EQ(
1999 ERR_IO_PENDING,
2000 request2.Request(
2001 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
2002 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
2003 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
2004 failed_on_default_network_callback_, callback_.callback()));
2005 EXPECT_THAT(callback_.WaitForResult(), IsOk());
2006 std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
2007 EXPECT_TRUE(stream2.get());
2008
2009 EXPECT_TRUE(HasActiveSession(host_port_pair_));
2010 EXPECT_NE(session, GetActiveSession(host_port_pair_));
2011 EXPECT_EQ(true,
2012 QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
2013
2014 stream2.reset();
2015 stream.reset();
2016
2017 EXPECT_TRUE(socket_data.AllReadDataConsumed());
2018 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
2019 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
2020 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
2021 }
2022
TEST_P(QuicStreamFactoryTest,MaxOpenStream)2023 TEST_P(QuicStreamFactoryTest, MaxOpenStream) {
2024 Initialize();
2025 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
2026 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
2027
2028 quic::QuicStreamId stream_id = GetNthClientInitiatedBidirectionalStreamId(0);
2029 MockQuicData socket_data(version_);
2030 if (version_.HasIetfQuicFrames()) {
2031 int packet_num = 1;
2032 socket_data.AddWrite(SYNCHRONOUS,
2033 ConstructInitialSettingsPacket(packet_num++));
2034 socket_data.AddWrite(SYNCHRONOUS, client_maker_.MakeStreamsBlockedPacket(
2035 packet_num++, true, 50,
2036 /*unidirectional=*/false));
2037 socket_data.AddWrite(
2038 SYNCHRONOUS, client_maker_.MakeDataPacket(
2039 packet_num++, GetQpackDecoderStreamId(), true, false,
2040 StreamCancellationQpackDecoderInstruction(0)));
2041 socket_data.AddWrite(
2042 SYNCHRONOUS, client_maker_.MakeRstPacket(packet_num++, true, stream_id,
2043 quic::QUIC_STREAM_CANCELLED));
2044 socket_data.AddRead(
2045 ASYNC, server_maker_.MakeRstPacket(1, false, stream_id,
2046 quic::QUIC_STREAM_CANCELLED));
2047 socket_data.AddRead(
2048 ASYNC, server_maker_.MakeMaxStreamsPacket(4, true, 52,
2049 /*unidirectional=*/false));
2050 } else {
2051 socket_data.AddWrite(
2052 SYNCHRONOUS, client_maker_.MakeRstPacket(1, true, stream_id,
2053 quic::QUIC_STREAM_CANCELLED));
2054 socket_data.AddRead(
2055 ASYNC, server_maker_.MakeRstPacket(1, false, stream_id,
2056 quic::QUIC_STREAM_CANCELLED));
2057 }
2058 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
2059 socket_data.AddSocketDataToFactory(socket_factory_.get());
2060
2061 HttpRequestInfo request_info;
2062 request_info.traffic_annotation =
2063 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
2064
2065 std::vector<std::unique_ptr<HttpStream>> streams;
2066 // The MockCryptoClientStream sets max_open_streams to be
2067 // quic::kDefaultMaxStreamsPerConnection / 2.
2068 for (size_t i = 0; i < quic::kDefaultMaxStreamsPerConnection / 2; i++) {
2069 QuicStreamRequest request(factory_.get());
2070 int rv = request.Request(
2071 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
2072 NetworkIsolationKey(), false /* disable_secure_dns */,
2073 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
2074 failed_on_default_network_callback_, callback_.callback());
2075 if (i == 0) {
2076 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
2077 EXPECT_THAT(callback_.WaitForResult(), IsOk());
2078 } else {
2079 EXPECT_THAT(rv, IsOk());
2080 }
2081 std::unique_ptr<HttpStream> stream = CreateStream(&request);
2082 EXPECT_TRUE(stream);
2083 EXPECT_EQ(OK,
2084 stream->InitializeStream(&request_info, false, DEFAULT_PRIORITY,
2085 net_log_, CompletionOnceCallback()));
2086 streams.push_back(std::move(stream));
2087 }
2088
2089 QuicStreamRequest request(factory_.get());
2090 EXPECT_EQ(
2091 OK,
2092 request.Request(
2093 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
2094 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
2095 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
2096 failed_on_default_network_callback_, CompletionOnceCallback()));
2097 std::unique_ptr<HttpStream> stream = CreateStream(&request);
2098 EXPECT_TRUE(stream);
2099 EXPECT_EQ(ERR_IO_PENDING,
2100 stream->InitializeStream(&request_info, false, DEFAULT_PRIORITY,
2101 net_log_, callback_.callback()));
2102
2103 // Close the first stream.
2104 streams.front()->Close(false);
2105 // Trigger exchange of RSTs that in turn allow progress for the last
2106 // stream.
2107 base::RunLoop().RunUntilIdle();
2108 EXPECT_THAT(callback_.WaitForResult(), IsOk());
2109
2110 EXPECT_TRUE(socket_data.AllReadDataConsumed());
2111 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
2112
2113 // Force close of the connection to suppress the generation of RST
2114 // packets when streams are torn down, which wouldn't be relevant to
2115 // this test anyway.
2116 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
2117 session->connection()->CloseConnection(
2118 quic::QUIC_PUBLIC_RESET, "test",
2119 quic::ConnectionCloseBehavior::SILENT_CLOSE);
2120 }
2121
TEST_P(QuicStreamFactoryTest,ResolutionErrorInCreate)2122 TEST_P(QuicStreamFactoryTest, ResolutionErrorInCreate) {
2123 Initialize();
2124 MockQuicData socket_data(version_);
2125 socket_data.AddSocketDataToFactory(socket_factory_.get());
2126
2127 host_resolver_->rules()->AddSimulatedFailure(kDefaultServerHostName);
2128
2129 QuicStreamRequest request(factory_.get());
2130 EXPECT_EQ(
2131 ERR_IO_PENDING,
2132 request.Request(
2133 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
2134 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
2135 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
2136 failed_on_default_network_callback_, callback_.callback()));
2137
2138 EXPECT_THAT(callback_.WaitForResult(), IsError(ERR_NAME_NOT_RESOLVED));
2139
2140 EXPECT_TRUE(socket_data.AllReadDataConsumed());
2141 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
2142 }
2143
TEST_P(QuicStreamFactoryTest,ConnectErrorInCreate)2144 TEST_P(QuicStreamFactoryTest, ConnectErrorInCreate) {
2145 Initialize();
2146
2147 MockQuicData socket_data(version_);
2148 socket_data.AddConnect(SYNCHRONOUS, ERR_ADDRESS_IN_USE);
2149 socket_data.AddSocketDataToFactory(socket_factory_.get());
2150
2151 QuicStreamRequest request(factory_.get());
2152 EXPECT_EQ(
2153 ERR_IO_PENDING,
2154 request.Request(
2155 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
2156 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
2157 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
2158 failed_on_default_network_callback_, callback_.callback()));
2159
2160 EXPECT_THAT(callback_.WaitForResult(), IsError(ERR_ADDRESS_IN_USE));
2161
2162 EXPECT_TRUE(socket_data.AllReadDataConsumed());
2163 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
2164 }
2165
TEST_P(QuicStreamFactoryTest,CancelCreate)2166 TEST_P(QuicStreamFactoryTest, CancelCreate) {
2167 Initialize();
2168 MockQuicData socket_data(version_);
2169 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
2170 if (VersionUsesHttp3(version_.transport_version))
2171 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
2172 socket_data.AddSocketDataToFactory(socket_factory_.get());
2173 {
2174 QuicStreamRequest request(factory_.get());
2175 EXPECT_EQ(
2176 ERR_IO_PENDING,
2177 request.Request(
2178 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
2179 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
2180 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
2181 failed_on_default_network_callback_, callback_.callback()));
2182 }
2183
2184 base::RunLoop().RunUntilIdle();
2185
2186 QuicStreamRequest request2(factory_.get());
2187 EXPECT_EQ(
2188 OK,
2189 request2.Request(
2190 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
2191 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
2192 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
2193 failed_on_default_network_callback_, callback_.callback()));
2194 std::unique_ptr<HttpStream> stream = CreateStream(&request2);
2195
2196 EXPECT_TRUE(stream.get());
2197 stream.reset();
2198
2199 EXPECT_TRUE(socket_data.AllReadDataConsumed());
2200 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
2201 }
2202
TEST_P(QuicStreamFactoryTest,CloseAllSessions)2203 TEST_P(QuicStreamFactoryTest, CloseAllSessions) {
2204 Initialize();
2205 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
2206 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
2207 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
2208
2209 MockQuicData socket_data(version_);
2210 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
2211 int packet_num = 1;
2212 if (VersionUsesHttp3(version_.transport_version)) {
2213 socket_data.AddWrite(SYNCHRONOUS,
2214 ConstructInitialSettingsPacket(packet_num++));
2215 }
2216 socket_data.AddWrite(
2217 SYNCHRONOUS,
2218 client_maker_.MakeConnectionClosePacket(
2219 packet_num++, true, quic::QUIC_PEER_GOING_AWAY, "net error"));
2220 socket_data.AddSocketDataToFactory(socket_factory_.get());
2221
2222 client_maker_.Reset();
2223 MockQuicData socket_data2(version_);
2224 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
2225 if (VersionUsesHttp3(version_.transport_version))
2226 socket_data2.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
2227 socket_data2.AddSocketDataToFactory(socket_factory_.get());
2228
2229 QuicStreamRequest request(factory_.get());
2230 EXPECT_EQ(
2231 ERR_IO_PENDING,
2232 request.Request(
2233 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
2234 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
2235 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
2236 failed_on_default_network_callback_, callback_.callback()));
2237
2238 EXPECT_THAT(callback_.WaitForResult(), IsOk());
2239 std::unique_ptr<HttpStream> stream = CreateStream(&request);
2240 HttpRequestInfo request_info;
2241 request_info.traffic_annotation =
2242 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
2243 EXPECT_EQ(OK, stream->InitializeStream(&request_info, false, DEFAULT_PRIORITY,
2244 net_log_, CompletionOnceCallback()));
2245
2246 // Close the session and verify that stream saw the error.
2247 factory_->CloseAllSessions(ERR_INTERNET_DISCONNECTED,
2248 quic::QUIC_PEER_GOING_AWAY);
2249 EXPECT_EQ(ERR_INTERNET_DISCONNECTED,
2250 stream->ReadResponseHeaders(callback_.callback()));
2251
2252 // Now attempting to request a stream to the same origin should create
2253 // a new session.
2254
2255 QuicStreamRequest request2(factory_.get());
2256 EXPECT_EQ(
2257 ERR_IO_PENDING,
2258 request2.Request(
2259 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
2260 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
2261 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
2262 failed_on_default_network_callback_, callback_.callback()));
2263
2264 EXPECT_THAT(callback_.WaitForResult(), IsOk());
2265 stream = CreateStream(&request2);
2266 stream.reset(); // Will reset stream 3.
2267
2268 EXPECT_TRUE(socket_data.AllReadDataConsumed());
2269 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
2270 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
2271 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
2272 }
2273
2274 // Regression test for crbug.com/700617. Test a write error during the
2275 // crypto handshake will not hang QuicStreamFactory::Job and should
2276 // report QUIC_HANDSHAKE_FAILED to upper layers. Subsequent
2277 // QuicStreamRequest should succeed without hanging.
TEST_P(QuicStreamFactoryTest,WriteErrorInCryptoConnectWithAsyncHostResolution)2278 TEST_P(QuicStreamFactoryTest,
2279 WriteErrorInCryptoConnectWithAsyncHostResolution) {
2280 Initialize();
2281 // Use unmocked crypto stream to do crypto connect.
2282 crypto_client_stream_factory_.set_handshake_mode(
2283 MockCryptoClientStream::COLD_START_WITH_CHLO_SENT);
2284
2285 MockQuicData socket_data(version_);
2286 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
2287 // Trigger PACKET_WRITE_ERROR when sending packets in crypto connect.
2288 socket_data.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE);
2289 socket_data.AddSocketDataToFactory(socket_factory_.get());
2290
2291 // Create request, should fail after the write of the CHLO fails.
2292 QuicStreamRequest request(factory_.get());
2293 EXPECT_EQ(
2294 ERR_IO_PENDING,
2295 request.Request(
2296 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
2297 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
2298 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
2299 failed_on_default_network_callback_, callback_.callback()));
2300 EXPECT_EQ(ERR_QUIC_HANDSHAKE_FAILED, callback_.WaitForResult());
2301 EXPECT_FALSE(HasActiveSession(host_port_pair_));
2302 EXPECT_FALSE(HasActiveJob(host_port_pair_, privacy_mode_));
2303
2304 // Verify new requests can be sent normally without hanging.
2305 crypto_client_stream_factory_.set_handshake_mode(
2306 MockCryptoClientStream::COLD_START);
2307 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
2308 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
2309 client_maker_.Reset();
2310 MockQuicData socket_data2(version_);
2311 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
2312 if (VersionUsesHttp3(version_.transport_version))
2313 socket_data2.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
2314 socket_data2.AddSocketDataToFactory(socket_factory_.get());
2315
2316 QuicStreamRequest request2(factory_.get());
2317 EXPECT_EQ(
2318 ERR_IO_PENDING,
2319 request2.Request(
2320 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
2321 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
2322 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
2323 failed_on_default_network_callback_, callback_.callback()));
2324 EXPECT_FALSE(HasActiveSession(host_port_pair_));
2325 EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_));
2326 // Run the message loop to complete host resolution.
2327 base::RunLoop().RunUntilIdle();
2328
2329 // Complete handshake. QuicStreamFactory::Job should complete and succeed.
2330 crypto_client_stream_factory_.last_stream()
2331 ->NotifySessionOneRttKeyAvailable();
2332 EXPECT_THAT(callback_.WaitForResult(), IsOk());
2333 EXPECT_TRUE(HasActiveSession(host_port_pair_));
2334 EXPECT_FALSE(HasActiveJob(host_port_pair_, privacy_mode_));
2335
2336 // Create QuicHttpStream.
2337 std::unique_ptr<HttpStream> stream = CreateStream(&request2);
2338 EXPECT_TRUE(stream.get());
2339 stream.reset();
2340 EXPECT_TRUE(socket_data.AllReadDataConsumed());
2341 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
2342 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
2343 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
2344 }
2345
TEST_P(QuicStreamFactoryTest,WriteErrorInCryptoConnectWithSyncHostResolution)2346 TEST_P(QuicStreamFactoryTest, WriteErrorInCryptoConnectWithSyncHostResolution) {
2347 Initialize();
2348 // Use unmocked crypto stream to do crypto connect.
2349 crypto_client_stream_factory_.set_handshake_mode(
2350 MockCryptoClientStream::COLD_START_WITH_CHLO_SENT);
2351 host_resolver_->set_synchronous_mode(true);
2352 host_resolver_->rules()->AddIPLiteralRule(host_port_pair_.host(),
2353 "192.168.0.1", "");
2354
2355 MockQuicData socket_data(version_);
2356 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
2357 // Trigger PACKET_WRITE_ERROR when sending packets in crypto connect.
2358 socket_data.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE);
2359 socket_data.AddSocketDataToFactory(socket_factory_.get());
2360
2361 // Create request, should fail immediately.
2362 QuicStreamRequest request(factory_.get());
2363 EXPECT_EQ(
2364 ERR_QUIC_HANDSHAKE_FAILED,
2365 request.Request(
2366 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
2367 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
2368 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
2369 failed_on_default_network_callback_, callback_.callback()));
2370 // Check no active session, or active jobs left for this server.
2371 EXPECT_FALSE(HasActiveSession(host_port_pair_));
2372 EXPECT_FALSE(HasActiveJob(host_port_pair_, privacy_mode_));
2373
2374 // Verify new requests can be sent normally without hanging.
2375 crypto_client_stream_factory_.set_handshake_mode(
2376 MockCryptoClientStream::COLD_START);
2377 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
2378 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
2379 client_maker_.Reset();
2380 MockQuicData socket_data2(version_);
2381 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
2382 if (VersionUsesHttp3(version_.transport_version))
2383 socket_data2.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
2384 socket_data2.AddSocketDataToFactory(socket_factory_.get());
2385
2386 QuicStreamRequest request2(factory_.get());
2387 EXPECT_EQ(
2388 ERR_IO_PENDING,
2389 request2.Request(
2390 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
2391 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
2392 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
2393 failed_on_default_network_callback_, callback_.callback()));
2394 EXPECT_FALSE(HasActiveSession(host_port_pair_));
2395 EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_));
2396
2397 // Complete handshake.
2398 crypto_client_stream_factory_.last_stream()
2399 ->NotifySessionOneRttKeyAvailable();
2400 EXPECT_THAT(callback_.WaitForResult(), IsOk());
2401 EXPECT_TRUE(HasActiveSession(host_port_pair_));
2402 EXPECT_FALSE(HasActiveJob(host_port_pair_, privacy_mode_));
2403
2404 // Create QuicHttpStream.
2405 std::unique_ptr<HttpStream> stream = CreateStream(&request2);
2406 EXPECT_TRUE(stream.get());
2407 stream.reset();
2408 EXPECT_TRUE(socket_data.AllReadDataConsumed());
2409 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
2410 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
2411 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
2412 }
2413
TEST_P(QuicStreamFactoryTest,CloseSessionsOnIPAddressChanged)2414 TEST_P(QuicStreamFactoryTest, CloseSessionsOnIPAddressChanged) {
2415 quic_params_->close_sessions_on_ip_change = true;
2416 Initialize();
2417 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
2418 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
2419 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
2420
2421 MockQuicData socket_data(version_);
2422 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
2423 int packet_num = 1;
2424 if (VersionUsesHttp3(version_.transport_version)) {
2425 socket_data.AddWrite(SYNCHRONOUS,
2426 ConstructInitialSettingsPacket(packet_num++));
2427 }
2428 socket_data.AddWrite(
2429 SYNCHRONOUS,
2430 client_maker_.MakeConnectionClosePacket(
2431 packet_num, true, quic::QUIC_IP_ADDRESS_CHANGED, "net error"));
2432 socket_data.AddSocketDataToFactory(socket_factory_.get());
2433
2434 client_maker_.Reset();
2435 MockQuicData socket_data2(version_);
2436 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
2437 if (VersionUsesHttp3(version_.transport_version))
2438 socket_data2.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
2439 socket_data2.AddSocketDataToFactory(socket_factory_.get());
2440
2441 QuicStreamRequest request(factory_.get());
2442 EXPECT_EQ(
2443 ERR_IO_PENDING,
2444 request.Request(
2445 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
2446 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
2447 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
2448 failed_on_default_network_callback_, callback_.callback()));
2449
2450 EXPECT_THAT(callback_.WaitForResult(), IsOk());
2451 std::unique_ptr<HttpStream> stream = CreateStream(&request);
2452 HttpRequestInfo request_info;
2453 request_info.traffic_annotation =
2454 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
2455 EXPECT_EQ(OK, stream->InitializeStream(&request_info, false, DEFAULT_PRIORITY,
2456 net_log_, CompletionOnceCallback()));
2457
2458 // Check an active session exists for the destination.
2459 EXPECT_TRUE(HasActiveSession(host_port_pair_));
2460 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
2461 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
2462
2463 EXPECT_TRUE(http_server_properties_->HasLastLocalAddressWhenQuicWorked());
2464 // Change the IP address and verify that stream saw the error and the active
2465 // session is closed.
2466 NotifyIPAddressChanged();
2467 EXPECT_EQ(ERR_NETWORK_CHANGED,
2468 stream->ReadResponseHeaders(callback_.callback()));
2469 EXPECT_FALSE(factory_->is_quic_known_to_work_on_current_network());
2470 EXPECT_FALSE(http_server_properties_->HasLastLocalAddressWhenQuicWorked());
2471 // Check no active session exists for the destination.
2472 EXPECT_FALSE(HasActiveSession(host_port_pair_));
2473
2474 // Now attempting to request a stream to the same origin should create
2475 // a new session.
2476 QuicStreamRequest request2(factory_.get());
2477 EXPECT_EQ(
2478 ERR_IO_PENDING,
2479 request2.Request(
2480 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
2481 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
2482 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
2483 failed_on_default_network_callback_, callback_.callback()));
2484
2485 EXPECT_THAT(callback_.WaitForResult(), IsOk());
2486 stream = CreateStream(&request2);
2487
2488 // Check a new active session exisits for the destination and the old session
2489 // is no longer live.
2490 EXPECT_TRUE(HasActiveSession(host_port_pair_));
2491 QuicChromiumClientSession* session2 = GetActiveSession(host_port_pair_);
2492 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session2));
2493
2494 stream.reset(); // Will reset stream 3.
2495 EXPECT_TRUE(socket_data.AllReadDataConsumed());
2496 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
2497 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
2498 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
2499 }
2500
2501 // Test that if goaway_session_on_ip_change is set, old sessions will be marked
2502 // as going away on IP address change instead of being closed. New requests will
2503 // go to a new connection.
TEST_P(QuicStreamFactoryTest,GoAwaySessionsOnIPAddressChanged)2504 TEST_P(QuicStreamFactoryTest, GoAwaySessionsOnIPAddressChanged) {
2505 quic_params_->goaway_sessions_on_ip_change = true;
2506 Initialize();
2507 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
2508 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
2509 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
2510
2511 MockQuicData quic_data1(version_);
2512 int packet_num = 1;
2513 if (VersionUsesHttp3(version_.transport_version)) {
2514 quic_data1.AddWrite(SYNCHRONOUS,
2515 ConstructInitialSettingsPacket(packet_num++));
2516 }
2517 quic_data1.AddWrite(
2518 SYNCHRONOUS,
2519 ConstructGetRequestPacket(packet_num++,
2520 GetNthClientInitiatedBidirectionalStreamId(0),
2521 true, true));
2522 quic_data1.AddRead(ASYNC, ERR_IO_PENDING); // Pause
2523 quic_data1.AddRead(
2524 ASYNC,
2525 ConstructOkResponsePacket(
2526 1, GetNthClientInitiatedBidirectionalStreamId(0), false, true));
2527 quic_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read.
2528 quic_data1.AddSocketDataToFactory(socket_factory_.get());
2529
2530 client_maker_.Reset();
2531 MockQuicData quic_data2(version_);
2532 quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read.
2533 if (VersionUsesHttp3(version_.transport_version))
2534 quic_data2.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket(1));
2535 quic_data2.AddSocketDataToFactory(socket_factory_.get());
2536
2537 // Create request and QuicHttpStream.
2538 QuicStreamRequest request(factory_.get());
2539 EXPECT_EQ(
2540 ERR_IO_PENDING,
2541 request.Request(
2542 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
2543 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
2544 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
2545 failed_on_default_network_callback_, callback_.callback()));
2546 EXPECT_THAT(callback_.WaitForResult(), IsOk());
2547 std::unique_ptr<HttpStream> stream = CreateStream(&request);
2548 EXPECT_TRUE(stream.get());
2549
2550 // Cause QUIC stream to be created.
2551 HttpRequestInfo request_info;
2552 request_info.method = "GET";
2553 request_info.url = url_;
2554 request_info.traffic_annotation =
2555 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
2556 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
2557 net_log_, CompletionOnceCallback()));
2558
2559 // Ensure that session is alive and active.
2560 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
2561 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
2562 EXPECT_TRUE(HasActiveSession(host_port_pair_));
2563
2564 // Send GET request on stream.
2565 HttpResponseInfo response;
2566 HttpRequestHeaders request_headers;
2567 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
2568 callback_.callback()));
2569
2570 // Receive an IP address change notification.
2571 NotifyIPAddressChanged();
2572
2573 // The connection should still be alive, but marked as going away.
2574 EXPECT_FALSE(HasActiveSession(host_port_pair_));
2575 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
2576 EXPECT_EQ(1u, session->GetNumActiveStreams());
2577
2578 // Resume the data, response should be read from the original connection.
2579 quic_data1.Resume();
2580 EXPECT_EQ(OK, stream->ReadResponseHeaders(callback_.callback()));
2581 EXPECT_EQ(200, response.headers->response_code());
2582 EXPECT_EQ(0u, session->GetNumActiveStreams());
2583
2584 // Second request should be sent on a new connection.
2585 QuicStreamRequest request2(factory_.get());
2586 EXPECT_EQ(
2587 ERR_IO_PENDING,
2588 request2.Request(
2589 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
2590 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
2591 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
2592 failed_on_default_network_callback_, callback_.callback()));
2593 EXPECT_THAT(callback_.WaitForResult(), IsOk());
2594 std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
2595 EXPECT_TRUE(stream2.get());
2596
2597 // Check an active session exisits for the destination.
2598 EXPECT_TRUE(HasActiveSession(host_port_pair_));
2599 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
2600 QuicChromiumClientSession* session2 = GetActiveSession(host_port_pair_);
2601 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session2));
2602
2603 stream.reset();
2604 stream2.reset();
2605 EXPECT_TRUE(quic_data1.AllReadDataConsumed());
2606 EXPECT_TRUE(quic_data1.AllWriteDataConsumed());
2607 EXPECT_TRUE(quic_data2.AllReadDataConsumed());
2608 EXPECT_TRUE(quic_data2.AllWriteDataConsumed());
2609 }
2610
TEST_P(QuicStreamFactoryTest,OnIPAddressChangedWithConnectionMigration)2611 TEST_P(QuicStreamFactoryTest, OnIPAddressChangedWithConnectionMigration) {
2612 InitializeConnectionMigrationV2Test(
2613 {kDefaultNetworkForTests, kNewNetworkForTests});
2614 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
2615 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
2616 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
2617
2618 MockQuicData socket_data(version_);
2619 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
2620 int packet_num = 1;
2621 if (VersionUsesHttp3(version_.transport_version)) {
2622 socket_data.AddWrite(SYNCHRONOUS,
2623 ConstructInitialSettingsPacket(packet_num++));
2624 socket_data.AddWrite(
2625 SYNCHRONOUS, client_maker_.MakeDataPacket(
2626 packet_num++, GetQpackDecoderStreamId(), true, false,
2627 StreamCancellationQpackDecoderInstruction(0)));
2628 }
2629 socket_data.AddWrite(
2630 SYNCHRONOUS,
2631 ConstructClientRstPacket(packet_num, quic::QUIC_STREAM_CANCELLED));
2632 socket_data.AddSocketDataToFactory(socket_factory_.get());
2633
2634 QuicStreamRequest request(factory_.get());
2635 EXPECT_EQ(
2636 ERR_IO_PENDING,
2637 request.Request(
2638 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
2639 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
2640 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
2641 failed_on_default_network_callback_, callback_.callback()));
2642
2643 EXPECT_THAT(callback_.WaitForResult(), IsOk());
2644 std::unique_ptr<HttpStream> stream = CreateStream(&request);
2645 HttpRequestInfo request_info;
2646 request_info.traffic_annotation =
2647 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
2648 EXPECT_EQ(OK, stream->InitializeStream(&request_info, false, DEFAULT_PRIORITY,
2649 net_log_, CompletionOnceCallback()));
2650
2651 EXPECT_TRUE(http_server_properties_->HasLastLocalAddressWhenQuicWorked());
2652
2653 // Change the IP address and verify that the connection is unaffected.
2654 NotifyIPAddressChanged();
2655 EXPECT_TRUE(factory_->is_quic_known_to_work_on_current_network());
2656 EXPECT_TRUE(http_server_properties_->HasLastLocalAddressWhenQuicWorked());
2657
2658 // Attempting a new request to the same origin uses the same connection.
2659 QuicStreamRequest request2(factory_.get());
2660 EXPECT_EQ(
2661 OK,
2662 request2.Request(
2663 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
2664 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
2665 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
2666 failed_on_default_network_callback_, callback_.callback()));
2667 stream = CreateStream(&request2);
2668
2669 stream.reset();
2670 EXPECT_TRUE(socket_data.AllReadDataConsumed());
2671 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
2672 }
2673
TEST_P(QuicStreamFactoryTest,MigrateOnNetworkMadeDefaultWithSynchronousWrite)2674 TEST_P(QuicStreamFactoryTest, MigrateOnNetworkMadeDefaultWithSynchronousWrite) {
2675 TestMigrationOnNetworkMadeDefault(SYNCHRONOUS);
2676 }
2677
TEST_P(QuicStreamFactoryTest,MigrateOnNetworkMadeDefaultWithAsyncWrite)2678 TEST_P(QuicStreamFactoryTest, MigrateOnNetworkMadeDefaultWithAsyncWrite) {
2679 TestMigrationOnNetworkMadeDefault(ASYNC);
2680 }
2681
2682 // Sets up a test which attempts connection migration successfully after probing
2683 // when a new network is made as default and the old default is still available.
2684 // |write_mode| specifies the write mode for the last write before
2685 // OnNetworkMadeDefault is delivered to session.
TestMigrationOnNetworkMadeDefault(IoMode write_mode)2686 void QuicStreamFactoryTestBase::TestMigrationOnNetworkMadeDefault(
2687 IoMode write_mode) {
2688 InitializeConnectionMigrationV2Test({kDefaultNetworkForTests});
2689 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
2690 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
2691 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
2692
2693 // Using a testing task runner so that we can control time.
2694 auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
2695 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
2696
2697 scoped_mock_network_change_notifier_->mock_network_change_notifier()
2698 ->QueueNetworkMadeDefault(kDefaultNetworkForTests);
2699
2700 MockQuicData quic_data1(version_);
2701 quic_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging Read.
2702 int packet_num = 1;
2703 if (VersionUsesHttp3(version_.transport_version)) {
2704 quic_data1.AddWrite(SYNCHRONOUS,
2705 ConstructInitialSettingsPacket(packet_num++));
2706 }
2707 quic_data1.AddWrite(
2708 write_mode,
2709 ConstructGetRequestPacket(packet_num++,
2710 GetNthClientInitiatedBidirectionalStreamId(0),
2711 true, true));
2712 quic_data1.AddSocketDataToFactory(socket_factory_.get());
2713
2714 // Set up the second socket data provider that is used after migration.
2715 // The response to the earlier request is read on the new socket.
2716 MockQuicData quic_data2(version_);
2717 // Connectivity probe to be sent on the new path.
2718 quic_data2.AddWrite(SYNCHRONOUS, client_maker_.MakeConnectivityProbingPacket(
2719 packet_num++, true));
2720 quic_data2.AddRead(ASYNC, ERR_IO_PENDING); // Pause
2721 // Connectivity probe to receive from the server.
2722 quic_data2.AddRead(ASYNC,
2723 server_maker_.MakeConnectivityProbingPacket(1, false));
2724 // Ping packet to send after migration is completed.
2725 quic_data2.AddWrite(
2726 ASYNC, client_maker_.MakeAckAndPingPacket(packet_num++, false, 1, 1));
2727 quic_data2.AddRead(
2728 ASYNC,
2729 ConstructOkResponsePacket(
2730 2, GetNthClientInitiatedBidirectionalStreamId(0), false, false));
2731 quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
2732 if (VersionUsesHttp3(version_.transport_version)) {
2733 quic_data2.AddWrite(
2734 SYNCHRONOUS, client_maker_.MakeAckAndDataPacket(
2735 packet_num++, false, GetQpackDecoderStreamId(), 2, 2,
2736 false, StreamCancellationQpackDecoderInstruction(0)));
2737 quic_data2.AddWrite(
2738 SYNCHRONOUS,
2739 client_maker_.MakeRstPacket(
2740 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
2741 quic::QUIC_STREAM_CANCELLED));
2742 } else {
2743 quic_data2.AddWrite(
2744 SYNCHRONOUS,
2745 client_maker_.MakeAckAndRstPacket(
2746 packet_num, false, GetNthClientInitiatedBidirectionalStreamId(0),
2747 quic::QUIC_STREAM_CANCELLED, 2, 2));
2748 }
2749 quic_data2.AddSocketDataToFactory(socket_factory_.get());
2750
2751 // Create request and QuicHttpStream.
2752 QuicStreamRequest request(factory_.get());
2753 EXPECT_EQ(
2754 ERR_IO_PENDING,
2755 request.Request(
2756 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
2757 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
2758 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
2759 failed_on_default_network_callback_, callback_.callback()));
2760 EXPECT_THAT(callback_.WaitForResult(), IsOk());
2761 std::unique_ptr<HttpStream> stream = CreateStream(&request);
2762 EXPECT_TRUE(stream.get());
2763
2764 // Cause QUIC stream to be created.
2765 HttpRequestInfo request_info;
2766 request_info.method = "GET";
2767 request_info.url = url_;
2768 request_info.traffic_annotation =
2769 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
2770 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
2771 net_log_, CompletionOnceCallback()));
2772
2773 // Ensure that session is alive and active.
2774 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
2775 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
2776 EXPECT_TRUE(HasActiveSession(host_port_pair_));
2777
2778 // Send GET request on stream.
2779 HttpResponseInfo response;
2780 HttpRequestHeaders request_headers;
2781 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
2782 callback_.callback()));
2783
2784 // Deliver a signal that a alternate network is connected now, this should
2785 // cause the connection to start early migration on path degrading.
2786 scoped_mock_network_change_notifier_->mock_network_change_notifier()
2787 ->SetConnectedNetworksList(
2788 {kDefaultNetworkForTests, kNewNetworkForTests});
2789 scoped_mock_network_change_notifier_->mock_network_change_notifier()
2790 ->NotifyNetworkConnected(kNewNetworkForTests);
2791
2792 // Cause the connection to report path degrading to the session.
2793 // Due to lack of alternate network, session will not mgirate connection.
2794 EXPECT_EQ(0u, task_runner->GetPendingTaskCount());
2795 scoped_mock_network_change_notifier_->mock_network_change_notifier()
2796 ->NotifyNetworkMadeDefault(kNewNetworkForTests);
2797
2798 // A task will be posted to migrate to the new default network.
2799 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
2800 EXPECT_EQ(base::TimeDelta(), task_runner->NextPendingTaskDelay());
2801
2802 // Execute the posted task to migrate back to the default network.
2803 task_runner->RunUntilIdle();
2804 // Another task to try send a new connectivity probe is posted. And a task to
2805 // retry migrate back to default network is scheduled.
2806 EXPECT_EQ(2u, task_runner->GetPendingTaskCount());
2807 // Next connectivity probe is scheduled to be sent in 2 *
2808 // kDefaultRTTMilliSecs.
2809 base::TimeDelta next_task_delay = task_runner->NextPendingTaskDelay();
2810 EXPECT_EQ(base::TimeDelta::FromMilliseconds(2 * kDefaultRTTMilliSecs),
2811 next_task_delay);
2812
2813 // The connection should still be alive, and not marked as going away.
2814 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
2815 EXPECT_TRUE(HasActiveSession(host_port_pair_));
2816 EXPECT_EQ(1u, session->GetNumActiveStreams());
2817 EXPECT_EQ(ERR_IO_PENDING, stream->ReadResponseHeaders(callback_.callback()));
2818
2819 // Resume quic data and a connectivity probe response will be read on the new
2820 // socket, declare probing as successful. And a new task to WriteToNewSocket
2821 // will be posted to complete migration.
2822 quic_data2.Resume();
2823
2824 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
2825 EXPECT_TRUE(HasActiveSession(host_port_pair_));
2826 EXPECT_EQ(1u, session->GetNumActiveStreams());
2827
2828 // There should be three pending tasks, the nearest one will complete
2829 // migration to the new network.
2830 EXPECT_EQ(3u, task_runner->GetPendingTaskCount());
2831 next_task_delay = task_runner->NextPendingTaskDelay();
2832 EXPECT_EQ(base::TimeDelta(), next_task_delay);
2833 task_runner->FastForwardBy(next_task_delay);
2834
2835 // Response headers are received over the new network.
2836 EXPECT_THAT(callback_.WaitForResult(), IsOk());
2837 EXPECT_EQ(200, response.headers->response_code());
2838
2839 // Now there are two pending tasks, the nearest one was to send connectivity
2840 // probe and has been cancelled due to successful migration.
2841 EXPECT_EQ(2u, task_runner->GetPendingTaskCount());
2842 next_task_delay = task_runner->NextPendingTaskDelay();
2843 EXPECT_EQ(base::TimeDelta::FromMilliseconds(2 * kDefaultRTTMilliSecs),
2844 next_task_delay);
2845 task_runner->FastForwardBy(next_task_delay);
2846
2847 // There's one more task to mgirate back to the default network in 0.4s, which
2848 // is also cancelled due to the success migration on the previous trial.
2849 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
2850 next_task_delay = task_runner->NextPendingTaskDelay();
2851 base::TimeDelta expected_delay =
2852 base::TimeDelta::FromSeconds(kMinRetryTimeForDefaultNetworkSecs) -
2853 base::TimeDelta::FromMilliseconds(2 * kDefaultRTTMilliSecs);
2854 EXPECT_EQ(expected_delay, next_task_delay);
2855 task_runner->FastForwardBy(next_task_delay);
2856 EXPECT_EQ(0u, task_runner->GetPendingTaskCount());
2857
2858 // Verify that the session is still alive.
2859 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
2860 EXPECT_TRUE(HasActiveSession(host_port_pair_));
2861
2862 stream.reset();
2863 EXPECT_TRUE(quic_data1.AllReadDataConsumed());
2864 EXPECT_TRUE(quic_data1.AllWriteDataConsumed());
2865 EXPECT_TRUE(quic_data2.AllReadDataConsumed());
2866 EXPECT_TRUE(quic_data2.AllWriteDataConsumed());
2867 }
2868
2869 // Regression test for http://859674.
2870 // This test veries that a writer will not attempt to write packets until being
2871 // unblocked on both socket level and network level. In this test, a probing
2872 // writer is used to send two connectivity probes to the peer: where the first
2873 // one completes successfully, while a connectivity response is received before
2874 // completes sending the second one. The connection migration attempt will
2875 // proceed while the probing writer is blocked at the socket level, which will
2876 // block the writer on the network level. Once connection migration completes
2877 // successfully, the probing writer will be unblocked on the network level, it
2878 // will not attempt to write new packets until the socket level is unblocked.
TEST_P(QuicStreamFactoryTest,MigratedToBlockedSocketAfterProbing)2879 TEST_P(QuicStreamFactoryTest, MigratedToBlockedSocketAfterProbing) {
2880 InitializeConnectionMigrationV2Test({kDefaultNetworkForTests});
2881 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
2882 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
2883 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
2884
2885 // Using a testing task runner so that we can control time.
2886 auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
2887 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
2888
2889 scoped_mock_network_change_notifier_->mock_network_change_notifier()
2890 ->QueueNetworkMadeDefault(kDefaultNetworkForTests);
2891
2892 MockQuicData quic_data1(version_);
2893 quic_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging Read.
2894 int packet_num = 1;
2895 if (VersionUsesHttp3(version_.transport_version)) {
2896 quic_data1.AddWrite(SYNCHRONOUS,
2897 ConstructInitialSettingsPacket(packet_num++));
2898 }
2899 quic_data1.AddWrite(
2900 SYNCHRONOUS,
2901 ConstructGetRequestPacket(packet_num++,
2902 GetNthClientInitiatedBidirectionalStreamId(0),
2903 true, true));
2904 quic_data1.AddSocketDataToFactory(socket_factory_.get());
2905
2906 // Set up the second socket data provider that is used after migration.
2907 // The response to the earlier request is read on the new socket.
2908 MockQuicData quic_data2(version_);
2909 // First connectivity probe to be sent on the new path.
2910 quic_data2.AddWrite(SYNCHRONOUS, client_maker_.MakeConnectivityProbingPacket(
2911 packet_num++, true));
2912 quic_data2.AddRead(ASYNC,
2913 ERR_IO_PENDING); // Pause so that we can control time.
2914 // Connectivity probe to receive from the server.
2915 quic_data2.AddRead(ASYNC,
2916 server_maker_.MakeConnectivityProbingPacket(1, false));
2917 // Second connectivity probe which will complete asynchronously.
2918 quic_data2.AddWrite(
2919 ASYNC, client_maker_.MakeConnectivityProbingPacket(packet_num++, true));
2920 quic_data2.AddRead(
2921 ASYNC,
2922 ConstructOkResponsePacket(
2923 2, GetNthClientInitiatedBidirectionalStreamId(0), false, false));
2924 quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
2925 quic_data2.AddWrite(
2926 ASYNC, client_maker_.MakeAckAndPingPacket(packet_num++, false, 1, 1));
2927 if (VersionUsesHttp3(version_.transport_version)) {
2928 quic_data2.AddWrite(
2929 SYNCHRONOUS, client_maker_.MakeAckAndDataPacket(
2930 packet_num++, false, GetQpackDecoderStreamId(), 2, 2,
2931 false, StreamCancellationQpackDecoderInstruction(0)));
2932 quic_data2.AddWrite(
2933 SYNCHRONOUS,
2934 client_maker_.MakeRstPacket(
2935 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
2936 quic::QUIC_STREAM_CANCELLED));
2937 } else {
2938 quic_data2.AddWrite(
2939 SYNCHRONOUS,
2940 client_maker_.MakeAckAndRstPacket(
2941 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
2942 quic::QUIC_STREAM_CANCELLED, 2, 2));
2943 }
2944
2945 quic_data2.AddSocketDataToFactory(socket_factory_.get());
2946
2947 // Create request and QuicHttpStream.
2948 QuicStreamRequest request(factory_.get());
2949 EXPECT_EQ(
2950 ERR_IO_PENDING,
2951 request.Request(
2952 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
2953 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
2954 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
2955 failed_on_default_network_callback_, callback_.callback()));
2956 EXPECT_THAT(callback_.WaitForResult(), IsOk());
2957 std::unique_ptr<HttpStream> stream = CreateStream(&request);
2958 EXPECT_TRUE(stream.get());
2959
2960 // Cause QUIC stream to be created.
2961 HttpRequestInfo request_info;
2962 request_info.method = "GET";
2963 request_info.url = url_;
2964 request_info.traffic_annotation =
2965 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
2966 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
2967 net_log_, CompletionOnceCallback()));
2968
2969 // Ensure that session is alive and active.
2970 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
2971 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
2972 EXPECT_TRUE(HasActiveSession(host_port_pair_));
2973
2974 // Send GET request on stream.
2975 HttpResponseInfo response;
2976 HttpRequestHeaders request_headers;
2977 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
2978 callback_.callback()));
2979
2980 // Deliver a signal that a alternate network is connected now, this should
2981 // cause the connection to start early migration on path degrading.
2982 scoped_mock_network_change_notifier_->mock_network_change_notifier()
2983 ->SetConnectedNetworksList(
2984 {kDefaultNetworkForTests, kNewNetworkForTests});
2985 scoped_mock_network_change_notifier_->mock_network_change_notifier()
2986 ->NotifyNetworkConnected(kNewNetworkForTests);
2987
2988 // Cause the connection to report path degrading to the session.
2989 // Due to lack of alternate network, session will not mgirate connection.
2990 EXPECT_EQ(0u, task_runner->GetPendingTaskCount());
2991 scoped_mock_network_change_notifier_->mock_network_change_notifier()
2992 ->NotifyNetworkMadeDefault(kNewNetworkForTests);
2993
2994 // A task will be posted to migrate to the new default network.
2995 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
2996 EXPECT_EQ(base::TimeDelta(), task_runner->NextPendingTaskDelay());
2997
2998 // Execute the posted task to migrate back to the default network.
2999 task_runner->RunUntilIdle();
3000 // Another task to resend a new connectivity probe is posted. And a task to
3001 // retry migrate back to default network is scheduled.
3002 EXPECT_EQ(2u, task_runner->GetPendingTaskCount());
3003 // Next connectivity probe is scheduled to be sent in 2 *
3004 // kDefaultRTTMilliSecs.
3005 base::TimeDelta next_task_delay = task_runner->NextPendingTaskDelay();
3006 base::TimeDelta expected_delay =
3007 base::TimeDelta::FromMilliseconds(2 * kDefaultRTTMilliSecs);
3008 EXPECT_EQ(expected_delay, next_task_delay);
3009
3010 // Fast forward to send the second connectivity probe. The write will be
3011 // asynchronous and complete after the read completes.
3012 task_runner->FastForwardBy(next_task_delay);
3013
3014 // Resume quic data and a connectivity probe response will be read on the new
3015 // socket, declare probing as successful.
3016 quic_data2.Resume();
3017
3018 // The connection should still be alive, and not marked as going away.
3019 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
3020 EXPECT_TRUE(HasActiveSession(host_port_pair_));
3021 EXPECT_EQ(1u, session->GetNumActiveStreams());
3022 EXPECT_EQ(ERR_IO_PENDING, stream->ReadResponseHeaders(callback_.callback()));
3023
3024 // There should be three pending tasks, the nearest one will complete
3025 // migration to the new network. Second task will retry migrate back to
3026 // default but cancelled, and the third task will retry send connectivity
3027 // probe but also cancelled.
3028 EXPECT_EQ(3u, task_runner->GetPendingTaskCount());
3029 EXPECT_EQ(base::TimeDelta(), task_runner->NextPendingTaskDelay());
3030 task_runner->RunUntilIdle();
3031
3032 // Response headers are received over the new network.
3033 EXPECT_THAT(callback_.WaitForResult(), IsOk());
3034 EXPECT_EQ(200, response.headers->response_code());
3035
3036 // Run the message loop to complete the asynchronous write of ack and ping.
3037 base::RunLoop().RunUntilIdle();
3038
3039 // Now there are two pending tasks, the nearest one was to retry migrate back
3040 // to default network and has been cancelled due to successful migration.
3041 EXPECT_EQ(2u, task_runner->GetPendingTaskCount());
3042 expected_delay =
3043 base::TimeDelta::FromSeconds(kMinRetryTimeForDefaultNetworkSecs) -
3044 expected_delay;
3045 next_task_delay = task_runner->NextPendingTaskDelay();
3046 EXPECT_EQ(expected_delay, next_task_delay);
3047 task_runner->FastForwardBy(next_task_delay);
3048
3049 // There's one more task to retry sending connectivity probe in 0.4s and has
3050 // also been cancelled due to the successful probing.
3051 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
3052 next_task_delay = task_runner->NextPendingTaskDelay();
3053 expected_delay =
3054 base::TimeDelta::FromMilliseconds(3 * 2 * kDefaultRTTMilliSecs) -
3055 base::TimeDelta::FromSeconds(kMinRetryTimeForDefaultNetworkSecs);
3056 EXPECT_EQ(expected_delay, next_task_delay);
3057 task_runner->FastForwardBy(next_task_delay);
3058 EXPECT_EQ(0u, task_runner->GetPendingTaskCount());
3059
3060 // Verify that the session is still alive.
3061 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
3062 EXPECT_TRUE(HasActiveSession(host_port_pair_));
3063
3064 stream.reset();
3065 EXPECT_TRUE(quic_data1.AllReadDataConsumed());
3066 EXPECT_TRUE(quic_data1.AllWriteDataConsumed());
3067 EXPECT_TRUE(quic_data2.AllReadDataConsumed());
3068 EXPECT_TRUE(quic_data2.AllWriteDataConsumed());
3069 }
3070
3071 // This test verifies that session times out connection migration attempt
3072 // with signals delivered in the following order (no alternate network is
3073 // available):
3074 // - default network disconnected is delivered: session attempts connection
3075 // migration but found not alternate network. Session waits for a new network
3076 // comes up in the next kWaitTimeForNewNetworkSecs seconds.
3077 // - no new network is connected, migration times out. Session is closed.
TEST_P(QuicStreamFactoryTest,MigrationTimeoutWithNoNewNetwork)3078 TEST_P(QuicStreamFactoryTest, MigrationTimeoutWithNoNewNetwork) {
3079 InitializeConnectionMigrationV2Test({kDefaultNetworkForTests});
3080 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
3081 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
3082
3083 // Using a testing task runner so that we can control time.
3084 auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
3085 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
3086
3087 MockQuicData socket_data(version_);
3088 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
3089 if (VersionUsesHttp3(version_.transport_version))
3090 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
3091 socket_data.AddSocketDataToFactory(socket_factory_.get());
3092
3093 // Create request and QuicHttpStream.
3094 QuicStreamRequest request(factory_.get());
3095 EXPECT_EQ(
3096 ERR_IO_PENDING,
3097 request.Request(
3098 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
3099 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
3100 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
3101 failed_on_default_network_callback_, callback_.callback()));
3102 EXPECT_THAT(callback_.WaitForResult(), IsOk());
3103 std::unique_ptr<HttpStream> stream = CreateStream(&request);
3104 EXPECT_TRUE(stream.get());
3105
3106 // Cause QUIC stream to be created.
3107 HttpRequestInfo request_info;
3108 request_info.traffic_annotation =
3109 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
3110 EXPECT_EQ(OK, stream->InitializeStream(&request_info, false, DEFAULT_PRIORITY,
3111 net_log_, CompletionOnceCallback()));
3112
3113 // Ensure that session is alive and active.
3114 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
3115 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
3116 EXPECT_TRUE(HasActiveSession(host_port_pair_));
3117
3118 // Trigger connection migration. Since there are no networks
3119 // to migrate to, this should cause the session to wait for a new network.
3120 scoped_mock_network_change_notifier_->mock_network_change_notifier()
3121 ->NotifyNetworkDisconnected(kDefaultNetworkForTests);
3122
3123 // The migration will not fail until the migration alarm timeout.
3124 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
3125 EXPECT_TRUE(HasActiveSession(host_port_pair_));
3126 EXPECT_EQ(1u, session->GetNumActiveStreams());
3127 EXPECT_EQ(ERR_IO_PENDING, stream->ReadResponseHeaders(callback_.callback()));
3128 EXPECT_EQ(true, session->connection()->writer()->IsWriteBlocked());
3129
3130 // Migration will be timed out after kWaitTimeForNewNetwokSecs.
3131 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
3132 base::TimeDelta next_task_delay = task_runner->NextPendingTaskDelay();
3133 EXPECT_EQ(base::TimeDelta::FromSeconds(kWaitTimeForNewNetworkSecs),
3134 next_task_delay);
3135 task_runner->FastForwardBy(next_task_delay);
3136
3137 // The connection should now be closed. A request for response
3138 // headers should fail.
3139 EXPECT_FALSE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
3140 EXPECT_FALSE(HasActiveSession(host_port_pair_));
3141 EXPECT_EQ(ERR_INTERNET_DISCONNECTED, callback_.WaitForResult());
3142
3143 EXPECT_TRUE(socket_data.AllReadDataConsumed());
3144 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
3145 }
3146
3147 // This test verifies that connectivity probes will be sent even if there is
3148 // a non-migratable stream. However, when connection migrates to the
3149 // successfully probed path, any non-migratable streams will be reset.
TEST_P(QuicStreamFactoryTest,OnNetworkMadeDefaultNonMigratableStream_MigrateIdleSessions)3150 TEST_P(QuicStreamFactoryTest,
3151 OnNetworkMadeDefaultNonMigratableStream_MigrateIdleSessions) {
3152 TestOnNetworkMadeDefaultNonMigratableStream(true);
3153 }
3154
3155 // This test verifies that connectivity probes will be sent even if there is
3156 // a non-migratable stream. However, when connection migrates to the
3157 // successfully probed path, any non-migratable stream will be reset. And if
3158 // the connection becomes idle then, close the connection.
TEST_P(QuicStreamFactoryTest,OnNetworkMadeDefaultNonMigratableStream_DoNotMigrateIdleSessions)3159 TEST_P(QuicStreamFactoryTest,
3160 OnNetworkMadeDefaultNonMigratableStream_DoNotMigrateIdleSessions) {
3161 TestOnNetworkMadeDefaultNonMigratableStream(false);
3162 }
3163
TestOnNetworkMadeDefaultNonMigratableStream(bool migrate_idle_sessions)3164 void QuicStreamFactoryTestBase::TestOnNetworkMadeDefaultNonMigratableStream(
3165 bool migrate_idle_sessions) {
3166 quic_params_->migrate_idle_sessions = migrate_idle_sessions;
3167 InitializeConnectionMigrationV2Test(
3168 {kDefaultNetworkForTests, kNewNetworkForTests});
3169 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
3170 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
3171
3172 MockQuicData socket_data(version_);
3173 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
3174 int packet_num = 1;
3175 if (VersionUsesHttp3(version_.transport_version)) {
3176 socket_data.AddWrite(SYNCHRONOUS,
3177 ConstructInitialSettingsPacket(packet_num++));
3178 }
3179
3180 // Set up the second socket data provider that is used for probing.
3181 MockQuicData quic_data1(version_);
3182 // Connectivity probe to be sent on the new path.
3183 quic_data1.AddWrite(SYNCHRONOUS, client_maker_.MakeConnectivityProbingPacket(
3184 packet_num++, true));
3185 quic_data1.AddRead(ASYNC, ERR_IO_PENDING); // Pause
3186 // Connectivity probe to receive from the server.
3187 quic_data1.AddRead(ASYNC,
3188 server_maker_.MakeConnectivityProbingPacket(1, false));
3189
3190 if (migrate_idle_sessions) {
3191 quic_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read.
3192 // A RESET will be sent to the peer to cancel the non-migratable stream.
3193 if (VersionUsesHttp3(version_.transport_version)) {
3194 quic_data1.AddWrite(SYNCHRONOUS,
3195 client_maker_.MakeDataRstAndAckPacket(
3196 packet_num++, true, GetQpackDecoderStreamId(),
3197 StreamCancellationQpackDecoderInstruction(0),
3198 GetNthClientInitiatedBidirectionalStreamId(0),
3199 quic::QUIC_STREAM_CANCELLED, 1, 1));
3200 } else {
3201 quic_data1.AddWrite(SYNCHRONOUS,
3202 client_maker_.MakeAckAndRstPacket(
3203 packet_num++, false,
3204 GetNthClientInitiatedBidirectionalStreamId(0),
3205 quic::QUIC_STREAM_CANCELLED, 1, 1));
3206 }
3207 // Ping packet to send after migration is completed.
3208 quic_data1.AddWrite(SYNCHRONOUS,
3209 client_maker_.MakePingPacket(packet_num++, false));
3210 } else {
3211 if (version_.UsesTls()) {
3212 if (VersionUsesHttp3(version_.transport_version)) {
3213 socket_data.AddWrite(
3214 SYNCHRONOUS,
3215 client_maker_.MakeDataRstAckAndConnectionClosePacket(
3216 packet_num++, false, GetQpackDecoderStreamId(),
3217 StreamCancellationQpackDecoderInstruction(0),
3218 GetNthClientInitiatedBidirectionalStreamId(0),
3219 quic::QUIC_STREAM_CANCELLED, 1, 1,
3220 quic::QUIC_CONNECTION_MIGRATION_NO_MIGRATABLE_STREAMS,
3221 "net error"));
3222 } else {
3223 socket_data.AddWrite(
3224 SYNCHRONOUS,
3225 client_maker_.MakeRstAckAndConnectionClosePacket(
3226 packet_num++, false,
3227 GetNthClientInitiatedBidirectionalStreamId(0),
3228 quic::QUIC_STREAM_CANCELLED, 1, 1,
3229 quic::QUIC_CONNECTION_MIGRATION_NO_MIGRATABLE_STREAMS,
3230 "net error"));
3231 }
3232 } else {
3233 if (VersionUsesHttp3(version_.transport_version)) {
3234 socket_data.AddWrite(
3235 SYNCHRONOUS,
3236 client_maker_.MakeDataRstAckAndConnectionClosePacket(
3237 packet_num++, false, GetQpackDecoderStreamId(),
3238 StreamCancellationQpackDecoderInstruction(0),
3239 GetNthClientInitiatedBidirectionalStreamId(0),
3240 quic::QUIC_STREAM_CANCELLED, 1, 1,
3241 quic::QUIC_CONNECTION_MIGRATION_NO_MIGRATABLE_STREAMS,
3242 "net error"));
3243 } else {
3244 socket_data.AddWrite(
3245 SYNCHRONOUS,
3246 client_maker_.MakeRstAckAndConnectionClosePacket(
3247 packet_num++, false,
3248 GetNthClientInitiatedBidirectionalStreamId(0),
3249 quic::QUIC_STREAM_CANCELLED, 1, 1,
3250 quic::QUIC_CONNECTION_MIGRATION_NO_MIGRATABLE_STREAMS,
3251 "net error"));
3252 }
3253 }
3254 }
3255
3256 socket_data.AddSocketDataToFactory(socket_factory_.get());
3257 quic_data1.AddSocketDataToFactory(socket_factory_.get());
3258
3259 // Create request and QuicHttpStream.
3260 QuicStreamRequest request(factory_.get());
3261 EXPECT_EQ(
3262 ERR_IO_PENDING,
3263 request.Request(
3264 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
3265 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
3266 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
3267 failed_on_default_network_callback_, callback_.callback()));
3268 EXPECT_THAT(callback_.WaitForResult(), IsOk());
3269 std::unique_ptr<HttpStream> stream = CreateStream(&request);
3270 EXPECT_TRUE(stream.get());
3271
3272 // Cause QUIC stream to be created, but marked as non-migratable.
3273 HttpRequestInfo request_info;
3274 request_info.load_flags |= LOAD_DISABLE_CONNECTION_MIGRATION_TO_CELLULAR;
3275 request_info.traffic_annotation =
3276 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
3277 EXPECT_EQ(OK, stream->InitializeStream(&request_info, false, DEFAULT_PRIORITY,
3278 net_log_, CompletionOnceCallback()));
3279
3280 // Ensure that session is alive and active.
3281 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
3282 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
3283 EXPECT_TRUE(HasActiveSession(host_port_pair_));
3284
3285 // Trigger connection migration. Session will start to probe the alternative
3286 // network. Although there is a non-migratable stream, session will still be
3287 // active until probing is declared as successful.
3288 scoped_mock_network_change_notifier_->mock_network_change_notifier()
3289 ->NotifyNetworkMadeDefault(kNewNetworkForTests);
3290
3291 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
3292 EXPECT_TRUE(HasActiveSession(host_port_pair_));
3293 EXPECT_EQ(1u, session->GetNumActiveStreams());
3294
3295 // Resume data to read a connectivity probing response, which will cause
3296 // non-migtable streams to be closed.
3297 quic_data1.Resume();
3298 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
3299 EXPECT_EQ(migrate_idle_sessions, HasActiveSession(host_port_pair_));
3300 EXPECT_EQ(0u, session->GetNumActiveStreams());
3301
3302 base::RunLoop().RunUntilIdle();
3303
3304 EXPECT_TRUE(quic_data1.AllReadDataConsumed());
3305 EXPECT_TRUE(quic_data1.AllWriteDataConsumed());
3306 EXPECT_TRUE(socket_data.AllReadDataConsumed());
3307 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
3308 }
3309
TEST_P(QuicStreamFactoryTest,OnNetworkMadeDefaultConnectionMigrationDisabled)3310 TEST_P(QuicStreamFactoryTest, OnNetworkMadeDefaultConnectionMigrationDisabled) {
3311 InitializeConnectionMigrationV2Test(
3312 {kDefaultNetworkForTests, kNewNetworkForTests});
3313 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
3314 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
3315
3316 MockQuicData socket_data(version_);
3317 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
3318 int packet_num = 1;
3319 if (VersionUsesHttp3(version_.transport_version)) {
3320 socket_data.AddWrite(SYNCHRONOUS,
3321 ConstructInitialSettingsPacket(packet_num++));
3322 socket_data.AddWrite(
3323 SYNCHRONOUS, client_maker_.MakeDataPacket(
3324 packet_num++, GetQpackDecoderStreamId(), true, false,
3325 StreamCancellationQpackDecoderInstruction(0)));
3326 }
3327 socket_data.AddWrite(
3328 SYNCHRONOUS,
3329 client_maker_.MakeRstPacket(packet_num++, true,
3330 GetNthClientInitiatedBidirectionalStreamId(0),
3331 quic::QUIC_STREAM_CANCELLED));
3332 socket_data.AddSocketDataToFactory(socket_factory_.get());
3333
3334 // Create request and QuicHttpStream.
3335 QuicStreamRequest request(factory_.get());
3336 EXPECT_EQ(
3337 ERR_IO_PENDING,
3338 request.Request(
3339 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
3340 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
3341 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
3342 failed_on_default_network_callback_, callback_.callback()));
3343 EXPECT_THAT(callback_.WaitForResult(), IsOk());
3344 std::unique_ptr<HttpStream> stream = CreateStream(&request);
3345 EXPECT_TRUE(stream.get());
3346
3347 // Cause QUIC stream to be created.
3348 HttpRequestInfo request_info;
3349 request_info.traffic_annotation =
3350 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
3351 EXPECT_EQ(OK, stream->InitializeStream(&request_info, false, DEFAULT_PRIORITY,
3352 net_log_, CompletionOnceCallback()));
3353
3354 // Ensure that session is alive and active.
3355 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
3356 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
3357 EXPECT_TRUE(HasActiveSession(host_port_pair_));
3358
3359 // Set session config to have connection migration disabled.
3360 quic::test::QuicConfigPeer::SetReceivedDisableConnectionMigration(
3361 session->config());
3362 EXPECT_TRUE(session->config()->DisableConnectionMigration());
3363
3364 // Trigger connection migration. Since there is a non-migratable stream,
3365 // this should cause session to continue but be marked as going away.
3366 scoped_mock_network_change_notifier_->mock_network_change_notifier()
3367 ->NotifyNetworkMadeDefault(kNewNetworkForTests);
3368
3369 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
3370 EXPECT_FALSE(HasActiveSession(host_port_pair_));
3371 EXPECT_EQ(1u, session->GetNumActiveStreams());
3372
3373 stream.reset();
3374
3375 EXPECT_TRUE(socket_data.AllReadDataConsumed());
3376 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
3377 }
3378
TEST_P(QuicStreamFactoryTest,OnNetworkDisconnectedNonMigratableStream_DoNotMigrateIdleSessions)3379 TEST_P(QuicStreamFactoryTest,
3380 OnNetworkDisconnectedNonMigratableStream_DoNotMigrateIdleSessions) {
3381 TestOnNetworkDisconnectedNonMigratableStream(false);
3382 }
3383
TEST_P(QuicStreamFactoryTest,OnNetworkDisconnectedNonMigratableStream_MigrateIdleSessions)3384 TEST_P(QuicStreamFactoryTest,
3385 OnNetworkDisconnectedNonMigratableStream_MigrateIdleSessions) {
3386 TestOnNetworkDisconnectedNonMigratableStream(true);
3387 }
3388
TestOnNetworkDisconnectedNonMigratableStream(bool migrate_idle_sessions)3389 void QuicStreamFactoryTestBase::TestOnNetworkDisconnectedNonMigratableStream(
3390 bool migrate_idle_sessions) {
3391 quic_params_->migrate_idle_sessions = migrate_idle_sessions;
3392 InitializeConnectionMigrationV2Test(
3393 {kDefaultNetworkForTests, kNewNetworkForTests});
3394 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
3395 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
3396
3397 MockQuicData failed_socket_data(version_);
3398 MockQuicData socket_data(version_);
3399 if (migrate_idle_sessions) {
3400 failed_socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
3401 int packet_num = 1;
3402 if (VersionUsesHttp3(version_.transport_version)) {
3403 failed_socket_data.AddWrite(SYNCHRONOUS,
3404 ConstructInitialSettingsPacket(packet_num++));
3405 }
3406 // A RESET will be sent to the peer to cancel the non-migratable stream.
3407 if (VersionUsesHttp3(version_.transport_version)) {
3408 failed_socket_data.AddWrite(
3409 SYNCHRONOUS, client_maker_.MakeDataPacket(
3410 packet_num++, GetQpackDecoderStreamId(), true, false,
3411 StreamCancellationQpackDecoderInstruction(0)));
3412 }
3413 failed_socket_data.AddWrite(
3414 SYNCHRONOUS,
3415 client_maker_.MakeRstPacket(
3416 packet_num++, true, GetNthClientInitiatedBidirectionalStreamId(0),
3417 quic::QUIC_STREAM_CANCELLED));
3418 failed_socket_data.AddSocketDataToFactory(socket_factory_.get());
3419
3420 // Set up second socket data provider that is used after migration.
3421 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read.
3422 // Ping packet to send after migration.
3423 socket_data.AddWrite(
3424 SYNCHRONOUS,
3425 client_maker_.MakePingPacket(packet_num++, /*include_version=*/true));
3426 socket_data.AddSocketDataToFactory(socket_factory_.get());
3427 } else {
3428 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
3429 int packet_num = 1;
3430 if (VersionUsesHttp3(version_.transport_version)) {
3431 socket_data.AddWrite(SYNCHRONOUS,
3432 ConstructInitialSettingsPacket(packet_num++));
3433 socket_data.AddWrite(
3434 SYNCHRONOUS, client_maker_.MakeDataPacket(
3435 packet_num++, GetQpackDecoderStreamId(), true, false,
3436 StreamCancellationQpackDecoderInstruction(0)));
3437 }
3438 socket_data.AddWrite(
3439 SYNCHRONOUS,
3440 client_maker_.MakeRstPacket(
3441 packet_num++, true, GetNthClientInitiatedBidirectionalStreamId(0),
3442 quic::QUIC_STREAM_CANCELLED));
3443 socket_data.AddSocketDataToFactory(socket_factory_.get());
3444 }
3445
3446 // Create request and QuicHttpStream.
3447 QuicStreamRequest request(factory_.get());
3448 EXPECT_EQ(
3449 ERR_IO_PENDING,
3450 request.Request(
3451 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
3452 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
3453 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
3454 failed_on_default_network_callback_, callback_.callback()));
3455 EXPECT_THAT(callback_.WaitForResult(), IsOk());
3456 std::unique_ptr<HttpStream> stream = CreateStream(&request);
3457 EXPECT_TRUE(stream.get());
3458
3459 // Cause QUIC stream to be created, but marked as non-migratable.
3460 HttpRequestInfo request_info;
3461 request_info.load_flags |= LOAD_DISABLE_CONNECTION_MIGRATION_TO_CELLULAR;
3462 request_info.traffic_annotation =
3463 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
3464 EXPECT_EQ(OK, stream->InitializeStream(&request_info, false, DEFAULT_PRIORITY,
3465 net_log_, CompletionOnceCallback()));
3466
3467 // Ensure that session is alive and active.
3468 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
3469 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
3470 EXPECT_TRUE(HasActiveSession(host_port_pair_));
3471
3472 // Trigger connection migration. Since there is a non-migratable stream,
3473 // this should cause a RST_STREAM frame to be emitted with
3474 // quic::QUIC_STREAM_CANCELLED error code.
3475 // If migate idle session, the connection will then be migrated to the
3476 // alternate network. Otherwise, the connection will be closed.
3477 scoped_mock_network_change_notifier_->mock_network_change_notifier()
3478 ->NotifyNetworkDisconnected(kDefaultNetworkForTests);
3479
3480 EXPECT_EQ(migrate_idle_sessions,
3481 QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
3482 EXPECT_EQ(migrate_idle_sessions, HasActiveSession(host_port_pair_));
3483
3484 if (migrate_idle_sessions) {
3485 EXPECT_EQ(0u, session->GetNumActiveStreams());
3486 base::RunLoop().RunUntilIdle();
3487
3488 EXPECT_TRUE(failed_socket_data.AllReadDataConsumed());
3489 EXPECT_TRUE(failed_socket_data.AllWriteDataConsumed());
3490 }
3491 EXPECT_TRUE(socket_data.AllReadDataConsumed());
3492 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
3493 }
3494
TEST_P(QuicStreamFactoryTest,OnNetworkDisconnectedConnectionMigrationDisabled)3495 TEST_P(QuicStreamFactoryTest,
3496 OnNetworkDisconnectedConnectionMigrationDisabled) {
3497 InitializeConnectionMigrationV2Test(
3498 {kDefaultNetworkForTests, kNewNetworkForTests});
3499 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
3500 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
3501
3502 MockQuicData socket_data(version_);
3503 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
3504 int packet_num = 1;
3505 if (VersionUsesHttp3(version_.transport_version)) {
3506 socket_data.AddWrite(SYNCHRONOUS,
3507 ConstructInitialSettingsPacket(packet_num++));
3508 }
3509 socket_data.AddSocketDataToFactory(socket_factory_.get());
3510
3511 // Create request and QuicHttpStream.
3512 QuicStreamRequest request(factory_.get());
3513 EXPECT_EQ(
3514 ERR_IO_PENDING,
3515 request.Request(
3516 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
3517 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
3518 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
3519 failed_on_default_network_callback_, callback_.callback()));
3520 EXPECT_THAT(callback_.WaitForResult(), IsOk());
3521 std::unique_ptr<HttpStream> stream = CreateStream(&request);
3522 EXPECT_TRUE(stream.get());
3523
3524 // Cause QUIC stream to be created.
3525 HttpRequestInfo request_info;
3526 request_info.traffic_annotation =
3527 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
3528 EXPECT_EQ(OK, stream->InitializeStream(&request_info, false, DEFAULT_PRIORITY,
3529 net_log_, CompletionOnceCallback()));
3530
3531 // Ensure that session is alive and active.
3532 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
3533 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
3534 EXPECT_TRUE(HasActiveSession(host_port_pair_));
3535
3536 // Set session config to have connection migration disabled.
3537 quic::test::QuicConfigPeer::SetReceivedDisableConnectionMigration(
3538 session->config());
3539 EXPECT_TRUE(session->config()->DisableConnectionMigration());
3540
3541 // Trigger connection migration.
3542 scoped_mock_network_change_notifier_->mock_network_change_notifier()
3543 ->NotifyNetworkDisconnected(kDefaultNetworkForTests);
3544
3545 EXPECT_FALSE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
3546 EXPECT_FALSE(HasActiveSession(host_port_pair_));
3547
3548 EXPECT_TRUE(socket_data.AllReadDataConsumed());
3549 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
3550 }
3551
TEST_P(QuicStreamFactoryTest,OnNetworkMadeDefaultNoOpenStreams_DoNotMigrateIdleSessions)3552 TEST_P(QuicStreamFactoryTest,
3553 OnNetworkMadeDefaultNoOpenStreams_DoNotMigrateIdleSessions) {
3554 TestOnNetworkMadeDefaultNoOpenStreams(false);
3555 }
3556
TEST_P(QuicStreamFactoryTest,OnNetworkMadeDefaultNoOpenStreams_MigrateIdleSessions)3557 TEST_P(QuicStreamFactoryTest,
3558 OnNetworkMadeDefaultNoOpenStreams_MigrateIdleSessions) {
3559 TestOnNetworkMadeDefaultNoOpenStreams(true);
3560 }
3561
TestOnNetworkMadeDefaultNoOpenStreams(bool migrate_idle_sessions)3562 void QuicStreamFactoryTestBase::TestOnNetworkMadeDefaultNoOpenStreams(
3563 bool migrate_idle_sessions) {
3564 quic_params_->migrate_idle_sessions = migrate_idle_sessions;
3565 InitializeConnectionMigrationV2Test(
3566 {kDefaultNetworkForTests, kNewNetworkForTests});
3567 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
3568 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
3569
3570 MockQuicData socket_data(version_);
3571 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
3572 int packet_num = 1;
3573 if (VersionUsesHttp3(version_.transport_version)) {
3574 socket_data.AddWrite(SYNCHRONOUS,
3575 ConstructInitialSettingsPacket(packet_num++));
3576 }
3577 if (!migrate_idle_sessions) {
3578 socket_data.AddWrite(
3579 SYNCHRONOUS, client_maker_.MakeConnectionClosePacket(
3580 packet_num, true,
3581 quic::QUIC_CONNECTION_MIGRATION_NO_MIGRATABLE_STREAMS,
3582 "net error"));
3583 }
3584 socket_data.AddSocketDataToFactory(socket_factory_.get());
3585
3586 MockQuicData quic_data1(version_);
3587 if (migrate_idle_sessions) {
3588 // Set up the second socket data provider that is used for probing.
3589 // Connectivity probe to be sent on the new path.
3590 quic_data1.AddWrite(
3591 SYNCHRONOUS,
3592 client_maker_.MakeConnectivityProbingPacket(packet_num++, true));
3593 quic_data1.AddRead(ASYNC, ERR_IO_PENDING); // Pause
3594 // Connectivity probe to receive from the server.
3595 quic_data1.AddRead(ASYNC,
3596 server_maker_.MakeConnectivityProbingPacket(1, false));
3597 quic_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read.
3598 // Ping packet to send after migration is completed.
3599 quic_data1.AddWrite(SYNCHRONOUS, client_maker_.MakeAckAndPingPacket(
3600 packet_num, false, 1, 1));
3601 quic_data1.AddSocketDataToFactory(socket_factory_.get());
3602 }
3603
3604 // Create request and QuicHttpStream.
3605 QuicStreamRequest request(factory_.get());
3606 EXPECT_EQ(
3607 ERR_IO_PENDING,
3608 request.Request(
3609 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
3610 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
3611 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
3612 failed_on_default_network_callback_, callback_.callback()));
3613 EXPECT_THAT(callback_.WaitForResult(), IsOk());
3614 std::unique_ptr<HttpStream> stream = CreateStream(&request);
3615 EXPECT_TRUE(stream.get());
3616
3617 // Ensure that session is alive and active.
3618 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
3619 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
3620 EXPECT_TRUE(HasActiveSession(host_port_pair_));
3621 EXPECT_FALSE(session->HasActiveRequestStreams());
3622
3623 // Trigger connection migration.
3624 scoped_mock_network_change_notifier_->mock_network_change_notifier()
3625 ->NotifyNetworkMadeDefault(kNewNetworkForTests);
3626 EXPECT_EQ(migrate_idle_sessions, HasActiveSession(host_port_pair_));
3627
3628 if (migrate_idle_sessions) {
3629 quic_data1.Resume();
3630 base::RunLoop().RunUntilIdle();
3631 EXPECT_TRUE(quic_data1.AllReadDataConsumed());
3632 EXPECT_TRUE(quic_data1.AllWriteDataConsumed());
3633 }
3634 EXPECT_TRUE(socket_data.AllReadDataConsumed());
3635 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
3636 }
3637
TEST_P(QuicStreamFactoryTest,OnNetworkDisconnectedNoOpenStreams_DoNotMigateIdleSessions)3638 TEST_P(QuicStreamFactoryTest,
3639 OnNetworkDisconnectedNoOpenStreams_DoNotMigateIdleSessions) {
3640 TestOnNetworkDisconnectedNoOpenStreams(false);
3641 }
3642
TEST_P(QuicStreamFactoryTest,OnNetworkDisconnectedNoOpenStreams_MigateIdleSessions)3643 TEST_P(QuicStreamFactoryTest,
3644 OnNetworkDisconnectedNoOpenStreams_MigateIdleSessions) {
3645 TestOnNetworkDisconnectedNoOpenStreams(true);
3646 }
3647
TestOnNetworkDisconnectedNoOpenStreams(bool migrate_idle_sessions)3648 void QuicStreamFactoryTestBase::TestOnNetworkDisconnectedNoOpenStreams(
3649 bool migrate_idle_sessions) {
3650 quic_params_->migrate_idle_sessions = migrate_idle_sessions;
3651 InitializeConnectionMigrationV2Test(
3652 {kDefaultNetworkForTests, kNewNetworkForTests});
3653 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
3654 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
3655
3656 MockQuicData default_socket_data(version_);
3657 default_socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
3658 int packet_num = 1;
3659 if (VersionUsesHttp3(version_.transport_version)) {
3660 default_socket_data.AddWrite(SYNCHRONOUS,
3661 ConstructInitialSettingsPacket(packet_num++));
3662 }
3663 default_socket_data.AddSocketDataToFactory(socket_factory_.get());
3664
3665 MockQuicData alternate_socket_data(version_);
3666 if (migrate_idle_sessions) {
3667 // Set up second socket data provider that is used after migration.
3668 alternate_socket_data.AddRead(SYNCHRONOUS,
3669 ERR_IO_PENDING); // Hanging read.
3670 // Ping packet to send after migration.
3671 alternate_socket_data.AddWrite(
3672 SYNCHRONOUS,
3673 client_maker_.MakePingPacket(packet_num, /*include_version=*/true));
3674 alternate_socket_data.AddSocketDataToFactory(socket_factory_.get());
3675 }
3676
3677 // Create request and QuicHttpStream.
3678 QuicStreamRequest request(factory_.get());
3679 EXPECT_EQ(
3680 ERR_IO_PENDING,
3681 request.Request(
3682 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
3683 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
3684 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
3685 failed_on_default_network_callback_, callback_.callback()));
3686 EXPECT_THAT(callback_.WaitForResult(), IsOk());
3687 std::unique_ptr<HttpStream> stream = CreateStream(&request);
3688 EXPECT_TRUE(stream.get());
3689
3690 // Ensure that session is active.
3691 EXPECT_TRUE(HasActiveSession(host_port_pair_));
3692
3693 // Trigger connection migration. Since there are no active streams,
3694 // the session will be closed.
3695 scoped_mock_network_change_notifier_->mock_network_change_notifier()
3696 ->NotifyNetworkDisconnected(kDefaultNetworkForTests);
3697
3698 EXPECT_EQ(migrate_idle_sessions, HasActiveSession(host_port_pair_));
3699
3700 EXPECT_TRUE(default_socket_data.AllReadDataConsumed());
3701 EXPECT_TRUE(default_socket_data.AllWriteDataConsumed());
3702 if (migrate_idle_sessions) {
3703 EXPECT_TRUE(alternate_socket_data.AllReadDataConsumed());
3704 EXPECT_TRUE(alternate_socket_data.AllWriteDataConsumed());
3705 }
3706 }
3707
3708 // This test verifies session migrates to the alternate network immediately when
3709 // default network disconnects with a synchronous write before migration.
TEST_P(QuicStreamFactoryTest,MigrateOnDefaultNetworkDisconnectedSync)3710 TEST_P(QuicStreamFactoryTest, MigrateOnDefaultNetworkDisconnectedSync) {
3711 TestMigrationOnNetworkDisconnected(/*async_write_before*/ false);
3712 }
3713
3714 // This test verifies session migrates to the alternate network immediately when
3715 // default network disconnects with an asynchronously write before migration.
TEST_P(QuicStreamFactoryTest,MigrateOnDefaultNetworkDisconnectedAsync)3716 TEST_P(QuicStreamFactoryTest, MigrateOnDefaultNetworkDisconnectedAsync) {
3717 TestMigrationOnNetworkDisconnected(/*async_write_before*/ true);
3718 }
3719
TestMigrationOnNetworkDisconnected(bool async_write_before)3720 void QuicStreamFactoryTestBase::TestMigrationOnNetworkDisconnected(
3721 bool async_write_before) {
3722 InitializeConnectionMigrationV2Test(
3723 {kDefaultNetworkForTests, kNewNetworkForTests});
3724 scoped_mock_network_change_notifier_->mock_network_change_notifier()
3725 ->NotifyNetworkMadeDefault(kDefaultNetworkForTests);
3726 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
3727 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
3728 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
3729
3730 // Use the test task runner.
3731 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), runner_.get());
3732
3733 int packet_number = 1;
3734 MockQuicData socket_data(version_);
3735 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
3736 if (VersionUsesHttp3(version_.transport_version)) {
3737 socket_data.AddWrite(SYNCHRONOUS,
3738 ConstructInitialSettingsPacket(packet_number++));
3739 }
3740 socket_data.AddWrite(
3741 SYNCHRONOUS,
3742 ConstructGetRequestPacket(packet_number++,
3743 GetNthClientInitiatedBidirectionalStreamId(0),
3744 true, true));
3745 if (async_write_before) {
3746 socket_data.AddWrite(ASYNC, OK);
3747 packet_number++;
3748 }
3749 socket_data.AddSocketDataToFactory(socket_factory_.get());
3750
3751 // Create request and QuicHttpStream.
3752 QuicStreamRequest request(factory_.get());
3753 EXPECT_EQ(
3754 ERR_IO_PENDING,
3755 request.Request(
3756 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
3757 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
3758 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
3759 failed_on_default_network_callback_, callback_.callback()));
3760 EXPECT_THAT(callback_.WaitForResult(), IsOk());
3761 std::unique_ptr<HttpStream> stream = CreateStream(&request);
3762 EXPECT_TRUE(stream.get());
3763
3764 // Cause QUIC stream to be created.
3765 HttpRequestInfo request_info;
3766 request_info.method = "GET";
3767 request_info.url = url_;
3768 request_info.traffic_annotation =
3769 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
3770 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
3771 net_log_, CompletionOnceCallback()));
3772
3773 // Ensure that session is alive and active.
3774 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
3775 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
3776 EXPECT_TRUE(HasActiveSession(host_port_pair_));
3777
3778 // Send GET request on stream.
3779 HttpResponseInfo response;
3780 HttpRequestHeaders request_headers;
3781 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
3782 callback_.callback()));
3783
3784 if (async_write_before)
3785 session->SendPing();
3786
3787 // Set up second socket data provider that is used after migration.
3788 // The response to the earlier request is read on this new socket.
3789 MockQuicData socket_data1(version_);
3790 socket_data1.AddWrite(
3791 SYNCHRONOUS,
3792 client_maker_.MakePingPacket(packet_number++, /*include_version=*/true));
3793 socket_data1.AddRead(
3794 ASYNC,
3795 ConstructOkResponsePacket(
3796 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false));
3797 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
3798 if (VersionUsesHttp3(version_.transport_version)) {
3799 socket_data1.AddWrite(
3800 SYNCHRONOUS,
3801 client_maker_.MakeAckAndDataPacket(
3802 packet_number++, false, GetQpackDecoderStreamId(), 1, 1, false,
3803 StreamCancellationQpackDecoderInstruction(0)));
3804 socket_data1.AddWrite(SYNCHRONOUS,
3805 client_maker_.MakeRstPacket(
3806 packet_number++, false,
3807 GetNthClientInitiatedBidirectionalStreamId(0),
3808 quic::QUIC_STREAM_CANCELLED));
3809 } else {
3810 socket_data1.AddWrite(SYNCHRONOUS,
3811 client_maker_.MakeAckAndRstPacket(
3812 packet_number++, false,
3813 GetNthClientInitiatedBidirectionalStreamId(0),
3814 quic::QUIC_STREAM_CANCELLED, 1, 1));
3815 }
3816 socket_data1.AddSocketDataToFactory(socket_factory_.get());
3817
3818 // Trigger connection migration.
3819 scoped_mock_network_change_notifier_->mock_network_change_notifier()
3820 ->NotifyNetworkDisconnected(kDefaultNetworkForTests);
3821
3822 // The connection should still be alive, not marked as going away.
3823 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
3824 EXPECT_TRUE(HasActiveSession(host_port_pair_));
3825 EXPECT_EQ(1u, session->GetNumActiveStreams());
3826 EXPECT_EQ(ERR_IO_PENDING, stream->ReadResponseHeaders(callback_.callback()));
3827
3828 // Ensure that the session is still alive.
3829 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
3830 EXPECT_TRUE(HasActiveSession(host_port_pair_));
3831 EXPECT_EQ(1u, session->GetNumActiveStreams());
3832
3833 // Run the message loop so that data queued in the new socket is read by the
3834 // packet reader.
3835 runner_->RunNextTask();
3836
3837 // Response headers are received over the new network.
3838 EXPECT_THAT(callback_.WaitForResult(), IsOk());
3839 EXPECT_EQ(200, response.headers->response_code());
3840
3841 // Check that the session is still alive.
3842 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
3843 EXPECT_TRUE(HasActiveSession(host_port_pair_));
3844
3845 // There should be posted tasks not executed, which is to migrate back to
3846 // default network.
3847 EXPECT_FALSE(runner_->GetPostedTasks().empty());
3848
3849 // Receive signal to mark new network as default.
3850 scoped_mock_network_change_notifier_->mock_network_change_notifier()
3851 ->NotifyNetworkMadeDefault(kNewNetworkForTests);
3852
3853 stream.reset();
3854 EXPECT_TRUE(socket_data.AllReadDataConsumed());
3855 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
3856 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
3857 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
3858 }
3859
3860 // This test receives NCN signals in the following order:
3861 // - default network disconnected
3862 // - after a pause, new network is connected.
3863 // - new network is made default.
TEST_P(QuicStreamFactoryTest,NewNetworkConnectedAfterNoNetwork)3864 TEST_P(QuicStreamFactoryTest, NewNetworkConnectedAfterNoNetwork) {
3865 InitializeConnectionMigrationV2Test({kDefaultNetworkForTests});
3866 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
3867 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
3868 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
3869
3870 // Use the test task runner.
3871 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), runner_.get());
3872
3873 MockQuicData socket_data(version_);
3874 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
3875 int packet_num = 1;
3876 if (VersionUsesHttp3(version_.transport_version)) {
3877 socket_data.AddWrite(SYNCHRONOUS,
3878 ConstructInitialSettingsPacket(packet_num++));
3879 }
3880 socket_data.AddWrite(
3881 SYNCHRONOUS,
3882 ConstructGetRequestPacket(packet_num++,
3883 GetNthClientInitiatedBidirectionalStreamId(0),
3884 true, true));
3885 socket_data.AddSocketDataToFactory(socket_factory_.get());
3886
3887 // Create request and QuicHttpStream.
3888 QuicStreamRequest request(factory_.get());
3889 EXPECT_EQ(
3890 ERR_IO_PENDING,
3891 request.Request(
3892 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
3893 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
3894 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
3895 failed_on_default_network_callback_, callback_.callback()));
3896 EXPECT_THAT(callback_.WaitForResult(), IsOk());
3897 std::unique_ptr<HttpStream> stream = CreateStream(&request);
3898 EXPECT_TRUE(stream.get());
3899
3900 // Cause QUIC stream to be created.
3901 HttpRequestInfo request_info;
3902 request_info.method = "GET";
3903 request_info.url = url_;
3904 request_info.traffic_annotation =
3905 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
3906 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
3907 net_log_, CompletionOnceCallback()));
3908
3909 // Ensure that session is alive and active.
3910 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
3911 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
3912 EXPECT_TRUE(HasActiveSession(host_port_pair_));
3913
3914 // Send GET request on stream.
3915 HttpResponseInfo response;
3916 HttpRequestHeaders request_headers;
3917 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
3918 callback_.callback()));
3919
3920 // Trigger connection migration. Since there are no networks
3921 // to migrate to, this should cause the session to wait for a new network.
3922 scoped_mock_network_change_notifier_->mock_network_change_notifier()
3923 ->NotifyNetworkDisconnected(kDefaultNetworkForTests);
3924
3925 // The connection should still be alive, not marked as going away.
3926 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
3927 EXPECT_TRUE(HasActiveSession(host_port_pair_));
3928 EXPECT_EQ(1u, session->GetNumActiveStreams());
3929 EXPECT_EQ(ERR_IO_PENDING, stream->ReadResponseHeaders(callback_.callback()));
3930
3931 // Set up second socket data provider that is used after migration.
3932 // The response to the earlier request is read on this new socket.
3933 MockQuicData socket_data1(version_);
3934 socket_data1.AddWrite(
3935 SYNCHRONOUS,
3936 client_maker_.MakePingPacket(packet_num++, /*include_version=*/true));
3937 socket_data1.AddRead(
3938 ASYNC,
3939 ConstructOkResponsePacket(
3940 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false));
3941 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
3942 if (VersionUsesHttp3(version_.transport_version)) {
3943 socket_data1.AddWrite(
3944 SYNCHRONOUS, client_maker_.MakeAckAndDataPacket(
3945 packet_num++, false, GetQpackDecoderStreamId(), 1, 1,
3946 false, StreamCancellationQpackDecoderInstruction(0)));
3947 socket_data1.AddWrite(
3948 SYNCHRONOUS,
3949 client_maker_.MakeRstPacket(
3950 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
3951 quic::QUIC_STREAM_CANCELLED));
3952 } else {
3953 socket_data1.AddWrite(
3954 SYNCHRONOUS,
3955 client_maker_.MakeAckAndRstPacket(
3956 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
3957 quic::QUIC_STREAM_CANCELLED, 1, 1));
3958 }
3959 socket_data1.AddSocketDataToFactory(socket_factory_.get());
3960
3961 // Add a new network and notify the stream factory of a new connected network.
3962 // This causes a PING packet to be sent over the new network.
3963 scoped_mock_network_change_notifier_->mock_network_change_notifier()
3964 ->SetConnectedNetworksList({kNewNetworkForTests});
3965 scoped_mock_network_change_notifier_->mock_network_change_notifier()
3966 ->NotifyNetworkConnected(kNewNetworkForTests);
3967
3968 // Ensure that the session is still alive.
3969 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
3970 EXPECT_TRUE(HasActiveSession(host_port_pair_));
3971 EXPECT_EQ(1u, session->GetNumActiveStreams());
3972
3973 // Run the message loop so that data queued in the new socket is read by the
3974 // packet reader.
3975 runner_->RunNextTask();
3976
3977 // Response headers are received over the new network.
3978 EXPECT_THAT(callback_.WaitForResult(), IsOk());
3979 EXPECT_EQ(200, response.headers->response_code());
3980
3981 // Check that the session is still alive.
3982 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
3983 EXPECT_TRUE(HasActiveSession(host_port_pair_));
3984
3985 // There should posted tasks not executed, which is to migrate back to default
3986 // network.
3987 EXPECT_FALSE(runner_->GetPostedTasks().empty());
3988
3989 // Receive signal to mark new network as default.
3990 scoped_mock_network_change_notifier_->mock_network_change_notifier()
3991 ->NotifyNetworkMadeDefault(kNewNetworkForTests);
3992
3993 stream.reset();
3994 EXPECT_TRUE(socket_data.AllReadDataConsumed());
3995 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
3996 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
3997 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
3998 }
3999
4000 // Regression test for http://crbug.com/872011.
4001 // This test verifies that migrate to the probing socket will not trigger
4002 // new packets being read synchronously and generate ACK frame while
4003 // processing the initial connectivity probe response, which may cause a
4004 // connection being closed with INTERNAL_ERROR as pending ACK frame is not
4005 // allowed when processing a new packet.
TEST_P(QuicStreamFactoryTest,MigrateToProbingSocket)4006 TEST_P(QuicStreamFactoryTest, MigrateToProbingSocket) {
4007 InitializeConnectionMigrationV2Test(
4008 {kDefaultNetworkForTests, kNewNetworkForTests});
4009 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
4010 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
4011 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
4012
4013 // Using a testing task runner so that we can control time.
4014 auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
4015 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
4016
4017 scoped_mock_network_change_notifier_->mock_network_change_notifier()
4018 ->QueueNetworkMadeDefault(kDefaultNetworkForTests);
4019
4020 int packet_number = 1;
4021 MockQuicData quic_data1(version_);
4022 quic_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging Read.
4023 if (VersionUsesHttp3(version_.transport_version)) {
4024 quic_data1.AddWrite(SYNCHRONOUS,
4025 ConstructInitialSettingsPacket(packet_number++));
4026 }
4027 quic_data1.AddWrite(
4028 SYNCHRONOUS,
4029 ConstructGetRequestPacket(packet_number++,
4030 GetNthClientInitiatedBidirectionalStreamId(0),
4031 true, true));
4032 quic_data1.AddSocketDataToFactory(socket_factory_.get());
4033
4034 // Set up the second socket data provider that is used for probing on the
4035 // alternate network.
4036 MockQuicData quic_data2(version_);
4037 // Connectivity probe to be sent on the new path.
4038 quic_data2.AddWrite(SYNCHRONOUS, client_maker_.MakeConnectivityProbingPacket(
4039 packet_number++, true));
4040 quic_data2.AddRead(ASYNC, ERR_IO_PENDING); // Pause
4041 // First connectivity probe to receive from the server, which will complete
4042 // connection migraiton on path degrading.
4043 quic_data2.AddRead(ASYNC,
4044 server_maker_.MakeConnectivityProbingPacket(1, false));
4045 // Read multiple connectivity probes synchronously.
4046 quic_data2.AddRead(SYNCHRONOUS,
4047 server_maker_.MakeConnectivityProbingPacket(2, false));
4048 quic_data2.AddRead(SYNCHRONOUS,
4049 server_maker_.MakeConnectivityProbingPacket(3, false));
4050 quic_data2.AddRead(SYNCHRONOUS,
4051 server_maker_.MakeConnectivityProbingPacket(4, false));
4052 quic_data2.AddWrite(ASYNC,
4053 client_maker_.MakeAckPacket(packet_number++, 4, 1));
4054 quic_data2.AddRead(
4055 ASYNC,
4056 ConstructOkResponsePacket(
4057 5, GetNthClientInitiatedBidirectionalStreamId(0), false, false));
4058 quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
4059 if (VersionUsesHttp3(version_.transport_version)) {
4060 quic_data2.AddWrite(
4061 SYNCHRONOUS,
4062 client_maker_.MakeAckAndDataPacket(
4063 packet_number++, false, GetQpackDecoderStreamId(), 5, 1, false,
4064 StreamCancellationQpackDecoderInstruction(0)));
4065 quic_data2.AddWrite(SYNCHRONOUS,
4066 client_maker_.MakeRstPacket(
4067 packet_number++, false,
4068 GetNthClientInitiatedBidirectionalStreamId(0),
4069 quic::QUIC_STREAM_CANCELLED));
4070 } else {
4071 quic_data2.AddWrite(SYNCHRONOUS,
4072 client_maker_.MakeAckAndRstPacket(
4073 packet_number++, false,
4074 GetNthClientInitiatedBidirectionalStreamId(0),
4075 quic::QUIC_STREAM_CANCELLED, 5, 1));
4076 }
4077 quic_data2.AddSocketDataToFactory(socket_factory_.get());
4078
4079 // Create request and QuicHttpStream.
4080 QuicStreamRequest request(factory_.get());
4081 EXPECT_EQ(
4082 ERR_IO_PENDING,
4083 request.Request(
4084 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
4085 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
4086 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
4087 failed_on_default_network_callback_, callback_.callback()));
4088 EXPECT_THAT(callback_.WaitForResult(), IsOk());
4089 std::unique_ptr<HttpStream> stream = CreateStream(&request);
4090 EXPECT_TRUE(stream.get());
4091
4092 // Cause QUIC stream to be created.
4093 HttpRequestInfo request_info;
4094 request_info.method = "GET";
4095 request_info.url = url_;
4096 request_info.traffic_annotation =
4097 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
4098 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
4099 net_log_, CompletionOnceCallback()));
4100
4101 // Ensure that session is alive and active.
4102 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
4103 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
4104 EXPECT_TRUE(HasActiveSession(host_port_pair_));
4105
4106 // Send GET request on stream.
4107 HttpResponseInfo response;
4108 HttpRequestHeaders request_headers;
4109 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
4110 callback_.callback()));
4111
4112 EXPECT_EQ(0u, QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
4113 // Cause the connection to report path degrading to the session.
4114 // Session will start to probe the alternate network.
4115 session->connection()->OnPathDegradingDetected();
4116 EXPECT_EQ(1u, QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
4117
4118 // Next connectivity probe is scheduled to be sent in 2 *
4119 // kDefaultRTTMilliSecs.
4120 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
4121 base::TimeDelta next_task_delay = task_runner->NextPendingTaskDelay();
4122 EXPECT_EQ(base::TimeDelta::FromMilliseconds(2 * kDefaultRTTMilliSecs),
4123 next_task_delay);
4124
4125 // The connection should still be alive, and not marked as going away.
4126 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
4127 EXPECT_TRUE(HasActiveSession(host_port_pair_));
4128 EXPECT_EQ(1u, session->GetNumActiveStreams());
4129 EXPECT_EQ(ERR_IO_PENDING, stream->ReadResponseHeaders(callback_.callback()));
4130
4131 // Resume quic data and a connectivity probe response will be read on the new
4132 // socket.
4133 quic_data2.Resume();
4134
4135 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
4136 EXPECT_TRUE(HasActiveSession(host_port_pair_));
4137 EXPECT_EQ(1u, session->GetNumActiveStreams());
4138
4139 // There should be three pending tasks, the nearest one will complete
4140 // migration to the new network.
4141 EXPECT_EQ(3u, task_runner->GetPendingTaskCount());
4142 next_task_delay = task_runner->NextPendingTaskDelay();
4143 EXPECT_EQ(base::TimeDelta(), next_task_delay);
4144 task_runner->FastForwardBy(next_task_delay);
4145
4146 EXPECT_EQ(1u, QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
4147
4148 // Response headers are received over the new network.
4149 EXPECT_THAT(callback_.WaitForResult(), IsOk());
4150 EXPECT_EQ(200, response.headers->response_code());
4151
4152 // Now there are two pending tasks, the nearest one was to send connectivity
4153 // probe and has been cancelled due to successful migration.
4154 EXPECT_EQ(2u, task_runner->GetPendingTaskCount());
4155 next_task_delay = task_runner->NextPendingTaskDelay();
4156 EXPECT_EQ(base::TimeDelta::FromMilliseconds(2 * kDefaultRTTMilliSecs),
4157 next_task_delay);
4158 task_runner->FastForwardBy(next_task_delay);
4159
4160 // There's one more task to mgirate back to the default network in 0.4s.
4161 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
4162 next_task_delay = task_runner->NextPendingTaskDelay();
4163 base::TimeDelta expected_delay =
4164 base::TimeDelta::FromSeconds(kMinRetryTimeForDefaultNetworkSecs) -
4165 base::TimeDelta::FromMilliseconds(2 * kDefaultRTTMilliSecs);
4166 EXPECT_EQ(expected_delay, next_task_delay);
4167
4168 // Deliver a signal that the alternate network now becomes default to session,
4169 // this will cancel mgirate back to default network timer.
4170 scoped_mock_network_change_notifier_->mock_network_change_notifier()
4171 ->NotifyNetworkMadeDefault(kNewNetworkForTests);
4172
4173 EXPECT_EQ(0u, QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
4174
4175 task_runner->FastForwardBy(next_task_delay);
4176 EXPECT_EQ(0u, task_runner->GetPendingTaskCount());
4177
4178 // Verify that the session is still alive.
4179 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
4180 EXPECT_TRUE(HasActiveSession(host_port_pair_));
4181
4182 stream.reset();
4183 EXPECT_TRUE(quic_data1.AllReadDataConsumed());
4184 EXPECT_TRUE(quic_data1.AllWriteDataConsumed());
4185 EXPECT_TRUE(quic_data2.AllReadDataConsumed());
4186 EXPECT_TRUE(quic_data2.AllWriteDataConsumed());
4187 }
4188
4189 // This test verifies that the connection migrates to the alternate network
4190 // early when path degrading is detected with an ASYNCHRONOUS write before
4191 // migration.
TEST_P(QuicStreamFactoryTest,MigrateEarlyOnPathDegradingAsync)4192 TEST_P(QuicStreamFactoryTest, MigrateEarlyOnPathDegradingAsync) {
4193 TestMigrationOnPathDegrading(/*async_write_before_migration*/ true);
4194 }
4195
4196 // This test verifies that the connection migrates to the alternate network
4197 // early when path degrading is detected with a SYNCHRONOUS write before
4198 // migration.
TEST_P(QuicStreamFactoryTest,MigrateEarlyOnPathDegradingSync)4199 TEST_P(QuicStreamFactoryTest, MigrateEarlyOnPathDegradingSync) {
4200 TestMigrationOnPathDegrading(/*async_write_before_migration*/ false);
4201 }
4202
TestMigrationOnPathDegrading(bool async_write_before)4203 void QuicStreamFactoryTestBase::TestMigrationOnPathDegrading(
4204 bool async_write_before) {
4205 InitializeConnectionMigrationV2Test(
4206 {kDefaultNetworkForTests, kNewNetworkForTests});
4207 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
4208 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
4209 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
4210
4211 // Using a testing task runner so that we can control time.
4212 auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
4213 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
4214
4215 scoped_mock_network_change_notifier_->mock_network_change_notifier()
4216 ->QueueNetworkMadeDefault(kDefaultNetworkForTests);
4217
4218 int packet_number = 1;
4219 MockQuicData quic_data1(version_);
4220 quic_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging Read.
4221 if (VersionUsesHttp3(version_.transport_version)) {
4222 quic_data1.AddWrite(SYNCHRONOUS,
4223 ConstructInitialSettingsPacket(packet_number++));
4224 }
4225 quic_data1.AddWrite(
4226 SYNCHRONOUS,
4227 ConstructGetRequestPacket(packet_number++,
4228 GetNthClientInitiatedBidirectionalStreamId(0),
4229 true, true));
4230 if (async_write_before) {
4231 quic_data1.AddWrite(ASYNC, OK);
4232 packet_number++;
4233 }
4234 quic_data1.AddSocketDataToFactory(socket_factory_.get());
4235
4236 // Set up the second socket data provider that is used after migration.
4237 // The response to the earlier request is read on the new socket.
4238 MockQuicData quic_data2(version_);
4239 // Connectivity probe to be sent on the new path.
4240 quic_data2.AddWrite(SYNCHRONOUS, client_maker_.MakeConnectivityProbingPacket(
4241 packet_number++, true));
4242 quic_data2.AddRead(ASYNC, ERR_IO_PENDING); // Pause
4243 // Connectivity probe to receive from the server.
4244 quic_data2.AddRead(ASYNC,
4245 server_maker_.MakeConnectivityProbingPacket(1, false));
4246 // Ping packet to send after migration is completed.
4247 quic_data2.AddWrite(
4248 ASYNC, client_maker_.MakeAckAndPingPacket(packet_number++, false, 1, 1));
4249 quic_data2.AddRead(
4250 ASYNC,
4251 ConstructOkResponsePacket(
4252 2, GetNthClientInitiatedBidirectionalStreamId(0), false, false));
4253 quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
4254 if (VersionUsesHttp3(version_.transport_version)) {
4255 quic_data2.AddWrite(
4256 SYNCHRONOUS,
4257 client_maker_.MakeAckAndDataPacket(
4258 packet_number++, false, GetQpackDecoderStreamId(), 2, 2, false,
4259 StreamCancellationQpackDecoderInstruction(0)));
4260 quic_data2.AddWrite(SYNCHRONOUS,
4261 client_maker_.MakeRstPacket(
4262 packet_number++, false,
4263 GetNthClientInitiatedBidirectionalStreamId(0),
4264 quic::QUIC_STREAM_CANCELLED));
4265 } else {
4266 quic_data2.AddWrite(SYNCHRONOUS,
4267 client_maker_.MakeAckAndRstPacket(
4268 packet_number++, false,
4269 GetNthClientInitiatedBidirectionalStreamId(0),
4270 quic::QUIC_STREAM_CANCELLED, 2, 2));
4271 }
4272 quic_data2.AddSocketDataToFactory(socket_factory_.get());
4273
4274 // Create request and QuicHttpStream.
4275 QuicStreamRequest request(factory_.get());
4276 EXPECT_EQ(
4277 ERR_IO_PENDING,
4278 request.Request(
4279 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
4280 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
4281 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
4282 failed_on_default_network_callback_, callback_.callback()));
4283 EXPECT_THAT(callback_.WaitForResult(), IsOk());
4284 std::unique_ptr<HttpStream> stream = CreateStream(&request);
4285 EXPECT_TRUE(stream.get());
4286
4287 // Cause QUIC stream to be created.
4288 HttpRequestInfo request_info;
4289 request_info.method = "GET";
4290 request_info.url = url_;
4291 request_info.traffic_annotation =
4292 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
4293 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
4294 net_log_, CompletionOnceCallback()));
4295
4296 // Ensure that session is alive and active.
4297 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
4298 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
4299 EXPECT_TRUE(HasActiveSession(host_port_pair_));
4300
4301 // Send GET request on stream.
4302 HttpResponseInfo response;
4303 HttpRequestHeaders request_headers;
4304 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
4305 callback_.callback()));
4306
4307 if (async_write_before)
4308 session->SendPing();
4309
4310 EXPECT_EQ(0u, QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
4311 // Cause the connection to report path degrading to the session.
4312 // Session will start to probe the alternate network.
4313 session->connection()->OnPathDegradingDetected();
4314 EXPECT_EQ(1u, QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
4315
4316 // Next connectivity probe is scheduled to be sent in 2 *
4317 // kDefaultRTTMilliSecs.
4318 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
4319 base::TimeDelta next_task_delay = task_runner->NextPendingTaskDelay();
4320 EXPECT_EQ(base::TimeDelta::FromMilliseconds(2 * kDefaultRTTMilliSecs),
4321 next_task_delay);
4322
4323 // The connection should still be alive, and not marked as going away.
4324 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
4325 EXPECT_TRUE(HasActiveSession(host_port_pair_));
4326 EXPECT_EQ(1u, session->GetNumActiveStreams());
4327 EXPECT_EQ(ERR_IO_PENDING, stream->ReadResponseHeaders(callback_.callback()));
4328
4329 // Resume quic data and a connectivity probe response will be read on the new
4330 // socket.
4331 quic_data2.Resume();
4332
4333 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
4334 EXPECT_TRUE(HasActiveSession(host_port_pair_));
4335 EXPECT_EQ(1u, session->GetNumActiveStreams());
4336
4337 // There should be three pending tasks, the nearest one will complete
4338 // migration to the new network.
4339 EXPECT_EQ(3u, task_runner->GetPendingTaskCount());
4340 next_task_delay = task_runner->NextPendingTaskDelay();
4341 EXPECT_EQ(base::TimeDelta(), next_task_delay);
4342 task_runner->FastForwardBy(next_task_delay);
4343
4344 EXPECT_EQ(1u, QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
4345
4346 // Response headers are received over the new network.
4347 EXPECT_THAT(callback_.WaitForResult(), IsOk());
4348 EXPECT_EQ(200, response.headers->response_code());
4349
4350 EXPECT_EQ(1u, QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
4351
4352 // Now there are two pending tasks, the nearest one was to send connectivity
4353 // probe and has been cancelled due to successful migration.
4354 EXPECT_EQ(2u, task_runner->GetPendingTaskCount());
4355 next_task_delay = task_runner->NextPendingTaskDelay();
4356 EXPECT_EQ(base::TimeDelta::FromMilliseconds(2 * kDefaultRTTMilliSecs),
4357 next_task_delay);
4358 task_runner->FastForwardBy(next_task_delay);
4359
4360 // There's one more task to mgirate back to the default network in 0.4s.
4361 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
4362 next_task_delay = task_runner->NextPendingTaskDelay();
4363 base::TimeDelta expected_delay =
4364 base::TimeDelta::FromSeconds(kMinRetryTimeForDefaultNetworkSecs) -
4365 base::TimeDelta::FromMilliseconds(2 * kDefaultRTTMilliSecs);
4366 EXPECT_EQ(expected_delay, next_task_delay);
4367
4368 // Deliver a signal that the alternate network now becomes default to session,
4369 // this will cancel mgirate back to default network timer.
4370 scoped_mock_network_change_notifier_->mock_network_change_notifier()
4371 ->NotifyNetworkMadeDefault(kNewNetworkForTests);
4372
4373 EXPECT_EQ(0u, QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
4374
4375 task_runner->FastForwardBy(next_task_delay);
4376 EXPECT_EQ(0u, task_runner->GetPendingTaskCount());
4377
4378 // Verify that the session is still alive.
4379 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
4380 EXPECT_TRUE(HasActiveSession(host_port_pair_));
4381
4382 stream.reset();
4383 EXPECT_TRUE(quic_data1.AllReadDataConsumed());
4384 EXPECT_TRUE(quic_data1.AllWriteDataConsumed());
4385 EXPECT_TRUE(quic_data2.AllReadDataConsumed());
4386 EXPECT_TRUE(quic_data2.AllWriteDataConsumed());
4387 }
4388
4389 // Verifies that port migration can be attempted and succeed when path degrading
4390 // is detected, even if NetworkHandle is not supported.
TEST_P(QuicStreamFactoryTest,MigratePortOnPathDegrading_WithoutNetworkHandle)4391 TEST_P(QuicStreamFactoryTest, MigratePortOnPathDegrading_WithoutNetworkHandle) {
4392 quic_params_->allow_port_migration = true;
4393 socket_factory_.reset(new TestMigrationSocketFactory);
4394 Initialize();
4395
4396 TestSimplePortMigrationOnPathDegrading();
4397 }
4398
4399 // Verifies that if a stateless reset is received on port migration probing
4400 // path, the session is still alive and probing is considered failed.
TEST_P(QuicStreamFactoryTest,PortMigrationProbingReceivedStatelessReset)4401 TEST_P(QuicStreamFactoryTest, PortMigrationProbingReceivedStatelessReset) {
4402 if (!VersionHasIetfInvariantHeader(version_.transport_version)) {
4403 // STATELESS_RESET is only supported after QUIC V46.
4404 return;
4405 }
4406 quic_params_->allow_port_migration = true;
4407 socket_factory_.reset(new TestMigrationSocketFactory);
4408 Initialize();
4409 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
4410 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
4411 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
4412
4413 // Using a testing task runner so that we can control time.
4414 auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
4415 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
4416
4417 int packet_number = 1;
4418 MockQuicData quic_data1(version_);
4419 quic_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // hanging read
4420 if (VersionUsesHttp3(version_.transport_version)) {
4421 quic_data1.AddWrite(SYNCHRONOUS,
4422 ConstructInitialSettingsPacket(packet_number++));
4423 }
4424 quic_data1.AddWrite(
4425 SYNCHRONOUS,
4426 ConstructGetRequestPacket(packet_number++,
4427 GetNthClientInitiatedBidirectionalStreamId(0),
4428 true, true));
4429 if (VersionUsesHttp3(version_.transport_version)) {
4430 quic_data1.AddWrite(
4431 SYNCHRONOUS, client_maker_.MakeDataPacket(
4432 packet_number + 1, GetQpackDecoderStreamId(), true,
4433 false, StreamCancellationQpackDecoderInstruction(0)));
4434 quic_data1.AddWrite(SYNCHRONOUS,
4435 client_maker_.MakeRstPacket(
4436 packet_number + 2, false,
4437 GetNthClientInitiatedBidirectionalStreamId(0),
4438 quic::QUIC_STREAM_CANCELLED));
4439 } else {
4440 quic_data1.AddWrite(SYNCHRONOUS,
4441 client_maker_.MakeRstPacket(
4442 packet_number + 1, false,
4443 GetNthClientInitiatedBidirectionalStreamId(0),
4444 quic::QUIC_STREAM_CANCELLED));
4445 }
4446 quic_data1.AddSocketDataToFactory(socket_factory_.get());
4447
4448 // Set up the second socket data provider that is used after migration.
4449 // The response to the earlier request is read on the new socket.
4450 MockQuicData quic_data2(version_);
4451 // Connectivity probe to be sent on the new path.
4452 quic_data2.AddWrite(SYNCHRONOUS, client_maker_.MakeConnectivityProbingPacket(
4453 packet_number, true));
4454 quic_data2.AddRead(ASYNC, ERR_IO_PENDING); // Pause
4455 // Stateless reset to receive from the server.
4456 quic_data2.AddRead(ASYNC, server_maker_.MakeStatelessResetPacket());
4457 quic_data2.AddSocketDataToFactory(socket_factory_.get());
4458
4459 // Create request and QuicHttpStream.
4460 QuicStreamRequest request(factory_.get());
4461 EXPECT_EQ(
4462 ERR_IO_PENDING,
4463 request.Request(
4464 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
4465 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
4466 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
4467 failed_on_default_network_callback_, callback_.callback()));
4468 EXPECT_THAT(callback_.WaitForResult(), IsOk());
4469 std::unique_ptr<HttpStream> stream = CreateStream(&request);
4470 EXPECT_TRUE(stream.get());
4471
4472 // Cause QUIC stream to be created.
4473 HttpRequestInfo request_info;
4474 request_info.method = "GET";
4475 request_info.url = url_;
4476 request_info.traffic_annotation =
4477 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
4478 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
4479 net_log_, CompletionOnceCallback()));
4480
4481 // Ensure that session is alive and active.
4482 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
4483 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
4484 EXPECT_TRUE(HasActiveSession(host_port_pair_));
4485
4486 // Send GET request on stream.
4487 HttpResponseInfo response;
4488 HttpRequestHeaders request_headers;
4489 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
4490 callback_.callback()));
4491
4492 EXPECT_EQ(0u, QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
4493
4494 // Cause the connection to report path degrading to the session.
4495 // Session will start to probe a different port.
4496 session->connection()->OnPathDegradingDetected();
4497
4498 EXPECT_EQ(1u, QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
4499
4500 // Next connectivity probe is scheduled to be sent in 2 *
4501 // kDefaultRTTMilliSecs.
4502 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
4503 base::TimeDelta next_task_delay = task_runner->NextPendingTaskDelay();
4504 EXPECT_EQ(base::TimeDelta::FromMilliseconds(2 * kDefaultRTTMilliSecs),
4505 next_task_delay);
4506
4507 // The connection should still be alive, and not marked as going away.
4508 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
4509 EXPECT_TRUE(HasActiveSession(host_port_pair_));
4510 EXPECT_EQ(1u, session->GetNumActiveStreams());
4511 EXPECT_EQ(ERR_IO_PENDING, stream->ReadResponseHeaders(callback_.callback()));
4512
4513 // Resume quic data and a STATELESS_RESET is read from the probing path.
4514 quic_data2.Resume();
4515
4516 EXPECT_EQ(1u, QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
4517
4518 // Verify that the session is still active, and the request stream is active.
4519 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
4520 EXPECT_TRUE(HasActiveSession(host_port_pair_));
4521 EXPECT_EQ(1u, session->GetNumActiveStreams());
4522 EXPECT_FALSE(
4523 QuicChromiumClientSessionPeer::DoesSessionAllowPortMigration(session));
4524
4525 // The task to resend connectivity probe is cancelled due to probe failure.
4526 task_runner->FastForwardBy(next_task_delay);
4527 EXPECT_EQ(0u, task_runner->GetPendingTaskCount());
4528
4529 stream.reset();
4530 EXPECT_TRUE(quic_data1.AllReadDataConsumed());
4531 EXPECT_TRUE(quic_data1.AllWriteDataConsumed());
4532 EXPECT_TRUE(quic_data2.AllReadDataConsumed());
4533 EXPECT_TRUE(quic_data2.AllWriteDataConsumed());
4534 }
4535
4536 // Verifies that port migration can be attempted on the default network and
4537 // succeed when path degrading is detected. NetworkHandle is supported.
TEST_P(QuicStreamFactoryTest,MigratePortOnPathDegrading_WithNetworkHandle)4538 TEST_P(QuicStreamFactoryTest, MigratePortOnPathDegrading_WithNetworkHandle) {
4539 scoped_mock_network_change_notifier_.reset(
4540 new ScopedMockNetworkChangeNotifier());
4541 MockNetworkChangeNotifier* mock_ncn =
4542 scoped_mock_network_change_notifier_->mock_network_change_notifier();
4543 mock_ncn->ForceNetworkHandlesSupported();
4544 mock_ncn->SetConnectedNetworksList({kDefaultNetworkForTests});
4545 quic_params_->allow_port_migration = true;
4546 socket_factory_.reset(new TestMigrationSocketFactory);
4547 Initialize();
4548
4549 scoped_mock_network_change_notifier_->mock_network_change_notifier()
4550 ->NotifyNetworkMadeDefault(kDefaultNetworkForTests);
4551
4552 TestSimplePortMigrationOnPathDegrading();
4553 }
4554
4555 // Verifies that port migration can be attempted on the default network and
4556 // succeed when path degrading is detected.
4557 // NetworkHandle is supported. Migration on network change is also enabled.
4558 // No additional network migration is triggered post port migration.
TEST_P(QuicStreamFactoryTest,MigratePortOnPathDegrading_WithMigration)4559 TEST_P(QuicStreamFactoryTest, MigratePortOnPathDegrading_WithMigration) {
4560 scoped_mock_network_change_notifier_.reset(
4561 new ScopedMockNetworkChangeNotifier());
4562 MockNetworkChangeNotifier* mock_ncn =
4563 scoped_mock_network_change_notifier_->mock_network_change_notifier();
4564 mock_ncn->ForceNetworkHandlesSupported();
4565 mock_ncn->SetConnectedNetworksList({kDefaultNetworkForTests});
4566 // Enable migration on network change.
4567 quic_params_->migrate_sessions_on_network_change_v2 = true;
4568 quic_params_->allow_port_migration = true;
4569 socket_factory_.reset(new TestMigrationSocketFactory);
4570 Initialize();
4571
4572 scoped_mock_network_change_notifier_->mock_network_change_notifier()
4573 ->NotifyNetworkMadeDefault(kDefaultNetworkForTests);
4574
4575 TestSimplePortMigrationOnPathDegrading();
4576 }
4577
TestSimplePortMigrationOnPathDegrading()4578 void QuicStreamFactoryTestBase::TestSimplePortMigrationOnPathDegrading() {
4579 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
4580 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
4581 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
4582
4583 // Using a testing task runner so that we can control time.
4584 auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
4585 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
4586
4587 int packet_number = 1;
4588 MockQuicData quic_data1(version_);
4589 quic_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging Read.
4590 if (VersionUsesHttp3(version_.transport_version)) {
4591 quic_data1.AddWrite(SYNCHRONOUS,
4592 ConstructInitialSettingsPacket(packet_number++));
4593 }
4594 quic_data1.AddWrite(
4595 SYNCHRONOUS,
4596 ConstructGetRequestPacket(packet_number++,
4597 GetNthClientInitiatedBidirectionalStreamId(0),
4598 true, true));
4599 quic_data1.AddSocketDataToFactory(socket_factory_.get());
4600
4601 // Set up the second socket data provider that is used after migration.
4602 // The response to the earlier request is read on the new socket.
4603 MockQuicData quic_data2(version_);
4604 // Connectivity probe to be sent on the new path.
4605 quic_data2.AddWrite(SYNCHRONOUS, client_maker_.MakeConnectivityProbingPacket(
4606 packet_number++, true));
4607 quic_data2.AddRead(ASYNC, ERR_IO_PENDING); // Pause
4608 // Connectivity probe to receive from the server.
4609 quic_data2.AddRead(ASYNC,
4610 server_maker_.MakeConnectivityProbingPacket(1, false));
4611 // Ping packet to send after migration is completed.
4612 quic_data2.AddWrite(
4613 ASYNC, client_maker_.MakeAckAndPingPacket(packet_number++, false, 1, 1));
4614 quic_data2.AddRead(
4615 ASYNC,
4616 ConstructOkResponsePacket(
4617 2, GetNthClientInitiatedBidirectionalStreamId(0), false, false));
4618 quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
4619 if (VersionUsesHttp3(version_.transport_version)) {
4620 quic_data2.AddWrite(
4621 SYNCHRONOUS,
4622 client_maker_.MakeAckAndDataPacket(
4623 packet_number++, false, GetQpackDecoderStreamId(), 2, 2, false,
4624 StreamCancellationQpackDecoderInstruction(0)));
4625 quic_data2.AddWrite(SYNCHRONOUS,
4626 client_maker_.MakeRstPacket(
4627 packet_number++, false,
4628 GetNthClientInitiatedBidirectionalStreamId(0),
4629 quic::QUIC_STREAM_CANCELLED));
4630 } else {
4631 quic_data2.AddWrite(SYNCHRONOUS,
4632 client_maker_.MakeAckAndRstPacket(
4633 packet_number++, false,
4634 GetNthClientInitiatedBidirectionalStreamId(0),
4635 quic::QUIC_STREAM_CANCELLED, 2, 2));
4636 }
4637 quic_data2.AddSocketDataToFactory(socket_factory_.get());
4638
4639 // Create request and QuicHttpStream.
4640 QuicStreamRequest request(factory_.get());
4641 EXPECT_EQ(
4642 ERR_IO_PENDING,
4643 request.Request(
4644 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
4645 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
4646 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
4647 failed_on_default_network_callback_, callback_.callback()));
4648 EXPECT_THAT(callback_.WaitForResult(), IsOk());
4649 std::unique_ptr<HttpStream> stream = CreateStream(&request);
4650 EXPECT_TRUE(stream.get());
4651
4652 // Cause QUIC stream to be created.
4653 HttpRequestInfo request_info;
4654 request_info.method = "GET";
4655 request_info.url = url_;
4656 request_info.traffic_annotation =
4657 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
4658 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
4659 net_log_, CompletionOnceCallback()));
4660
4661 // Ensure that session is alive and active.
4662 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
4663 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
4664 EXPECT_TRUE(HasActiveSession(host_port_pair_));
4665
4666 // Send GET request on stream.
4667 HttpResponseInfo response;
4668 HttpRequestHeaders request_headers;
4669 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
4670 callback_.callback()));
4671
4672 EXPECT_EQ(0u, QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
4673
4674 // Cause the connection to report path degrading to the session.
4675 // Session will start to probe a different port.
4676 session->connection()->OnPathDegradingDetected();
4677
4678 EXPECT_EQ(1u, QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
4679
4680 // Next connectivity probe is scheduled to be sent in 2 *
4681 // kDefaultRTTMilliSecs.
4682 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
4683 base::TimeDelta next_task_delay = task_runner->NextPendingTaskDelay();
4684 EXPECT_EQ(base::TimeDelta::FromMilliseconds(2 * kDefaultRTTMilliSecs),
4685 next_task_delay);
4686
4687 // The connection should still be alive, and not marked as going away.
4688 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
4689 EXPECT_TRUE(HasActiveSession(host_port_pair_));
4690 EXPECT_EQ(1u, session->GetNumActiveStreams());
4691 EXPECT_EQ(ERR_IO_PENDING, stream->ReadResponseHeaders(callback_.callback()));
4692
4693 // Resume quic data and a connectivity probe response will be read on the new
4694 // socket.
4695 quic_data2.Resume();
4696
4697 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
4698 EXPECT_TRUE(HasActiveSession(host_port_pair_));
4699 EXPECT_EQ(1u, session->GetNumActiveStreams());
4700 // Successful port migration causes the path no longer degrading on the same
4701 // network.
4702 EXPECT_EQ(0u, QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
4703
4704 // There should be pending tasks, the nearest one will complete
4705 // migration to the new port.
4706 EXPECT_EQ(2u, task_runner->GetPendingTaskCount());
4707 next_task_delay = task_runner->NextPendingTaskDelay();
4708 EXPECT_EQ(base::TimeDelta(), next_task_delay);
4709 task_runner->FastForwardBy(next_task_delay);
4710
4711 // Response headers are received over the new port.
4712 EXPECT_THAT(callback_.WaitForResult(), IsOk());
4713 EXPECT_EQ(200, response.headers->response_code());
4714
4715 EXPECT_EQ(0u, QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
4716
4717 // Now there is one pending task to send connectivity probe and has been
4718 // cancelled due to successful migration.
4719 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
4720 next_task_delay = task_runner->NextPendingTaskDelay();
4721 EXPECT_EQ(base::TimeDelta::FromMilliseconds(2 * kDefaultRTTMilliSecs),
4722 next_task_delay);
4723 task_runner->FastForwardBy(next_task_delay);
4724
4725 EXPECT_EQ(0u, task_runner->GetPendingTaskCount());
4726
4727 // Verify that the session is still alive.
4728 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
4729 EXPECT_TRUE(HasActiveSession(host_port_pair_));
4730
4731 stream.reset();
4732 EXPECT_TRUE(quic_data1.AllReadDataConsumed());
4733 EXPECT_TRUE(quic_data1.AllWriteDataConsumed());
4734 EXPECT_TRUE(quic_data2.AllReadDataConsumed());
4735 EXPECT_TRUE(quic_data2.AllWriteDataConsumed());
4736 }
4737
4738 // Regression test for https://crbug.com/1014092.
TEST_P(QuicStreamFactoryTest,MultiplePortMigrationsExceedsMaxLimit)4739 TEST_P(QuicStreamFactoryTest, MultiplePortMigrationsExceedsMaxLimit) {
4740 quic_params_->allow_port_migration = true;
4741 socket_factory_.reset(new TestMigrationSocketFactory);
4742 Initialize();
4743
4744 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
4745 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
4746 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
4747
4748 // Using a testing task runner so that we can control time.
4749 auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
4750 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
4751
4752 int packet_number = 1;
4753 MockQuicData quic_data1(version_);
4754 quic_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging Read.
4755 if (VersionUsesHttp3(version_.transport_version)) {
4756 quic_data1.AddWrite(SYNCHRONOUS,
4757 ConstructInitialSettingsPacket(packet_number++));
4758 }
4759 quic_data1.AddWrite(
4760 SYNCHRONOUS,
4761 ConstructGetRequestPacket(packet_number++,
4762 GetNthClientInitiatedBidirectionalStreamId(0),
4763 true, true));
4764 quic_data1.AddSocketDataToFactory(socket_factory_.get());
4765
4766 // Create request and QuicHttpStream.
4767 QuicStreamRequest request(factory_.get());
4768 EXPECT_EQ(
4769 ERR_IO_PENDING,
4770 request.Request(
4771 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
4772 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
4773 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
4774 failed_on_default_network_callback_, callback_.callback()));
4775 EXPECT_THAT(callback_.WaitForResult(), IsOk());
4776 std::unique_ptr<HttpStream> stream = CreateStream(&request);
4777 EXPECT_TRUE(stream.get());
4778
4779 // Cause QUIC stream to be created.
4780 HttpRequestInfo request_info;
4781 request_info.method = "GET";
4782 request_info.url = url_;
4783 request_info.traffic_annotation =
4784 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
4785 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
4786 net_log_, CompletionOnceCallback()));
4787
4788 // Ensure that session is alive and active.
4789 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
4790 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
4791 EXPECT_TRUE(HasActiveSession(host_port_pair_));
4792
4793 // Send GET request on stream.
4794 HttpResponseInfo response;
4795 HttpRequestHeaders request_headers;
4796 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
4797 callback_.callback()));
4798
4799 int server_packet_num = 1;
4800 base::TimeDelta next_task_delay;
4801 // Perform 4 round of successful migration, and the 5th round will
4802 // cancel after successful probing due to hitting the limit.
4803 for (int i = 0; i <= 4; i++) {
4804 // Set up a different socket data provider that is used for
4805 // probing and migration.
4806 MockQuicData quic_data2(version_);
4807 // Connectivity probe to be sent on the new path.
4808 quic_data2.AddWrite(SYNCHRONOUS,
4809 client_maker_.MakeConnectivityProbingPacket(
4810 packet_number, packet_number == 2));
4811 packet_number++;
4812 quic_data2.AddRead(ASYNC, ERR_IO_PENDING); // Pause
4813 // Connectivity probe to receive from the server.
4814 quic_data2.AddRead(ASYNC, server_maker_.MakeConnectivityProbingPacket(
4815 server_packet_num++, false));
4816 // Ping packet to send after migration is completed.
4817 if (i == 0) {
4818 // First ack and PING are bundled, and version flag is set.
4819 quic_data2.AddWrite(SYNCHRONOUS, client_maker_.MakeAckAndPingPacket(
4820 packet_number++, false, 1, 1));
4821 } else if (i != 4) {
4822 // ACK and PING post migration after successful probing.
4823 quic_data2.AddWrite(
4824 SYNCHRONOUS,
4825 client_maker_.MakeAckPacket(packet_number++, 1 + 2 * i, 1 + 2 * i));
4826 quic_data2.AddWrite(SYNCHRONOUS,
4827 client_maker_.MakePingPacket(packet_number++, false));
4828 }
4829 if (i == 4) {
4830 // Add one more synchronous read on the last probing reader. The
4831 // reader should be deleted on the read before this one.
4832 // The test will verify this read is not consumed.
4833 quic_data2.AddRead(SYNCHRONOUS,
4834 server_maker_.MakeConnectivityProbingPacket(
4835 server_packet_num++, false));
4836 } else {
4837 quic_data2.AddRead(ASYNC, server_maker_.MakeConnectivityProbingPacket(
4838 server_packet_num++, false));
4839 }
4840 if (i == 3) {
4841 // On the last allowed port migration, read one more packet so
4842 // that ACK is sent. The next round of migration (which hists the limit)
4843 // will not send any proactive ACK when reading the successful probing
4844 // response.
4845 quic_data2.AddRead(ASYNC, server_maker_.MakeConnectivityProbingPacket(
4846 server_packet_num++, false));
4847 quic_data2.AddWrite(SYNCHRONOUS,
4848 client_maker_.MakeAckPacket(packet_number++, 9, 9));
4849 }
4850 quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // EOF.
4851 quic_data2.AddSocketDataToFactory(socket_factory_.get());
4852
4853 EXPECT_EQ(0u,
4854 QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
4855
4856 // Cause the connection to report path degrading to the session.
4857 // Session will start to probe a different port.
4858 session->connection()->OnPathDegradingDetected();
4859
4860 EXPECT_EQ(1u,
4861 QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
4862
4863 // Next connectivity probe is scheduled to be sent in 2 *
4864 // kDefaultRTTMilliSecs.
4865 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
4866 next_task_delay = task_runner->NextPendingTaskDelay();
4867 EXPECT_EQ(base::TimeDelta::FromMilliseconds(2 * kDefaultRTTMilliSecs),
4868 next_task_delay);
4869
4870 // The connection should still be alive, and not marked as going away.
4871 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
4872 EXPECT_TRUE(HasActiveSession(host_port_pair_));
4873 EXPECT_EQ(1u, session->GetNumActiveStreams());
4874
4875 // Resume quic data and a connectivity probe response will be read on the
4876 // new socket.
4877 quic_data2.Resume();
4878 base::RunLoop().RunUntilIdle();
4879
4880 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
4881 EXPECT_TRUE(HasActiveSession(host_port_pair_));
4882 EXPECT_EQ(1u, session->GetNumActiveStreams());
4883
4884 if (i < 4) {
4885 // There should be pending tasks, the nearest one will complete
4886 // migration to the new port.
4887 EXPECT_EQ(2u, task_runner->GetPendingTaskCount());
4888 next_task_delay = task_runner->NextPendingTaskDelay();
4889 EXPECT_EQ(base::TimeDelta(), next_task_delay);
4890 } else {
4891 // Last attempt to migrate will abort due to hitting the limit of max
4892 // number of allowed migrations.
4893 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
4894 next_task_delay = task_runner->NextPendingTaskDelay();
4895 EXPECT_NE(base::TimeDelta(), next_task_delay);
4896 }
4897 task_runner->FastForwardBy(next_task_delay);
4898 EXPECT_TRUE(quic_data2.AllWriteDataConsumed());
4899 // The last round of migration will abort upon reading the probing response.
4900 // Future reads in the same socket is ignored.
4901 EXPECT_EQ(i != 4, quic_data2.AllReadDataConsumed());
4902 }
4903
4904 EXPECT_EQ(0u, task_runner->GetPendingTaskCount());
4905
4906 // Verify that the session is still alive.
4907 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
4908 EXPECT_TRUE(HasActiveSession(host_port_pair_));
4909
4910 stream.reset();
4911 EXPECT_TRUE(quic_data1.AllReadDataConsumed());
4912 EXPECT_TRUE(quic_data1.AllWriteDataConsumed());
4913 }
4914
4915 // This test verifies that the session marks itself GOAWAY on path degrading
4916 // and it does not receive any new request
TEST_P(QuicStreamFactoryTest,GoawayOnPathDegrading)4917 TEST_P(QuicStreamFactoryTest, GoawayOnPathDegrading) {
4918 quic_params_->go_away_on_path_degrading = true;
4919 Initialize();
4920 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
4921 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
4922 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
4923
4924 MockQuicData quic_data1(version_);
4925 int packet_num = 1;
4926 if (VersionUsesHttp3(version_.transport_version)) {
4927 quic_data1.AddWrite(SYNCHRONOUS,
4928 ConstructInitialSettingsPacket(packet_num++));
4929 }
4930 quic_data1.AddWrite(
4931 SYNCHRONOUS,
4932 ConstructGetRequestPacket(packet_num,
4933 GetNthClientInitiatedBidirectionalStreamId(0),
4934 true, true));
4935 quic_data1.AddRead(ASYNC, ERR_IO_PENDING); // Pause
4936 quic_data1.AddRead(
4937 ASYNC,
4938 ConstructOkResponsePacket(
4939 1, GetNthClientInitiatedBidirectionalStreamId(0), false, true));
4940 quic_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read.
4941 quic_data1.AddSocketDataToFactory(socket_factory_.get());
4942
4943 client_maker_.Reset();
4944 MockQuicData quic_data2(version_);
4945 quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read.
4946 if (VersionUsesHttp3(version_.transport_version))
4947 quic_data2.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
4948 quic_data2.AddSocketDataToFactory(socket_factory_.get());
4949
4950 // Creat request and QuicHttpStream.
4951 QuicStreamRequest request(factory_.get());
4952 EXPECT_EQ(
4953 ERR_IO_PENDING,
4954 request.Request(
4955 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
4956 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
4957 /*cerf_verify_flags=*/0, url_, net_log_, &net_error_details_,
4958 failed_on_default_network_callback_, callback_.callback()));
4959 EXPECT_THAT(callback_.WaitForResult(), IsOk());
4960 std::unique_ptr<HttpStream> stream = CreateStream(&request);
4961 EXPECT_TRUE(stream.get());
4962
4963 // Cause QUIC stream to be created.
4964 HttpRequestInfo request_info;
4965 request_info.method = "GET";
4966 request_info.url = url_;
4967 request_info.traffic_annotation =
4968 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
4969 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
4970 net_log_, CompletionOnceCallback()));
4971
4972 // Ensure that session is alive and active.
4973 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
4974 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
4975 EXPECT_TRUE(HasActiveSession(host_port_pair_));
4976
4977 // Send GET request on stream.
4978 HttpResponseInfo response;
4979 HttpRequestHeaders request_headers;
4980 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
4981 callback_.callback()));
4982
4983 EXPECT_EQ(0u, QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
4984
4985 // Trigger the connection to report path degrading to the session.
4986 // Session will mark itself GOAWAY.
4987 session->connection()->OnPathDegradingDetected();
4988
4989 /// Path degrading detection on go_away_on_path_degrading detection is
4990 // disabled.
4991 EXPECT_EQ(0u, QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
4992
4993 // The connection should still be alive, but marked as going away.
4994 EXPECT_FALSE(HasActiveSession(host_port_pair_));
4995 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
4996 EXPECT_EQ(1u, session->GetNumActiveStreams());
4997
4998 // Second request should be sent on a new connection.
4999 QuicStreamRequest request2(factory_.get());
5000 EXPECT_EQ(
5001 ERR_IO_PENDING,
5002 request2.Request(
5003 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
5004 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
5005 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
5006 failed_on_default_network_callback_, callback_.callback()));
5007 EXPECT_THAT(callback_.WaitForResult(), IsOk());
5008 std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
5009 EXPECT_TRUE(stream2.get());
5010
5011 // Resume the data, verify old request can read response on the old session
5012 // successfully.
5013 quic_data1.Resume();
5014 EXPECT_EQ(OK, stream->ReadResponseHeaders(callback_.callback()));
5015 EXPECT_EQ(200, response.headers->response_code());
5016 EXPECT_EQ(0U, session->GetNumActiveStreams());
5017
5018 // Check an active session exists for the destination.
5019 EXPECT_TRUE(HasActiveSession(host_port_pair_));
5020 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
5021 QuicChromiumClientSession* session2 = GetActiveSession(host_port_pair_);
5022 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session2));
5023 EXPECT_NE(session, session2);
5024
5025 stream.reset();
5026 stream2.reset();
5027 EXPECT_TRUE(quic_data1.AllReadDataConsumed());
5028 EXPECT_TRUE(quic_data1.AllWriteDataConsumed());
5029 EXPECT_TRUE(quic_data2.AllReadDataConsumed());
5030 EXPECT_TRUE(quic_data2.AllWriteDataConsumed());
5031 }
5032
5033 // This test verifies that the connection will not migrate to a bad socket
5034 // when path degrading is detected.
TEST_P(QuicStreamFactoryTest,DoNotMigrateToBadSocketOnPathDegrading)5035 TEST_P(QuicStreamFactoryTest, DoNotMigrateToBadSocketOnPathDegrading) {
5036 InitializeConnectionMigrationV2Test(
5037 {kDefaultNetworkForTests, kNewNetworkForTests});
5038 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
5039 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
5040 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
5041
5042 // Using a testing task runner so that we can control time.
5043 auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
5044 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
5045
5046 scoped_mock_network_change_notifier_->mock_network_change_notifier()
5047 ->QueueNetworkMadeDefault(kDefaultNetworkForTests);
5048
5049 MockQuicData quic_data(version_);
5050 int packet_num = 1;
5051 if (VersionUsesHttp3(version_.transport_version)) {
5052 quic_data.AddWrite(SYNCHRONOUS,
5053 ConstructInitialSettingsPacket(packet_num++));
5054 }
5055 quic_data.AddWrite(
5056 SYNCHRONOUS,
5057 ConstructGetRequestPacket(packet_num++,
5058 GetNthClientInitiatedBidirectionalStreamId(0),
5059 true, true));
5060 quic_data.AddRead(ASYNC, ERR_IO_PENDING); // Pause
5061 quic_data.AddRead(ASYNC, ConstructOkResponsePacket(
5062 1, GetNthClientInitiatedBidirectionalStreamId(0),
5063 false, false));
5064 quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
5065 if (VersionUsesHttp3(version_.transport_version)) {
5066 quic_data.AddWrite(
5067 SYNCHRONOUS, client_maker_.MakeAckAndDataPacket(
5068 packet_num++, false, GetQpackDecoderStreamId(), 1, 1,
5069 false, StreamCancellationQpackDecoderInstruction(0)));
5070 quic_data.AddWrite(
5071 SYNCHRONOUS,
5072 client_maker_.MakeRstPacket(
5073 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
5074 quic::QUIC_STREAM_CANCELLED));
5075 } else {
5076 quic_data.AddWrite(
5077 SYNCHRONOUS,
5078 client_maker_.MakeAckAndRstPacket(
5079 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
5080 quic::QUIC_STREAM_CANCELLED, 1, 1));
5081 }
5082 quic_data.AddSocketDataToFactory(socket_factory_.get());
5083
5084 // Set up second socket that will immediately return disconnected.
5085 // The stream factory will abort probe the alternate network.
5086 MockConnect bad_connect = MockConnect(SYNCHRONOUS, ERR_INTERNET_DISCONNECTED);
5087 SequencedSocketData socket_data(bad_connect, base::span<MockRead>(),
5088 base::span<MockWrite>());
5089 socket_factory_->AddSocketDataProvider(&socket_data);
5090
5091 // Create request and QuicHttpStream.
5092 QuicStreamRequest request(factory_.get());
5093 EXPECT_EQ(
5094 ERR_IO_PENDING,
5095 request.Request(
5096 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
5097 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
5098 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
5099 failed_on_default_network_callback_, callback_.callback()));
5100 EXPECT_THAT(callback_.WaitForResult(), IsOk());
5101 std::unique_ptr<HttpStream> stream = CreateStream(&request);
5102 EXPECT_TRUE(stream.get());
5103
5104 // Cause QUIC stream to be created.
5105 HttpRequestInfo request_info;
5106 request_info.method = "GET";
5107 request_info.url = url_;
5108 request_info.traffic_annotation =
5109 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
5110 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
5111 net_log_, CompletionOnceCallback()));
5112
5113 // Ensure that session is alive and active.
5114 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
5115 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
5116 EXPECT_TRUE(HasActiveSession(host_port_pair_));
5117
5118 // Send GET request on stream.
5119 HttpResponseInfo response;
5120 HttpRequestHeaders request_headers;
5121 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
5122 callback_.callback()));
5123
5124 EXPECT_EQ(0u, QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
5125 // Cause the connection to report path degrading to the session.
5126 // Session will start to probe the alternate network.
5127 session->connection()->OnPathDegradingDetected();
5128 EXPECT_EQ(1u, QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
5129
5130 // The connection should still be alive, and not marked as going away.
5131 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
5132 EXPECT_TRUE(HasActiveSession(host_port_pair_));
5133 EXPECT_EQ(1u, session->GetNumActiveStreams());
5134 EXPECT_EQ(ERR_IO_PENDING, stream->ReadResponseHeaders(callback_.callback()));
5135
5136 // Resume the data, and response header is received over the original network.
5137 quic_data.Resume();
5138 EXPECT_THAT(callback_.WaitForResult(), IsOk());
5139 EXPECT_EQ(200, response.headers->response_code());
5140
5141 // Verify there is no pending task as probing alternate network is halted.
5142 EXPECT_EQ(0u, task_runner->GetPendingTaskCount());
5143
5144 // Verify that the session is still alive.
5145 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
5146 EXPECT_TRUE(HasActiveSession(host_port_pair_));
5147
5148 stream.reset();
5149 EXPECT_TRUE(quic_data.AllReadDataConsumed());
5150 EXPECT_TRUE(quic_data.AllWriteDataConsumed());
5151 }
5152
5153 // Regression test for http://crbug.com/847569.
5154 // This test verifies that the connection migrates to the alternate network
5155 // early when there is no active stream but a draining stream.
5156 // The first packet being written after migration is a synchrnous write, which
5157 // will cause a PING packet being sent.
TEST_P(QuicStreamFactoryTest,MigrateSessionWithDrainingStreamSync)5158 TEST_P(QuicStreamFactoryTest, MigrateSessionWithDrainingStreamSync) {
5159 TestMigrateSessionWithDrainingStream(SYNCHRONOUS);
5160 }
5161
5162 // Regression test for http://crbug.com/847569.
5163 // This test verifies that the connection migrates to the alternate network
5164 // early when there is no active stream but a draining stream.
5165 // The first packet being written after migration is an asynchronous write, no
5166 // PING packet will be sent.
TEST_P(QuicStreamFactoryTest,MigrateSessionWithDrainingStreamAsync)5167 TEST_P(QuicStreamFactoryTest, MigrateSessionWithDrainingStreamAsync) {
5168 TestMigrateSessionWithDrainingStream(ASYNC);
5169 }
5170
TestMigrateSessionWithDrainingStream(IoMode write_mode_for_queued_packet)5171 void QuicStreamFactoryTestBase::TestMigrateSessionWithDrainingStream(
5172 IoMode write_mode_for_queued_packet) {
5173 InitializeConnectionMigrationV2Test(
5174 {kDefaultNetworkForTests, kNewNetworkForTests});
5175 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
5176 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
5177 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
5178
5179 // Using a testing task runner so that we can control time.
5180 auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
5181 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
5182
5183 scoped_mock_network_change_notifier_->mock_network_change_notifier()
5184 ->QueueNetworkMadeDefault(kDefaultNetworkForTests);
5185
5186 int packet_number = 1;
5187 MockQuicData quic_data1(version_);
5188 if (VersionUsesHttp3(version_.transport_version)) {
5189 quic_data1.AddWrite(SYNCHRONOUS,
5190 ConstructInitialSettingsPacket(packet_number++));
5191 }
5192 quic_data1.AddWrite(
5193 SYNCHRONOUS,
5194 ConstructGetRequestPacket(packet_number++,
5195 GetNthClientInitiatedBidirectionalStreamId(0),
5196 true, true));
5197 // Read an out of order packet with FIN to drain the stream.
5198 quic_data1.AddRead(
5199 ASYNC, ConstructOkResponsePacket(
5200 2, GetNthClientInitiatedBidirectionalStreamId(0), false,
5201 true)); // keep sending version.
5202 quic_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
5203 quic_data1.AddSocketDataToFactory(socket_factory_.get());
5204
5205 // Set up the second socket data provider that is used after migration.
5206 MockQuicData quic_data2(version_);
5207 // Connectivity probe to be sent on the new path.
5208 quic_data2.AddWrite(SYNCHRONOUS, client_maker_.MakeConnectivityProbingPacket(
5209 packet_number++, false));
5210 quic_data2.AddRead(ASYNC, ERR_IO_PENDING); // Pause
5211 // Connectivity probe to receive from the server.
5212 quic_data2.AddRead(ASYNC,
5213 server_maker_.MakeConnectivityProbingPacket(3, false));
5214 // Ping packet to send after migration is completed.
5215 quic_data2.AddWrite(write_mode_for_queued_packet,
5216 client_maker_.MakeAckPacket(packet_number++, 2, 3, 3));
5217 if (write_mode_for_queued_packet == SYNCHRONOUS) {
5218 quic_data2.AddWrite(ASYNC,
5219 client_maker_.MakePingPacket(packet_number++, false));
5220 }
5221 server_maker_.Reset();
5222 quic_data2.AddRead(
5223 ASYNC,
5224 ConstructOkResponsePacket(
5225 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false));
5226 quic_data2.AddWrite(SYNCHRONOUS,
5227 client_maker_.MakeAckPacket(packet_number++, 1, 3, 1));
5228 quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
5229 quic_data2.AddSocketDataToFactory(socket_factory_.get());
5230
5231 // Create request and QuicHttpStream.
5232 QuicStreamRequest request(factory_.get());
5233 EXPECT_EQ(
5234 ERR_IO_PENDING,
5235 request.Request(
5236 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
5237 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
5238 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
5239 failed_on_default_network_callback_, callback_.callback()));
5240 EXPECT_THAT(callback_.WaitForResult(), IsOk());
5241 std::unique_ptr<HttpStream> stream = CreateStream(&request);
5242 EXPECT_TRUE(stream.get());
5243
5244 // Cause QUIC stream to be created.
5245 HttpRequestInfo request_info;
5246 request_info.method = "GET";
5247 request_info.url = url_;
5248 request_info.traffic_annotation =
5249 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
5250 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
5251 net_log_, CompletionOnceCallback()));
5252
5253 // Ensure that session is alive and active.
5254 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
5255 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
5256 EXPECT_TRUE(HasActiveSession(host_port_pair_));
5257
5258 // Send GET request on stream.
5259 HttpResponseInfo response;
5260 HttpRequestHeaders request_headers;
5261 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
5262 callback_.callback()));
5263
5264 // Run the message loop to receive the out of order packet which contains a
5265 // FIN and drains the stream.
5266 base::RunLoop().RunUntilIdle();
5267 EXPECT_EQ(0u, session->GetNumActiveStreams());
5268
5269 EXPECT_EQ(0u, QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
5270 // Cause the connection to report path degrading to the session.
5271 // Session should still start to probe the alternate network.
5272 session->connection()->OnPathDegradingDetected();
5273 EXPECT_TRUE(HasActiveSession(host_port_pair_));
5274 EXPECT_EQ(1u, QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
5275
5276 // Next connectivity probe is scheduled to be sent in 2 *
5277 // kDefaultRTTMilliSecs.
5278 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
5279 base::TimeDelta next_task_delay = task_runner->NextPendingTaskDelay();
5280 EXPECT_EQ(base::TimeDelta::FromMilliseconds(2 * kDefaultRTTMilliSecs),
5281 next_task_delay);
5282
5283 // The connection should still be alive, and not marked as going away.
5284 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
5285
5286 // Resume quic data and a connectivity probe response will be read on the new
5287 // socket.
5288 quic_data2.Resume();
5289
5290 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
5291 EXPECT_TRUE(HasActiveSession(host_port_pair_));
5292 EXPECT_EQ(0u, session->GetNumActiveStreams());
5293 EXPECT_TRUE(session->HasActiveRequestStreams());
5294
5295 // There should be three pending tasks, the nearest one will complete
5296 // migration to the new network.
5297 EXPECT_EQ(3u, task_runner->GetPendingTaskCount());
5298 next_task_delay = task_runner->NextPendingTaskDelay();
5299 EXPECT_EQ(base::TimeDelta(), next_task_delay);
5300 task_runner->FastForwardBy(next_task_delay);
5301
5302 // Now there are two pending tasks, the nearest one was to send connectivity
5303 // probe and has been cancelled due to successful migration.
5304 EXPECT_EQ(2u, task_runner->GetPendingTaskCount());
5305 next_task_delay = task_runner->NextPendingTaskDelay();
5306 EXPECT_EQ(base::TimeDelta::FromMilliseconds(2 * kDefaultRTTMilliSecs),
5307 next_task_delay);
5308 task_runner->FastForwardBy(next_task_delay);
5309
5310 // There's one more task to mgirate back to the default network in 0.4s.
5311 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
5312 next_task_delay = task_runner->NextPendingTaskDelay();
5313 base::TimeDelta expected_delay =
5314 base::TimeDelta::FromSeconds(kMinRetryTimeForDefaultNetworkSecs) -
5315 base::TimeDelta::FromMilliseconds(2 * kDefaultRTTMilliSecs);
5316 EXPECT_EQ(expected_delay, next_task_delay);
5317
5318 base::RunLoop().RunUntilIdle();
5319
5320 // Deliver a signal that the alternate network now becomes default to session,
5321 // this will cancel mgirate back to default network timer.
5322 scoped_mock_network_change_notifier_->mock_network_change_notifier()
5323 ->NotifyNetworkMadeDefault(kNewNetworkForTests);
5324
5325 task_runner->FastForwardBy(next_task_delay);
5326 EXPECT_EQ(0u, task_runner->GetPendingTaskCount());
5327
5328 // Verify that the session is still alive.
5329 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
5330 EXPECT_TRUE(HasActiveSession(host_port_pair_));
5331 EXPECT_EQ(OK, stream->ReadResponseHeaders(callback_.callback()));
5332
5333 stream.reset();
5334 EXPECT_TRUE(quic_data1.AllReadDataConsumed());
5335 EXPECT_TRUE(quic_data1.AllWriteDataConsumed());
5336 EXPECT_TRUE(quic_data2.AllReadDataConsumed());
5337 EXPECT_TRUE(quic_data2.AllWriteDataConsumed());
5338 }
5339
5340 // Regression test for http://crbug.com/835444.
5341 // This test verifies that the connection migrates to the alternate network
5342 // when the alternate network is connected after path has been degrading.
TEST_P(QuicStreamFactoryTest,MigrateOnNewNetworkConnectAfterPathDegrading)5343 TEST_P(QuicStreamFactoryTest, MigrateOnNewNetworkConnectAfterPathDegrading) {
5344 InitializeConnectionMigrationV2Test({kDefaultNetworkForTests});
5345 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
5346 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
5347 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
5348
5349 // Using a testing task runner so that we can control time.
5350 auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
5351 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
5352
5353 scoped_mock_network_change_notifier_->mock_network_change_notifier()
5354 ->QueueNetworkMadeDefault(kDefaultNetworkForTests);
5355
5356 MockQuicData quic_data1(version_);
5357 quic_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging Read.
5358 int packet_num = 1;
5359 if (VersionUsesHttp3(version_.transport_version)) {
5360 quic_data1.AddWrite(SYNCHRONOUS,
5361 ConstructInitialSettingsPacket(packet_num++));
5362 }
5363 quic_data1.AddWrite(
5364 SYNCHRONOUS,
5365 ConstructGetRequestPacket(packet_num++,
5366 GetNthClientInitiatedBidirectionalStreamId(0),
5367 true, true));
5368 quic_data1.AddSocketDataToFactory(socket_factory_.get());
5369
5370 // Set up the second socket data provider that is used after migration.
5371 // The response to the earlier request is read on the new socket.
5372 MockQuicData quic_data2(version_);
5373 // Connectivity probe to be sent on the new path.
5374 quic_data2.AddWrite(SYNCHRONOUS, client_maker_.MakeConnectivityProbingPacket(
5375 packet_num++, true));
5376 quic_data2.AddRead(ASYNC, ERR_IO_PENDING); // Pause
5377 // Connectivity probe to receive from the server.
5378 quic_data2.AddRead(ASYNC,
5379 server_maker_.MakeConnectivityProbingPacket(1, false));
5380 // Ping packet to send after migration is completed.
5381 quic_data2.AddWrite(
5382 ASYNC, client_maker_.MakeAckAndPingPacket(packet_num++, false, 1, 1));
5383 quic_data2.AddRead(
5384 ASYNC,
5385 ConstructOkResponsePacket(
5386 2, GetNthClientInitiatedBidirectionalStreamId(0), false, false));
5387 quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
5388 if (VersionUsesHttp3(version_.transport_version)) {
5389 quic_data2.AddWrite(
5390 SYNCHRONOUS, client_maker_.MakeAckAndDataPacket(
5391 packet_num++, false, GetQpackDecoderStreamId(), 2, 2,
5392 false, StreamCancellationQpackDecoderInstruction(0)));
5393 quic_data2.AddWrite(
5394 SYNCHRONOUS,
5395 client_maker_.MakeRstPacket(
5396 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
5397 quic::QUIC_STREAM_CANCELLED));
5398 } else {
5399 quic_data2.AddWrite(
5400 SYNCHRONOUS,
5401 client_maker_.MakeAckAndRstPacket(
5402 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
5403 quic::QUIC_STREAM_CANCELLED, 2, 2));
5404 }
5405 quic_data2.AddSocketDataToFactory(socket_factory_.get());
5406
5407 // Create request and QuicHttpStream.
5408 QuicStreamRequest request(factory_.get());
5409 EXPECT_EQ(
5410 ERR_IO_PENDING,
5411 request.Request(
5412 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
5413 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
5414 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
5415 failed_on_default_network_callback_, callback_.callback()));
5416 EXPECT_THAT(callback_.WaitForResult(), IsOk());
5417 std::unique_ptr<HttpStream> stream = CreateStream(&request);
5418 EXPECT_TRUE(stream.get());
5419
5420 // Cause QUIC stream to be created.
5421 HttpRequestInfo request_info;
5422 request_info.method = "GET";
5423 request_info.url = url_;
5424 request_info.traffic_annotation =
5425 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
5426 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
5427 net_log_, CompletionOnceCallback()));
5428
5429 // Ensure that session is alive and active.
5430 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
5431 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
5432 EXPECT_TRUE(HasActiveSession(host_port_pair_));
5433
5434 // Send GET request on stream.
5435 HttpResponseInfo response;
5436 HttpRequestHeaders request_headers;
5437 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
5438 callback_.callback()));
5439
5440 EXPECT_EQ(0u, QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
5441
5442 // Cause the connection to report path degrading to the session.
5443 // Due to lack of alternate network, session will not mgirate connection.
5444 EXPECT_EQ(0u, task_runner->GetPendingTaskCount());
5445 EXPECT_EQ(0u, QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
5446 session->connection()->OnPathDegradingDetected();
5447 EXPECT_EQ(1u, QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
5448 EXPECT_EQ(0u, task_runner->GetPendingTaskCount());
5449
5450 EXPECT_EQ(1u, QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
5451
5452 // Deliver a signal that a alternate network is connected now, this should
5453 // cause the connection to start early migration on path degrading.
5454 scoped_mock_network_change_notifier_->mock_network_change_notifier()
5455 ->SetConnectedNetworksList(
5456 {kDefaultNetworkForTests, kNewNetworkForTests});
5457 scoped_mock_network_change_notifier_->mock_network_change_notifier()
5458 ->NotifyNetworkConnected(kNewNetworkForTests);
5459
5460 // Next connectivity probe is scheduled to be sent in 2 *
5461 // kDefaultRTTMilliSecs.
5462 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
5463 base::TimeDelta next_task_delay = task_runner->NextPendingTaskDelay();
5464 EXPECT_EQ(base::TimeDelta::FromMilliseconds(2 * kDefaultRTTMilliSecs),
5465 next_task_delay);
5466
5467 // The connection should still be alive, and not marked as going away.
5468 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
5469 EXPECT_TRUE(HasActiveSession(host_port_pair_));
5470 EXPECT_EQ(1u, session->GetNumActiveStreams());
5471 EXPECT_EQ(ERR_IO_PENDING, stream->ReadResponseHeaders(callback_.callback()));
5472
5473 // Resume quic data and a connectivity probe response will be read on the new
5474 // socket.
5475 quic_data2.Resume();
5476
5477 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
5478 EXPECT_TRUE(HasActiveSession(host_port_pair_));
5479 EXPECT_EQ(1u, session->GetNumActiveStreams());
5480
5481 // There should be three pending tasks, the nearest one will complete
5482 // migration to the new network.
5483 EXPECT_EQ(3u, task_runner->GetPendingTaskCount());
5484 next_task_delay = task_runner->NextPendingTaskDelay();
5485 EXPECT_EQ(base::TimeDelta(), next_task_delay);
5486 task_runner->FastForwardBy(next_task_delay);
5487
5488 // Although the session successfully migrates, it is still considered
5489 // degrading sessions.
5490 EXPECT_EQ(1u, QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
5491
5492 // Response headers are received over the new network.
5493 EXPECT_THAT(callback_.WaitForResult(), IsOk());
5494 EXPECT_EQ(200, response.headers->response_code());
5495
5496 // Now there are two pending tasks, the nearest one was to send connectivity
5497 // probe and has been cancelled due to successful migration.
5498 EXPECT_EQ(2u, task_runner->GetPendingTaskCount());
5499 next_task_delay = task_runner->NextPendingTaskDelay();
5500 EXPECT_EQ(base::TimeDelta::FromMilliseconds(2 * kDefaultRTTMilliSecs),
5501 next_task_delay);
5502 task_runner->FastForwardBy(next_task_delay);
5503
5504 // There's one more task to mgirate back to the default network in 0.4s.
5505 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
5506 next_task_delay = task_runner->NextPendingTaskDelay();
5507 base::TimeDelta expected_delay =
5508 base::TimeDelta::FromSeconds(kMinRetryTimeForDefaultNetworkSecs) -
5509 base::TimeDelta::FromMilliseconds(2 * kDefaultRTTMilliSecs);
5510 EXPECT_EQ(expected_delay, next_task_delay);
5511
5512 // Deliver a signal that the alternate network now becomes default to session,
5513 // this will cancel mgirate back to default network timer.
5514 scoped_mock_network_change_notifier_->mock_network_change_notifier()
5515 ->NotifyNetworkMadeDefault(kNewNetworkForTests);
5516
5517 task_runner->FastForwardBy(next_task_delay);
5518 EXPECT_EQ(0u, task_runner->GetPendingTaskCount());
5519
5520 // Verify that the session is still alive.
5521 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
5522 EXPECT_TRUE(HasActiveSession(host_port_pair_));
5523
5524 stream.reset();
5525 EXPECT_TRUE(quic_data1.AllReadDataConsumed());
5526 EXPECT_TRUE(quic_data1.AllWriteDataConsumed());
5527 EXPECT_TRUE(quic_data2.AllReadDataConsumed());
5528 EXPECT_TRUE(quic_data2.AllWriteDataConsumed());
5529 }
5530
5531 // This test verifies that multiple sessions are migrated on connection
5532 // migration signal.
TEST_P(QuicStreamFactoryTest,MigrateMultipleSessionsToBadSocketsAfterDisconnected)5533 TEST_P(QuicStreamFactoryTest,
5534 MigrateMultipleSessionsToBadSocketsAfterDisconnected) {
5535 InitializeConnectionMigrationV2Test({kDefaultNetworkForTests});
5536
5537 MockQuicData socket_data1(version_);
5538 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
5539 if (VersionUsesHttp3(version_.transport_version))
5540 socket_data1.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
5541 socket_data1.AddWrite(ASYNC, OK);
5542 socket_data1.AddSocketDataToFactory(socket_factory_.get());
5543 client_maker_.Reset();
5544 MockQuicData socket_data2(version_);
5545 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
5546 if (VersionUsesHttp3(version_.transport_version))
5547 socket_data2.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
5548 socket_data2.AddWrite(ASYNC, OK);
5549 socket_data2.AddSocketDataToFactory(socket_factory_.get());
5550
5551 HostPortPair server1(kDefaultServerHostName, 443);
5552 HostPortPair server2(kServer2HostName, 443);
5553
5554 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
5555 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
5556 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
5557
5558 host_resolver_->set_synchronous_mode(true);
5559 host_resolver_->rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", "");
5560 host_resolver_->rules()->AddIPLiteralRule(server2.host(), "192.168.0.2", "");
5561
5562 // Create request and QuicHttpStream to create session1.
5563 QuicStreamRequest request1(factory_.get());
5564 EXPECT_EQ(OK,
5565 request1.Request(
5566 server1, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
5567 NetworkIsolationKey(), false /* disable_secure_dns */,
5568 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
5569 failed_on_default_network_callback_, callback_.callback()));
5570 std::unique_ptr<HttpStream> stream1 = CreateStream(&request1);
5571 EXPECT_TRUE(stream1.get());
5572
5573 // Create request and QuicHttpStream to create session2.
5574 QuicStreamRequest request2(factory_.get());
5575 EXPECT_EQ(OK,
5576 request2.Request(
5577 server2, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
5578 NetworkIsolationKey(), false /* disable_secure_dns */,
5579 /*cert_verify_flags=*/0, url2_, net_log_, &net_error_details_,
5580 failed_on_default_network_callback_, callback_.callback()));
5581 std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
5582 EXPECT_TRUE(stream2.get());
5583
5584 QuicChromiumClientSession* session1 = GetActiveSession(server1);
5585 QuicChromiumClientSession* session2 = GetActiveSession(server2);
5586 EXPECT_NE(session1, session2);
5587
5588 // Cause QUIC stream to be created and send GET so session1 has an open
5589 // stream.
5590 HttpRequestInfo request_info1;
5591 request_info1.method = "GET";
5592 request_info1.url = url_;
5593 request_info1.traffic_annotation =
5594 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
5595 EXPECT_EQ(OK,
5596 stream1->InitializeStream(&request_info1, true, DEFAULT_PRIORITY,
5597 net_log_, CompletionOnceCallback()));
5598 HttpResponseInfo response1;
5599 HttpRequestHeaders request_headers1;
5600 EXPECT_EQ(OK, stream1->SendRequest(request_headers1, &response1,
5601 callback_.callback()));
5602
5603 // Cause QUIC stream to be created and send GET so session2 has an open
5604 // stream.
5605 HttpRequestInfo request_info2;
5606 request_info2.method = "GET";
5607 request_info2.url = url_;
5608 request_info2.traffic_annotation =
5609 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
5610 EXPECT_EQ(OK,
5611 stream2->InitializeStream(&request_info2, true, DEFAULT_PRIORITY,
5612 net_log_, CompletionOnceCallback()));
5613 HttpResponseInfo response2;
5614 HttpRequestHeaders request_headers2;
5615 EXPECT_EQ(OK, stream2->SendRequest(request_headers2, &response2,
5616 callback_.callback()));
5617
5618 // Cause both sessions to be paused due to DISCONNECTED.
5619 scoped_mock_network_change_notifier_->mock_network_change_notifier()
5620 ->NotifyNetworkDisconnected(kDefaultNetworkForTests);
5621
5622 // Ensure that both sessions are paused but alive.
5623 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session1));
5624 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session2));
5625
5626 // Add new sockets to use post migration. Those are bad sockets and will cause
5627 // migration to fail.
5628 MockConnect connect_result =
5629 MockConnect(SYNCHRONOUS, ERR_INTERNET_DISCONNECTED);
5630 SequencedSocketData socket_data3(connect_result, base::span<MockRead>(),
5631 base::span<MockWrite>());
5632 socket_factory_->AddSocketDataProvider(&socket_data3);
5633 SequencedSocketData socket_data4(connect_result, base::span<MockRead>(),
5634 base::span<MockWrite>());
5635 socket_factory_->AddSocketDataProvider(&socket_data4);
5636
5637 // Connect the new network and cause migration to bad sockets, causing
5638 // sessions to close.
5639 scoped_mock_network_change_notifier_->mock_network_change_notifier()
5640 ->SetConnectedNetworksList({kNewNetworkForTests});
5641 scoped_mock_network_change_notifier_->mock_network_change_notifier()
5642 ->NotifyNetworkConnected(kNewNetworkForTests);
5643
5644 EXPECT_FALSE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session1));
5645 EXPECT_FALSE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session2));
5646
5647 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
5648 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
5649 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
5650 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
5651 }
5652
5653 // This test verifies that session attempts connection migration with signals
5654 // delivered in the following order (no alternate network is available):
5655 // - path degrading is detected: session attempts connection migration but no
5656 // alternate network is available, session caches path degrading signal in
5657 // connection and stays on the original network.
5658 // - original network backs up, request is served in the orignal network,
5659 // session is not marked as going away.
TEST_P(QuicStreamFactoryTest,MigrateOnPathDegradingWithNoNewNetwork)5660 TEST_P(QuicStreamFactoryTest, MigrateOnPathDegradingWithNoNewNetwork) {
5661 InitializeConnectionMigrationV2Test({kDefaultNetworkForTests});
5662 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
5663 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
5664
5665 MockQuicData quic_data(version_);
5666 int packet_num = 1;
5667 if (VersionUsesHttp3(version_.transport_version)) {
5668 quic_data.AddWrite(SYNCHRONOUS,
5669 ConstructInitialSettingsPacket(packet_num++));
5670 }
5671 quic_data.AddWrite(
5672 SYNCHRONOUS,
5673 ConstructGetRequestPacket(packet_num++,
5674 GetNthClientInitiatedBidirectionalStreamId(0),
5675 true, true));
5676 quic_data.AddRead(ASYNC, ERR_IO_PENDING); // Pause for path degrading signal.
5677
5678 // The rest of the data will still flow in the original socket as there is no
5679 // new network after path degrading.
5680 quic_data.AddRead(ASYNC, ConstructOkResponsePacket(
5681 1, GetNthClientInitiatedBidirectionalStreamId(0),
5682 false, false));
5683 quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
5684 if (VersionUsesHttp3(version_.transport_version)) {
5685 quic_data.AddWrite(
5686 SYNCHRONOUS, client_maker_.MakeAckAndDataPacket(
5687 packet_num++, false, GetQpackDecoderStreamId(), 1, 1,
5688 false, StreamCancellationQpackDecoderInstruction(0)));
5689 quic_data.AddWrite(
5690 SYNCHRONOUS,
5691 client_maker_.MakeRstPacket(
5692 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
5693 quic::QUIC_STREAM_CANCELLED));
5694 } else {
5695 quic_data.AddWrite(
5696 SYNCHRONOUS,
5697 client_maker_.MakeAckAndRstPacket(
5698 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
5699 quic::QUIC_STREAM_CANCELLED, 1, 1));
5700 }
5701 quic_data.AddSocketDataToFactory(socket_factory_.get());
5702
5703 // Create request and QuicHttpStream.
5704 QuicStreamRequest request(factory_.get());
5705 EXPECT_EQ(
5706 ERR_IO_PENDING,
5707 request.Request(
5708 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
5709 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
5710 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
5711 failed_on_default_network_callback_, callback_.callback()));
5712 EXPECT_THAT(callback_.WaitForResult(), IsOk());
5713 std::unique_ptr<HttpStream> stream = CreateStream(&request);
5714 EXPECT_TRUE(stream.get());
5715
5716 // Cause QUIC stream to be created.
5717 HttpRequestInfo request_info;
5718 request_info.method = "GET";
5719 request_info.url = url_;
5720 request_info.traffic_annotation =
5721 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
5722 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
5723 net_log_, CompletionOnceCallback()));
5724
5725 // Ensure that session is alive and active.
5726 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
5727 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
5728 EXPECT_TRUE(HasActiveSession(host_port_pair_));
5729
5730 // Send GET request on stream.
5731 HttpResponseInfo response;
5732 HttpRequestHeaders request_headers;
5733 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
5734 callback_.callback()));
5735
5736 // Trigger connection migration on path degrading. Since there are no networks
5737 // to migrate to, the session will remain on the original network, not marked
5738 // as going away.
5739 EXPECT_EQ(0u, QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
5740 session->connection()->OnPathDegradingDetected();
5741 EXPECT_TRUE(session->connection()->IsPathDegrading());
5742 EXPECT_EQ(1u, QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
5743
5744 EXPECT_TRUE(HasActiveSession(host_port_pair_));
5745 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
5746 EXPECT_EQ(1u, session->GetNumActiveStreams());
5747 EXPECT_EQ(ERR_IO_PENDING, stream->ReadResponseHeaders(callback_.callback()));
5748
5749 // Resume so that rest of the data will flow in the original socket.
5750 quic_data.Resume();
5751
5752 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
5753 EXPECT_TRUE(HasActiveSession(host_port_pair_));
5754 EXPECT_EQ(1u, session->GetNumActiveStreams());
5755
5756 stream.reset();
5757 EXPECT_TRUE(quic_data.AllReadDataConsumed());
5758 EXPECT_TRUE(quic_data.AllWriteDataConsumed());
5759 }
5760
5761 // This test verifies that session with non-migratable stream will probe the
5762 // alternate network on path degrading, and close the non-migratable streams
5763 // when probe is successful.
TEST_P(QuicStreamFactoryTest,MigrateSessionEarlyNonMigratableStream_DoNotMigrateIdleSessions)5764 TEST_P(QuicStreamFactoryTest,
5765 MigrateSessionEarlyNonMigratableStream_DoNotMigrateIdleSessions) {
5766 TestMigrateSessionEarlyNonMigratableStream(false);
5767 }
5768
TEST_P(QuicStreamFactoryTest,MigrateSessionEarlyNonMigratableStream_MigrateIdleSessions)5769 TEST_P(QuicStreamFactoryTest,
5770 MigrateSessionEarlyNonMigratableStream_MigrateIdleSessions) {
5771 TestMigrateSessionEarlyNonMigratableStream(true);
5772 }
5773
TestMigrateSessionEarlyNonMigratableStream(bool migrate_idle_sessions)5774 void QuicStreamFactoryTestBase::TestMigrateSessionEarlyNonMigratableStream(
5775 bool migrate_idle_sessions) {
5776 quic_params_->migrate_idle_sessions = migrate_idle_sessions;
5777 InitializeConnectionMigrationV2Test(
5778 {kDefaultNetworkForTests, kNewNetworkForTests});
5779 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
5780 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
5781
5782 MockQuicData socket_data(version_);
5783 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
5784 int packet_num = 1;
5785 if (VersionUsesHttp3(version_.transport_version)) {
5786 socket_data.AddWrite(SYNCHRONOUS,
5787 ConstructInitialSettingsPacket(packet_num++));
5788 }
5789
5790 // Set up the second socket data provider that is used for probing.
5791 MockQuicData quic_data1(version_);
5792 // Connectivity probe to be sent on the new path.
5793 quic_data1.AddWrite(SYNCHRONOUS, client_maker_.MakeConnectivityProbingPacket(
5794 packet_num++, true));
5795 quic_data1.AddRead(ASYNC, ERR_IO_PENDING); // Pause
5796 // Connectivity probe to receive from the server.
5797 quic_data1.AddRead(ASYNC,
5798 server_maker_.MakeConnectivityProbingPacket(1, false));
5799
5800 if (migrate_idle_sessions) {
5801 quic_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read.
5802 // A RESET will be sent to the peer to cancel the non-migratable stream.
5803 if (VersionUsesHttp3(version_.transport_version)) {
5804 quic_data1.AddWrite(SYNCHRONOUS,
5805 client_maker_.MakeDataRstAndAckPacket(
5806 packet_num++, true, GetQpackDecoderStreamId(),
5807 StreamCancellationQpackDecoderInstruction(0),
5808 GetNthClientInitiatedBidirectionalStreamId(0),
5809 quic::QUIC_STREAM_CANCELLED, 1, 1));
5810 } else {
5811 quic_data1.AddWrite(SYNCHRONOUS,
5812 client_maker_.MakeAckAndRstPacket(
5813 packet_num++, false,
5814 GetNthClientInitiatedBidirectionalStreamId(0),
5815 quic::QUIC_STREAM_CANCELLED, 1, 1));
5816 }
5817 // Ping packet to send after migration is completed.
5818 quic_data1.AddWrite(SYNCHRONOUS,
5819 client_maker_.MakePingPacket(packet_num++, false));
5820
5821 } else {
5822 if (version_.UsesTls()) {
5823 if (VersionUsesHttp3(version_.transport_version)) {
5824 socket_data.AddWrite(
5825 SYNCHRONOUS,
5826 client_maker_.MakeDataRstAckAndConnectionClosePacket(
5827 packet_num++, false, GetQpackDecoderStreamId(),
5828 StreamCancellationQpackDecoderInstruction(0),
5829 GetNthClientInitiatedBidirectionalStreamId(0),
5830 quic::QUIC_STREAM_CANCELLED, 1, 1,
5831 quic::QUIC_CONNECTION_MIGRATION_NO_MIGRATABLE_STREAMS,
5832 "net error"));
5833 } else {
5834 socket_data.AddWrite(
5835 SYNCHRONOUS,
5836 client_maker_.MakeRstAckAndConnectionClosePacket(
5837 packet_num++, false,
5838 GetNthClientInitiatedBidirectionalStreamId(0),
5839 quic::QUIC_STREAM_CANCELLED, 1, 1,
5840 quic::QUIC_CONNECTION_MIGRATION_NO_MIGRATABLE_STREAMS,
5841 "net error"));
5842 }
5843 } else {
5844 if (VersionUsesHttp3(version_.transport_version)) {
5845 socket_data.AddWrite(
5846 SYNCHRONOUS,
5847 client_maker_.MakeDataRstAckAndConnectionClosePacket(
5848 packet_num++, false, GetQpackDecoderStreamId(),
5849 StreamCancellationQpackDecoderInstruction(0),
5850 GetNthClientInitiatedBidirectionalStreamId(0),
5851 quic::QUIC_STREAM_CANCELLED, 1, 1,
5852 quic::QUIC_CONNECTION_MIGRATION_NO_MIGRATABLE_STREAMS,
5853 "net error"));
5854 } else {
5855 socket_data.AddWrite(
5856 SYNCHRONOUS,
5857 client_maker_.MakeRstAckAndConnectionClosePacket(
5858 packet_num++, false,
5859 GetNthClientInitiatedBidirectionalStreamId(0),
5860 quic::QUIC_STREAM_CANCELLED, 1, 1,
5861 quic::QUIC_CONNECTION_MIGRATION_NO_MIGRATABLE_STREAMS,
5862 "net error"));
5863 }
5864 }
5865 }
5866
5867 socket_data.AddSocketDataToFactory(socket_factory_.get());
5868 quic_data1.AddSocketDataToFactory(socket_factory_.get());
5869
5870 // Create request and QuicHttpStream.
5871 QuicStreamRequest request(factory_.get());
5872 EXPECT_EQ(
5873 ERR_IO_PENDING,
5874 request.Request(
5875 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
5876 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
5877 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
5878 failed_on_default_network_callback_, callback_.callback()));
5879 EXPECT_THAT(callback_.WaitForResult(), IsOk());
5880 std::unique_ptr<HttpStream> stream = CreateStream(&request);
5881 EXPECT_TRUE(stream.get());
5882
5883 // Cause QUIC stream to be created, but marked as non-migratable.
5884 HttpRequestInfo request_info;
5885 request_info.load_flags |= LOAD_DISABLE_CONNECTION_MIGRATION_TO_CELLULAR;
5886 request_info.traffic_annotation =
5887 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
5888 EXPECT_EQ(OK, stream->InitializeStream(&request_info, false, DEFAULT_PRIORITY,
5889 net_log_, CompletionOnceCallback()));
5890
5891 // Ensure that session is alive and active.
5892 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
5893 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
5894 EXPECT_TRUE(HasActiveSession(host_port_pair_));
5895
5896 // Trigger connection migration. Since there is a non-migratable stream,
5897 // this should cause session to migrate.
5898 session->OnPathDegrading();
5899
5900 // Run the message loop so that data queued in the new socket is read by the
5901 // packet reader.
5902 base::RunLoop().RunUntilIdle();
5903
5904 EXPECT_TRUE(HasActiveSession(host_port_pair_));
5905 EXPECT_EQ(1u, session->GetNumActiveStreams());
5906
5907 // Resume the data to read the connectivity probing response to declare probe
5908 // as successful. Non-migratable streams will be closed.
5909 quic_data1.Resume();
5910 if (migrate_idle_sessions)
5911 base::RunLoop().RunUntilIdle();
5912
5913 EXPECT_EQ(migrate_idle_sessions, HasActiveSession(host_port_pair_));
5914 EXPECT_EQ(0u, session->GetNumActiveStreams());
5915
5916 EXPECT_TRUE(quic_data1.AllReadDataConsumed());
5917 EXPECT_TRUE(quic_data1.AllWriteDataConsumed());
5918 EXPECT_TRUE(socket_data.AllReadDataConsumed());
5919 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
5920 }
5921
TEST_P(QuicStreamFactoryTest,MigrateSessionEarlyConnectionMigrationDisabled)5922 TEST_P(QuicStreamFactoryTest, MigrateSessionEarlyConnectionMigrationDisabled) {
5923 InitializeConnectionMigrationV2Test(
5924 {kDefaultNetworkForTests, kNewNetworkForTests});
5925 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
5926 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
5927
5928 MockQuicData socket_data(version_);
5929 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
5930 int packet_num = 1;
5931 if (VersionUsesHttp3(version_.transport_version)) {
5932 socket_data.AddWrite(SYNCHRONOUS,
5933 ConstructInitialSettingsPacket(packet_num++));
5934 }
5935 if (VersionUsesHttp3(version_.transport_version)) {
5936 socket_data.AddWrite(
5937 SYNCHRONOUS, client_maker_.MakeDataPacket(
5938 packet_num++, GetQpackDecoderStreamId(), true, false,
5939 StreamCancellationQpackDecoderInstruction(0)));
5940 }
5941 socket_data.AddWrite(
5942 SYNCHRONOUS,
5943 client_maker_.MakeRstPacket(packet_num++, true,
5944 GetNthClientInitiatedBidirectionalStreamId(0),
5945 quic::QUIC_STREAM_CANCELLED));
5946 socket_data.AddSocketDataToFactory(socket_factory_.get());
5947
5948 // Create request and QuicHttpStream.
5949 QuicStreamRequest request(factory_.get());
5950 EXPECT_EQ(
5951 ERR_IO_PENDING,
5952 request.Request(
5953 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
5954 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
5955 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
5956 failed_on_default_network_callback_, callback_.callback()));
5957 EXPECT_THAT(callback_.WaitForResult(), IsOk());
5958 std::unique_ptr<HttpStream> stream = CreateStream(&request);
5959 EXPECT_TRUE(stream.get());
5960
5961 // Cause QUIC stream to be created.
5962 HttpRequestInfo request_info;
5963 request_info.traffic_annotation =
5964 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
5965 EXPECT_EQ(OK, stream->InitializeStream(&request_info, false, DEFAULT_PRIORITY,
5966 net_log_, CompletionOnceCallback()));
5967
5968 // Ensure that session is alive and active.
5969 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
5970 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
5971 EXPECT_TRUE(HasActiveSession(host_port_pair_));
5972
5973 // Set session config to have connection migration disabled.
5974 quic::test::QuicConfigPeer::SetReceivedDisableConnectionMigration(
5975 session->config());
5976 EXPECT_TRUE(session->config()->DisableConnectionMigration());
5977
5978 // Trigger connection migration. Since there is a non-migratable stream,
5979 // this should cause session to be continue without migrating.
5980 session->OnPathDegrading();
5981
5982 // Run the message loop so that data queued in the new socket is read by the
5983 // packet reader.
5984 base::RunLoop().RunUntilIdle();
5985
5986 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
5987 EXPECT_TRUE(HasActiveSession(host_port_pair_));
5988 EXPECT_EQ(1u, session->GetNumActiveStreams());
5989
5990 stream.reset();
5991
5992 EXPECT_TRUE(socket_data.AllReadDataConsumed());
5993 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
5994 }
5995
5996 // Regression test for http://crbug.com/791886.
5997 // This test verifies that the old packet writer which encountered an
5998 // asynchronous write error will be blocked during migration on write error. New
5999 // packets would not be written until the one with write error is rewritten on
6000 // the new network.
TEST_P(QuicStreamFactoryTest,MigrateSessionOnAsyncWriteError)6001 TEST_P(QuicStreamFactoryTest, MigrateSessionOnAsyncWriteError) {
6002 InitializeConnectionMigrationV2Test(
6003 {kDefaultNetworkForTests, kNewNetworkForTests});
6004 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
6005 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
6006 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
6007
6008 // Using a testing task runner so that we can control time.
6009 // base::RunLoop() controls mocked socket writes and reads.
6010 auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
6011 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
6012
6013 MockQuicData socket_data(version_);
6014 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
6015 int packet_num = 1;
6016 if (VersionUsesHttp3(version_.transport_version)) {
6017 socket_data.AddWrite(SYNCHRONOUS,
6018 ConstructInitialSettingsPacket(packet_num++));
6019 }
6020 socket_data.AddWrite(ASYNC, ERR_ADDRESS_UNREACHABLE);
6021 socket_data.AddSocketDataToFactory(socket_factory_.get());
6022
6023 // Set up second socket data provider that is used after
6024 // migration. The request is rewritten to this new socket, and the
6025 // response to the request is read on this new socket.
6026 MockQuicData socket_data1(version_);
6027 socket_data1.AddWrite(
6028 SYNCHRONOUS,
6029 ConstructGetRequestPacket(packet_num++,
6030 GetNthClientInitiatedBidirectionalStreamId(0),
6031 true, true));
6032 socket_data1.AddWrite(
6033 SYNCHRONOUS,
6034 ConstructGetRequestPacket(
6035 packet_num++, GetNthClientInitiatedBidirectionalStreamId(1),
6036 GetNthClientInitiatedBidirectionalStreamId(0), true, true));
6037 socket_data1.AddRead(
6038 ASYNC,
6039 ConstructOkResponsePacket(
6040 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false));
6041 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
6042 if (VersionUsesHttp3(version_.transport_version)) {
6043 socket_data1.AddWrite(
6044 SYNCHRONOUS, client_maker_.MakeAckAndDataPacket(
6045 packet_num++, false, GetQpackDecoderStreamId(), 1, 1,
6046 false, StreamCancellationQpackDecoderInstruction(0)));
6047 socket_data1.AddWrite(
6048 SYNCHRONOUS,
6049 client_maker_.MakeRstPacket(
6050 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
6051 quic::QUIC_STREAM_CANCELLED));
6052 } else {
6053 socket_data1.AddWrite(
6054 SYNCHRONOUS,
6055 client_maker_.MakeAckAndRstPacket(
6056 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
6057 quic::QUIC_STREAM_CANCELLED, 1, 1));
6058 }
6059 if (VersionUsesHttp3(version_.transport_version)) {
6060 socket_data1.AddWrite(
6061 SYNCHRONOUS, client_maker_.MakeDataPacket(
6062 packet_num++, GetQpackDecoderStreamId(),
6063 /* should_include_version = */ true,
6064 /* fin = */ false,
6065 StreamCancellationQpackDecoderInstruction(1, false)));
6066 }
6067 socket_data1.AddWrite(
6068 SYNCHRONOUS,
6069 client_maker_.MakeRstPacket(packet_num++, false,
6070 GetNthClientInitiatedBidirectionalStreamId(1),
6071 quic::QUIC_STREAM_CANCELLED,
6072 /*include_stop_sending_if_v99=*/true));
6073
6074 socket_data1.AddSocketDataToFactory(socket_factory_.get());
6075
6076 // Create request #1 and QuicHttpStream.
6077 QuicStreamRequest request1(factory_.get());
6078 EXPECT_EQ(
6079 ERR_IO_PENDING,
6080 request1.Request(
6081 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
6082 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
6083 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
6084 failed_on_default_network_callback_, callback_.callback()));
6085 EXPECT_THAT(callback_.WaitForResult(), IsOk());
6086 std::unique_ptr<HttpStream> stream1 = CreateStream(&request1);
6087 EXPECT_TRUE(stream1.get());
6088
6089 HttpRequestInfo request_info1;
6090 request_info1.method = "GET";
6091 request_info1.url = GURL("https://www.example.org/");
6092 request_info1.traffic_annotation =
6093 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
6094 EXPECT_EQ(OK,
6095 stream1->InitializeStream(&request_info1, true, DEFAULT_PRIORITY,
6096 net_log_, CompletionOnceCallback()));
6097
6098 // Request #2 returns synchronously because it pools to existing session.
6099 TestCompletionCallback callback2;
6100 QuicStreamRequest request2(factory_.get());
6101 EXPECT_EQ(
6102 OK,
6103 request2.Request(
6104 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
6105 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
6106 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
6107 failed_on_default_network_callback_, callback2.callback()));
6108 std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
6109 EXPECT_TRUE(stream2.get());
6110
6111 HttpRequestInfo request_info2;
6112 request_info2.method = "GET";
6113 request_info2.url = GURL("https://www.example.org/");
6114 request_info2.traffic_annotation =
6115 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
6116 EXPECT_EQ(OK,
6117 stream2->InitializeStream(&request_info2, true, DEFAULT_PRIORITY,
6118 net_log_, CompletionOnceCallback()));
6119
6120 // Ensure that session is alive and active.
6121 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
6122 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
6123 EXPECT_TRUE(HasActiveSession(host_port_pair_));
6124 EXPECT_EQ(2u, session->GetNumActiveStreams());
6125
6126 // Send GET request on stream1. This should cause an async write error.
6127 HttpResponseInfo response;
6128 HttpRequestHeaders request_headers;
6129 EXPECT_EQ(OK, stream1->SendRequest(request_headers, &response,
6130 callback_.callback()));
6131 EXPECT_EQ(0u, task_runner->GetPendingTaskCount());
6132
6133 // Run the message loop so that asynchronous write completes and a connection
6134 // migration on write error attempt is posted in QuicStreamFactory's task
6135 // runner.
6136 base::RunLoop().RunUntilIdle();
6137 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
6138
6139 // Send GET request on stream. This will cause another write attempt before
6140 // migration on write error is exectued.
6141 HttpResponseInfo response2;
6142 HttpRequestHeaders request_headers2;
6143 EXPECT_EQ(OK, stream2->SendRequest(request_headers2, &response2,
6144 callback2.callback()));
6145
6146 // Run the task runner so that migration on write error is finally executed.
6147 task_runner->RunUntilIdle();
6148
6149 // Verify the session is still alive and not marked as going away.
6150 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
6151 EXPECT_TRUE(HasActiveSession(host_port_pair_));
6152 EXPECT_EQ(2u, session->GetNumActiveStreams());
6153 // There should be one task posted to migrate back to the default network in
6154 // kMinRetryTimeForDefaultNetworkSecs.
6155 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
6156 EXPECT_EQ(base::TimeDelta::FromSeconds(kMinRetryTimeForDefaultNetworkSecs),
6157 task_runner->NextPendingTaskDelay());
6158
6159 // Verify that response headers on the migrated socket were delivered to the
6160 // stream.
6161 EXPECT_EQ(OK, stream1->ReadResponseHeaders(callback_.callback()));
6162 EXPECT_EQ(200, response.headers->response_code());
6163
6164 stream1.reset();
6165 stream2.reset();
6166
6167 EXPECT_TRUE(socket_data.AllReadDataConsumed());
6168 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
6169 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
6170 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
6171 }
6172
6173 // Verify session is not marked as going away after connection migration on
6174 // write error and migrate back to default network logic is applied to bring the
6175 // migrated session back to the default network. Migration singals delivered
6176 // in the following order (alternate network is always availabe):
6177 // - session on the default network encountered a write error;
6178 // - session successfully migrated to the non-default network;
6179 // - session attempts to migrate back to default network post migration;
6180 // - migration back to the default network is successful.
TEST_P(QuicStreamFactoryTest,MigrateBackToDefaultPostMigrationOnWriteError)6181 TEST_P(QuicStreamFactoryTest, MigrateBackToDefaultPostMigrationOnWriteError) {
6182 InitializeConnectionMigrationV2Test(
6183 {kDefaultNetworkForTests, kNewNetworkForTests});
6184 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
6185 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
6186 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
6187
6188 // Using a testing task runner so that we can control time.
6189 auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
6190 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
6191
6192 MockQuicData socket_data(version_);
6193 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
6194 int packet_num = 1;
6195 if (VersionUsesHttp3(version_.transport_version)) {
6196 socket_data.AddWrite(SYNCHRONOUS,
6197 ConstructInitialSettingsPacket(packet_num++));
6198 }
6199 socket_data.AddWrite(ASYNC, ERR_ADDRESS_UNREACHABLE);
6200 socket_data.AddSocketDataToFactory(socket_factory_.get());
6201
6202 // Set up second socket data provider that is used after
6203 // migration. The request is rewritten to this new socket, and the
6204 // response to the request is read on this new socket.
6205 MockQuicData quic_data2(version_);
6206 quic_data2.AddWrite(
6207 SYNCHRONOUS,
6208 ConstructGetRequestPacket(packet_num++,
6209 GetNthClientInitiatedBidirectionalStreamId(0),
6210 true, true));
6211 quic_data2.AddRead(
6212 ASYNC,
6213 ConstructOkResponsePacket(
6214 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false));
6215 quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
6216 quic_data2.AddSocketDataToFactory(socket_factory_.get());
6217
6218 // Create request QuicHttpStream.
6219 QuicStreamRequest request1(factory_.get());
6220 EXPECT_EQ(
6221 ERR_IO_PENDING,
6222 request1.Request(
6223 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
6224 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
6225 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
6226 failed_on_default_network_callback_, callback_.callback()));
6227 EXPECT_THAT(callback_.WaitForResult(), IsOk());
6228 std::unique_ptr<HttpStream> stream1 = CreateStream(&request1);
6229 EXPECT_TRUE(stream1.get());
6230
6231 HttpRequestInfo request_info1;
6232 request_info1.method = "GET";
6233 request_info1.url = GURL("https://www.example.org/");
6234 request_info1.traffic_annotation =
6235 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
6236 EXPECT_EQ(OK,
6237 stream1->InitializeStream(&request_info1, true, DEFAULT_PRIORITY,
6238 net_log_, CompletionOnceCallback()));
6239
6240 // Ensure that session is alive and active.
6241 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
6242 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
6243 EXPECT_TRUE(HasActiveSession(host_port_pair_));
6244 EXPECT_EQ(1u, session->GetNumActiveStreams());
6245
6246 // Send GET request. This should cause an async write error.
6247 HttpResponseInfo response;
6248 HttpRequestHeaders request_headers;
6249 EXPECT_EQ(OK, stream1->SendRequest(request_headers, &response,
6250 callback_.callback()));
6251 EXPECT_EQ(0u, task_runner->GetPendingTaskCount());
6252
6253 // Run the message loop so that asynchronous write completes and a connection
6254 // migration on write error attempt is posted in QuicStreamFactory's task
6255 // runner.
6256 base::RunLoop().RunUntilIdle();
6257 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
6258
6259 // Run the task runner so that migration on write error is finally executed.
6260 task_runner->RunUntilIdle();
6261
6262 // Verify the session is still alive and not marked as going away.
6263 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
6264 EXPECT_TRUE(HasActiveSession(host_port_pair_));
6265 EXPECT_EQ(1u, session->GetNumActiveStreams());
6266 // There should be one task posted to migrate back to the default network in
6267 // kMinRetryTimeForDefaultNetworkSecs.
6268 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
6269 base::TimeDelta expected_delay =
6270 base::TimeDelta::FromSeconds(kMinRetryTimeForDefaultNetworkSecs);
6271 EXPECT_EQ(expected_delay, task_runner->NextPendingTaskDelay());
6272
6273 // Verify that response headers on the migrated socket were delivered to the
6274 // stream.
6275 EXPECT_EQ(OK, stream1->ReadResponseHeaders(callback_.callback()));
6276 EXPECT_EQ(200, response.headers->response_code());
6277
6278 // Set up the third socket data provider for migrate back to default network.
6279 MockQuicData quic_data3(version_);
6280 // Connectivity probe to be sent on the new path.
6281 quic_data3.AddWrite(SYNCHRONOUS, client_maker_.MakeConnectivityProbingPacket(
6282 packet_num++, false));
6283 // Connectivity probe to receive from the server.
6284 quic_data3.AddRead(ASYNC,
6285 server_maker_.MakeConnectivityProbingPacket(2, false));
6286 quic_data3.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
6287 quic_data3.AddWrite(ASYNC,
6288 client_maker_.MakeAckPacket(packet_num++, 1, 2, 1));
6289 if (VersionUsesHttp3(version_.transport_version)) {
6290 quic_data3.AddWrite(
6291 SYNCHRONOUS, client_maker_.MakeDataPacket(
6292 packet_num++, GetQpackDecoderStreamId(), true, false,
6293 StreamCancellationQpackDecoderInstruction(0)));
6294 }
6295 quic_data3.AddWrite(
6296 SYNCHRONOUS,
6297 client_maker_.MakeRstPacket(packet_num++, false,
6298 GetNthClientInitiatedBidirectionalStreamId(0),
6299 quic::QUIC_STREAM_CANCELLED,
6300 /*include_stop_sending_if_v99=*/true));
6301 quic_data3.AddSocketDataToFactory(socket_factory_.get());
6302
6303 // Fast forward to fire the migrate back timer and verify the session
6304 // successfully migrates back to the default network.
6305 task_runner->FastForwardBy(expected_delay);
6306
6307 // Verify the session is still alive and not marked as going away.
6308 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
6309 EXPECT_TRUE(HasActiveSession(host_port_pair_));
6310 EXPECT_EQ(1u, session->GetNumActiveStreams());
6311
6312 // There should be one task posted to one will resend a connectivity probe and
6313 // the other will retry migrate back, both are cancelled.
6314 EXPECT_EQ(2u, task_runner->GetPendingTaskCount());
6315 task_runner->FastForwardBy(
6316 base::TimeDelta::FromSeconds(2 * kMinRetryTimeForDefaultNetworkSecs));
6317 EXPECT_EQ(0u, task_runner->GetPendingTaskCount());
6318
6319 stream1.reset();
6320 EXPECT_TRUE(socket_data.AllReadDataConsumed());
6321 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
6322 EXPECT_TRUE(quic_data2.AllReadDataConsumed());
6323 EXPECT_TRUE(quic_data2.AllWriteDataConsumed());
6324 EXPECT_TRUE(quic_data3.AllReadDataConsumed());
6325 EXPECT_TRUE(quic_data3.AllWriteDataConsumed());
6326 }
6327
6328 // This test verifies that the connection will not attempt connection migration
6329 // (send connectivity probes on alternate path) when path degrading is detected
6330 // and handshake is not confirmed.
TEST_P(QuicStreamFactoryTest,NoMigrationOnPathDegradingBeforeHandshakeConfirmed)6331 TEST_P(QuicStreamFactoryTest,
6332 NoMigrationOnPathDegradingBeforeHandshakeConfirmed) {
6333 InitializeConnectionMigrationV2Test(
6334 {kDefaultNetworkForTests, kNewNetworkForTests});
6335
6336 // Using a testing task runner.
6337 auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
6338 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
6339
6340 // Use cold start mode to send crypto message for handshake.
6341 crypto_client_stream_factory_.set_handshake_mode(
6342 MockCryptoClientStream::COLD_START_WITH_CHLO_SENT);
6343
6344 MockQuicData socket_data(version_);
6345 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
6346 socket_data.AddWrite(ASYNC, client_maker_.MakeDummyCHLOPacket(1));
6347 socket_data.AddSocketDataToFactory(socket_factory_.get());
6348
6349 // Create request and QuicHttpStream.
6350 QuicStreamRequest request(factory_.get());
6351 EXPECT_EQ(
6352 ERR_IO_PENDING,
6353 request.Request(
6354 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
6355 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
6356 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
6357 failed_on_default_network_callback_, callback_.callback()));
6358
6359 base::RunLoop().RunUntilIdle();
6360
6361 // Ensure that session is alive but not active.
6362 EXPECT_FALSE(HasActiveSession(host_port_pair_));
6363 EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_));
6364 QuicChromiumClientSession* session = GetPendingSession(host_port_pair_);
6365 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
6366 EXPECT_EQ(0u, task_runner->GetPendingTaskCount());
6367
6368 // Cause the connection to report path degrading to the session.
6369 // Session will ignore the signal as handshake is not completed.
6370 EXPECT_EQ(0u, QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
6371 session->connection()->OnPathDegradingDetected();
6372 EXPECT_EQ(0u, task_runner->GetPendingTaskCount());
6373 EXPECT_EQ(1u, QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
6374
6375 EXPECT_FALSE(HasActiveSession(host_port_pair_));
6376 EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_));
6377 EXPECT_TRUE(socket_data.AllReadDataConsumed());
6378 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
6379 }
6380
6381 // This test verifies that if a connection is closed with
6382 // QUIC_NETWORK_IDLE_TIMEOUT before handshake is completed and there is no
6383 // alternate network, no new connection will be created.
TEST_P(QuicStreamFactoryTest,NoAlternateNetworkBeforeHandshakeOnIdleTimeout)6384 TEST_P(QuicStreamFactoryTest, NoAlternateNetworkBeforeHandshakeOnIdleTimeout) {
6385 TestNoAlternateNetworkBeforeHandshake(quic::QUIC_NETWORK_IDLE_TIMEOUT);
6386 }
6387
6388 // This test verifies that if a connection is closed with QUIC_HANDSHAKE_TIMEOUT
6389 // and there is no alternate network, no new connection will be created.
TEST_P(QuicStreamFactoryTest,NoAlternateNetworkOnHandshakeTimeout)6390 TEST_P(QuicStreamFactoryTest, NoAlternateNetworkOnHandshakeTimeout) {
6391 TestNoAlternateNetworkBeforeHandshake(quic::QUIC_HANDSHAKE_TIMEOUT);
6392 }
6393
TestNoAlternateNetworkBeforeHandshake(quic::QuicErrorCode quic_error)6394 void QuicStreamFactoryTestBase::TestNoAlternateNetworkBeforeHandshake(
6395 quic::QuicErrorCode quic_error) {
6396 DCHECK(quic_error == quic::QUIC_NETWORK_IDLE_TIMEOUT ||
6397 quic_error == quic::QUIC_HANDSHAKE_TIMEOUT);
6398 InitializeConnectionMigrationV2Test({kDefaultNetworkForTests});
6399
6400 // Using a testing task runner.
6401 auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
6402 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
6403
6404 // Use cold start mode to send crypto message for handshake.
6405 crypto_client_stream_factory_.set_handshake_mode(
6406 MockCryptoClientStream::COLD_START_WITH_CHLO_SENT);
6407
6408 MockQuicData socket_data(version_);
6409 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
6410 socket_data.AddWrite(ASYNC, client_maker_.MakeDummyCHLOPacket(1));
6411 socket_data.AddSocketDataToFactory(socket_factory_.get());
6412
6413 // Create request.
6414 QuicStreamRequest request(factory_.get());
6415 EXPECT_EQ(
6416 ERR_IO_PENDING,
6417 request.Request(
6418 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
6419 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
6420 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
6421 failed_on_default_network_callback_, callback_.callback()));
6422
6423 base::RunLoop().RunUntilIdle();
6424
6425 // Ensure that session is alive but not active.
6426 EXPECT_FALSE(HasActiveSession(host_port_pair_));
6427 EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_));
6428 QuicChromiumClientSession* session = GetPendingSession(host_port_pair_);
6429 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
6430 EXPECT_EQ(0u, task_runner->GetPendingTaskCount());
6431
6432 EXPECT_EQ(0u, QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
6433 // Cause the connection to report path degrading to the session.
6434 // Session will ignore the signal as handshake is not completed.
6435 session->connection()->OnPathDegradingDetected();
6436 EXPECT_EQ(1u, QuicStreamFactoryPeer::GetNumDegradingSessions(factory_.get()));
6437 EXPECT_EQ(0u, task_runner->GetPendingTaskCount());
6438 EXPECT_FALSE(HasActiveSession(host_port_pair_));
6439 EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_));
6440
6441 // Cause the connection to close due to |quic_error| before handshake.
6442 std::string error_details;
6443 if (quic_error == quic::QUIC_NETWORK_IDLE_TIMEOUT) {
6444 error_details = "No recent network activity.";
6445 } else {
6446 error_details = "Handshake timeout expired.";
6447 }
6448 session->connection()->CloseConnection(
6449 quic_error, error_details, quic::ConnectionCloseBehavior::SILENT_CLOSE);
6450
6451 // A task will be posted to clean up the session in the factory.
6452 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
6453 task_runner->FastForwardUntilNoTasksRemain();
6454
6455 // No new session should be created as there is no alternate network.
6456 EXPECT_FALSE(HasActiveSession(host_port_pair_));
6457 EXPECT_FALSE(HasActiveJob(host_port_pair_, privacy_mode_));
6458 EXPECT_TRUE(socket_data.AllReadDataConsumed());
6459 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
6460 }
6461
TEST_P(QuicStreamFactoryTest,NewConnectionBeforeHandshakeAfterIdleTimeout)6462 TEST_P(QuicStreamFactoryTest, NewConnectionBeforeHandshakeAfterIdleTimeout) {
6463 TestNewConnectionOnAlternateNetworkBeforeHandshake(
6464 quic::QUIC_NETWORK_IDLE_TIMEOUT);
6465 }
6466
TEST_P(QuicStreamFactoryTest,NewConnectionAfterHandshakeTimeout)6467 TEST_P(QuicStreamFactoryTest, NewConnectionAfterHandshakeTimeout) {
6468 TestNewConnectionOnAlternateNetworkBeforeHandshake(
6469 quic::QUIC_HANDSHAKE_TIMEOUT);
6470 }
6471
6472 // Sets up a test to verify that a new connection will be created on the
6473 // alternate network after the initial connection fails before handshake with
6474 // signals delivered in the following order (alternate network is available):
6475 // - the default network is not able to complete crypto handshake;
6476 // - the original connection is closed with |quic_error|;
6477 // - a new connection is created on the alternate network and is able to finish
6478 // crypto handshake;
6479 // - the new session on the alternate network attempts to migrate back to the
6480 // default network by sending probes;
6481 // - default network being disconnected is delivered: session will stop probing
6482 // the original network.
6483 // - alternate network is made by default.
6484 void QuicStreamFactoryTestBase::
TestNewConnectionOnAlternateNetworkBeforeHandshake(quic::QuicErrorCode quic_error)6485 TestNewConnectionOnAlternateNetworkBeforeHandshake(
6486 quic::QuicErrorCode quic_error) {
6487 DCHECK(quic_error == quic::QUIC_NETWORK_IDLE_TIMEOUT ||
6488 quic_error == quic::QUIC_HANDSHAKE_TIMEOUT);
6489 quic_params_->retry_on_alternate_network_before_handshake = true;
6490 InitializeConnectionMigrationV2Test(
6491 {kDefaultNetworkForTests, kNewNetworkForTests});
6492
6493 // Using a testing task runner.
6494 auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
6495 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
6496
6497 // Use cold start mode to send crypto message for handshake.
6498 crypto_client_stream_factory_.set_handshake_mode(
6499 MockCryptoClientStream::COLD_START_WITH_CHLO_SENT);
6500
6501 // Socket data for connection on the default network.
6502 MockQuicData socket_data(version_);
6503 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
6504 socket_data.AddWrite(ASYNC, client_maker_.MakeDummyCHLOPacket(1));
6505 socket_data.AddSocketDataToFactory(socket_factory_.get());
6506
6507 // Socket data for connection on the alternate network.
6508 MockQuicData socket_data2(version_);
6509 int packet_num = 1;
6510 socket_data2.AddWrite(SYNCHRONOUS,
6511 client_maker_.MakeDummyCHLOPacket(packet_num++));
6512 socket_data2.AddRead(ASYNC, ERR_IO_PENDING); // Pause.
6513 // Change the encryption level after handshake is confirmed.
6514 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
6515 if (VersionUsesHttp3(version_.transport_version))
6516 socket_data2.AddWrite(ASYNC, ConstructInitialSettingsPacket(packet_num++));
6517 socket_data2.AddWrite(
6518 ASYNC, ConstructGetRequestPacket(
6519 packet_num++, GetNthClientInitiatedBidirectionalStreamId(0),
6520 true, true));
6521 socket_data2.AddRead(
6522 ASYNC,
6523 ConstructOkResponsePacket(
6524 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false));
6525 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
6526
6527 int probing_packet_num = packet_num++;
6528
6529 if (VersionUsesHttp3(version_.transport_version)) {
6530 socket_data2.AddWrite(
6531 SYNCHRONOUS, client_maker_.MakeAckAndDataPacket(
6532 packet_num++, false, GetQpackDecoderStreamId(), 1, 1,
6533 false, StreamCancellationQpackDecoderInstruction(0)));
6534 socket_data2.AddWrite(
6535 SYNCHRONOUS,
6536 client_maker_.MakeRstPacket(
6537 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
6538 quic::QUIC_STREAM_CANCELLED));
6539 } else {
6540 socket_data2.AddWrite(
6541 SYNCHRONOUS,
6542 client_maker_.MakeAckAndRstPacket(
6543 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
6544 quic::QUIC_STREAM_CANCELLED, 1, 1));
6545 }
6546 socket_data2.AddSocketDataToFactory(socket_factory_.get());
6547
6548 // Socket data for probing on the default network.
6549 MockQuicData probing_data(version_);
6550 probing_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read.
6551 probing_data.AddWrite(
6552 SYNCHRONOUS,
6553 client_maker_.MakeConnectivityProbingPacket(probing_packet_num, false));
6554 probing_data.AddSocketDataToFactory(socket_factory_.get());
6555
6556 // Create request and QuicHttpStream.
6557 QuicStreamRequest request(factory_.get());
6558 EXPECT_EQ(
6559 ERR_IO_PENDING,
6560 request.Request(
6561 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
6562 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
6563 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
6564 failed_on_default_network_callback_, callback_.callback()));
6565
6566 base::RunLoop().RunUntilIdle();
6567
6568 // Ensure that session is alive but not active.
6569 EXPECT_FALSE(HasActiveSession(host_port_pair_));
6570 EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_));
6571 QuicChromiumClientSession* session = GetPendingSession(host_port_pair_);
6572 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
6573 EXPECT_EQ(0u, task_runner->GetPendingTaskCount());
6574 EXPECT_FALSE(failed_on_default_network_);
6575
6576 std::string error_details;
6577 if (quic_error == quic::QUIC_NETWORK_IDLE_TIMEOUT) {
6578 error_details = "No recent network activity.";
6579 } else {
6580 error_details = "Handshake timeout expired.";
6581 }
6582 session->connection()->CloseConnection(
6583 quic_error, error_details, quic::ConnectionCloseBehavior::SILENT_CLOSE);
6584
6585 // A task will be posted to clean up the session in the factory.
6586 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
6587 task_runner->FastForwardUntilNoTasksRemain();
6588
6589 // Verify a new session is created on the alternate network.
6590 EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_));
6591 EXPECT_FALSE(HasActiveSession(host_port_pair_));
6592 QuicChromiumClientSession* session2 = GetPendingSession(host_port_pair_);
6593 EXPECT_NE(session, session2);
6594 EXPECT_TRUE(failed_on_default_network_);
6595
6596 // Confirm the handshake on the alternate network.
6597 crypto_client_stream_factory_.last_stream()
6598 ->NotifySessionOneRttKeyAvailable();
6599 EXPECT_THAT(callback_.WaitForResult(), IsOk());
6600 EXPECT_TRUE(HasActiveSession(host_port_pair_));
6601 // Resume the data now so that data can be sent and read.
6602 socket_data2.Resume();
6603
6604 // Create the stream.
6605 std::unique_ptr<HttpStream> stream = CreateStream(&request);
6606 EXPECT_TRUE(stream.get());
6607 HttpRequestInfo request_info;
6608 request_info.method = "GET";
6609 request_info.url = GURL("https://www.example.org/");
6610 request_info.traffic_annotation =
6611 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
6612 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
6613 net_log_, CompletionOnceCallback()));
6614 // Send the request.
6615 HttpResponseInfo response;
6616 HttpRequestHeaders request_headers;
6617 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
6618 callback_.callback()));
6619 // Run the message loop to finish asynchronous mock write.
6620 base::RunLoop().RunUntilIdle();
6621 // Read the response.
6622 EXPECT_EQ(OK, stream->ReadResponseHeaders(callback_.callback()));
6623 EXPECT_EQ(200, response.headers->response_code());
6624
6625 // There should be a new task posted to migrate back to the default network.
6626 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
6627 base::TimeDelta next_task_delay = task_runner->NextPendingTaskDelay();
6628 EXPECT_EQ(base::TimeDelta::FromSeconds(kMinRetryTimeForDefaultNetworkSecs),
6629 next_task_delay);
6630 task_runner->FastForwardBy(next_task_delay);
6631
6632 // There should be two tasks posted. One will retry probing and the other
6633 // will retry migrate back.
6634 EXPECT_EQ(2u, task_runner->GetPendingTaskCount());
6635 next_task_delay = task_runner->NextPendingTaskDelay();
6636 EXPECT_EQ(base::TimeDelta::FromMilliseconds(2 * kDefaultRTTMilliSecs),
6637 next_task_delay);
6638
6639 // Deliver the signal that the default network is disconnected.
6640 scoped_mock_network_change_notifier_->mock_network_change_notifier()
6641 ->NotifyNetworkDisconnected(kDefaultNetworkForTests);
6642 // Verify no connectivity probes will be sent as probing will be cancelled.
6643 task_runner->FastForwardUntilNoTasksRemain();
6644 // Deliver the signal that the alternate network is made default.
6645 scoped_mock_network_change_notifier_->mock_network_change_notifier()
6646 ->NotifyNetworkMadeDefault(kNewNetworkForTests);
6647 EXPECT_EQ(0u, task_runner->GetPendingTaskCount());
6648
6649 stream.reset();
6650 EXPECT_TRUE(socket_data.AllReadDataConsumed());
6651 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
6652 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
6653 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
6654 }
6655
6656 // Test that connection will be closed with PACKET_WRITE_ERROR if a write error
6657 // is triggered before handshake is confirmed and connection migration is turned
6658 // on.
TEST_P(QuicStreamFactoryTest,MigrationOnWriteErrorBeforeHandshakeConfirmed)6659 TEST_P(QuicStreamFactoryTest, MigrationOnWriteErrorBeforeHandshakeConfirmed) {
6660 DCHECK(!quic_params_->retry_on_alternate_network_before_handshake);
6661 InitializeConnectionMigrationV2Test(
6662 {kDefaultNetworkForTests, kNewNetworkForTests});
6663
6664 // Use unmocked crypto stream to do crypto connect.
6665 crypto_client_stream_factory_.set_handshake_mode(
6666 MockCryptoClientStream::COLD_START_WITH_CHLO_SENT);
6667
6668 MockQuicData socket_data(version_);
6669 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
6670 // Trigger PACKET_WRITE_ERROR when sending packets in crypto connect.
6671 socket_data.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE);
6672 socket_data.AddSocketDataToFactory(socket_factory_.get());
6673
6674 // Create request, should fail after the write of the CHLO fails.
6675 QuicStreamRequest request(factory_.get());
6676 EXPECT_EQ(
6677 ERR_IO_PENDING,
6678 request.Request(
6679 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
6680 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
6681 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
6682 failed_on_default_network_callback_, callback_.callback()));
6683 EXPECT_EQ(ERR_QUIC_HANDSHAKE_FAILED, callback_.WaitForResult());
6684 EXPECT_FALSE(HasActiveSession(host_port_pair_));
6685 EXPECT_FALSE(HasActiveJob(host_port_pair_, privacy_mode_));
6686
6687 // Verify new requests can be sent normally.
6688 crypto_client_stream_factory_.set_handshake_mode(
6689 MockCryptoClientStream::COLD_START);
6690 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
6691 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
6692 client_maker_.Reset();
6693 MockQuicData socket_data2(version_);
6694 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
6695 if (VersionUsesHttp3(version_.transport_version))
6696 socket_data2.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
6697 socket_data2.AddSocketDataToFactory(socket_factory_.get());
6698
6699 QuicStreamRequest request2(factory_.get());
6700 EXPECT_EQ(
6701 ERR_IO_PENDING,
6702 request2.Request(
6703 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
6704 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
6705 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
6706 failed_on_default_network_callback_, callback_.callback()));
6707 EXPECT_FALSE(HasActiveSession(host_port_pair_));
6708 EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_));
6709 // Run the message loop to complete host resolution.
6710 base::RunLoop().RunUntilIdle();
6711
6712 // Complete handshake. QuicStreamFactory::Job should complete and succeed.
6713 crypto_client_stream_factory_.last_stream()
6714 ->NotifySessionOneRttKeyAvailable();
6715 EXPECT_THAT(callback_.WaitForResult(), IsOk());
6716 EXPECT_TRUE(HasActiveSession(host_port_pair_));
6717 EXPECT_FALSE(HasActiveJob(host_port_pair_, privacy_mode_));
6718
6719 // Create QuicHttpStream.
6720 std::unique_ptr<HttpStream> stream = CreateStream(&request2);
6721 EXPECT_TRUE(stream.get());
6722 stream.reset();
6723 EXPECT_TRUE(socket_data.AllReadDataConsumed());
6724 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
6725 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
6726 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
6727 }
6728
6729 // Test that if the original connection is closed with QUIC_PACKET_WRITE_ERROR
6730 // before handshake is confirmed and new connection before handshake is turned
6731 // on, a new connection will be retried on the alternate network.
TEST_P(QuicStreamFactoryTest,RetryConnectionOnWriteErrorBeforeHandshakeConfirmed)6732 TEST_P(QuicStreamFactoryTest,
6733 RetryConnectionOnWriteErrorBeforeHandshakeConfirmed) {
6734 quic_params_->retry_on_alternate_network_before_handshake = true;
6735 InitializeConnectionMigrationV2Test(
6736 {kDefaultNetworkForTests, kNewNetworkForTests});
6737
6738 // Use unmocked crypto stream to do crypto connect.
6739 crypto_client_stream_factory_.set_handshake_mode(
6740 MockCryptoClientStream::COLD_START_WITH_CHLO_SENT);
6741
6742 // Socket data for connection on the default network.
6743 MockQuicData socket_data(version_);
6744 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
6745 // Trigger PACKET_WRITE_ERROR when sending packets in crypto connect.
6746 socket_data.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE);
6747 socket_data.AddSocketDataToFactory(socket_factory_.get());
6748
6749 // Socket data for connection on the alternate network.
6750 MockQuicData socket_data2(version_);
6751 int packet_num = 1;
6752 socket_data2.AddWrite(SYNCHRONOUS,
6753 client_maker_.MakeDummyCHLOPacket(packet_num++));
6754 socket_data2.AddRead(ASYNC, ERR_IO_PENDING); // Pause.
6755 // Change the encryption level after handshake is confirmed.
6756 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
6757 if (VersionUsesHttp3(version_.transport_version))
6758 socket_data2.AddWrite(ASYNC, ConstructInitialSettingsPacket(packet_num++));
6759 socket_data2.AddWrite(
6760 ASYNC, ConstructGetRequestPacket(
6761 packet_num++, GetNthClientInitiatedBidirectionalStreamId(0),
6762 true, true));
6763 socket_data2.AddRead(
6764 ASYNC,
6765 ConstructOkResponsePacket(
6766 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false));
6767 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
6768 if (VersionUsesHttp3(version_.transport_version)) {
6769 socket_data2.AddWrite(
6770 SYNCHRONOUS, client_maker_.MakeAckAndDataPacket(
6771 packet_num++, false, GetQpackDecoderStreamId(), 1, 1,
6772 false, StreamCancellationQpackDecoderInstruction(0)));
6773 socket_data2.AddWrite(
6774 SYNCHRONOUS,
6775 client_maker_.MakeRstPacket(
6776 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
6777 quic::QUIC_STREAM_CANCELLED));
6778 } else {
6779 socket_data2.AddWrite(
6780 SYNCHRONOUS,
6781 client_maker_.MakeAckAndRstPacket(
6782 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
6783 quic::QUIC_STREAM_CANCELLED, 1, 1));
6784 }
6785 socket_data2.AddSocketDataToFactory(socket_factory_.get());
6786
6787 // Create request, should fail after the write of the CHLO fails.
6788 QuicStreamRequest request(factory_.get());
6789 EXPECT_EQ(
6790 ERR_IO_PENDING,
6791 request.Request(
6792 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
6793 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
6794 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
6795 failed_on_default_network_callback_, callback_.callback()));
6796 // Ensure that the session is alive but not active.
6797 EXPECT_FALSE(HasActiveSession(host_port_pair_));
6798 EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_));
6799 base::RunLoop().RunUntilIdle();
6800 QuicChromiumClientSession* session = GetPendingSession(host_port_pair_);
6801 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
6802
6803 // Confirm the handshake on the alternate network.
6804 crypto_client_stream_factory_.last_stream()
6805 ->NotifySessionOneRttKeyAvailable();
6806 EXPECT_THAT(callback_.WaitForResult(), IsOk());
6807 EXPECT_TRUE(HasActiveSession(host_port_pair_));
6808
6809 // Resume the data now so that data can be sent and read.
6810 socket_data2.Resume();
6811
6812 // Create the stream.
6813 std::unique_ptr<HttpStream> stream = CreateStream(&request);
6814 EXPECT_TRUE(stream.get());
6815 HttpRequestInfo request_info;
6816 request_info.method = "GET";
6817 request_info.url = GURL("https://www.example.org/");
6818 request_info.traffic_annotation =
6819 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
6820 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
6821 net_log_, CompletionOnceCallback()));
6822 // Send the request.
6823 HttpResponseInfo response;
6824 HttpRequestHeaders request_headers;
6825 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
6826 callback_.callback()));
6827 // Run the message loop to finish asynchronous mock write.
6828 base::RunLoop().RunUntilIdle();
6829 // Read the response.
6830 EXPECT_EQ(OK, stream->ReadResponseHeaders(callback_.callback()));
6831 EXPECT_EQ(200, response.headers->response_code());
6832
6833 stream.reset();
6834 EXPECT_TRUE(socket_data.AllReadDataConsumed());
6835 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
6836 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
6837 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
6838 }
6839
TestMigrationOnWriteError(IoMode write_error_mode)6840 void QuicStreamFactoryTestBase::TestMigrationOnWriteError(
6841 IoMode write_error_mode) {
6842 InitializeConnectionMigrationV2Test(
6843 {kDefaultNetworkForTests, kNewNetworkForTests});
6844 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
6845 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
6846 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
6847
6848 auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
6849
6850 MockQuicData socket_data(version_);
6851 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
6852 int packet_num = 1;
6853 if (VersionUsesHttp3(version_.transport_version)) {
6854 socket_data.AddWrite(SYNCHRONOUS,
6855 ConstructInitialSettingsPacket(packet_num++));
6856 }
6857 socket_data.AddWrite(write_error_mode, ERR_ADDRESS_UNREACHABLE);
6858 socket_data.AddSocketDataToFactory(socket_factory_.get());
6859
6860 // Create request and QuicHttpStream.
6861 QuicStreamRequest request(factory_.get());
6862 EXPECT_EQ(
6863 ERR_IO_PENDING,
6864 request.Request(
6865 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
6866 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
6867 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
6868 failed_on_default_network_callback_, callback_.callback()));
6869 EXPECT_EQ(OK, callback_.WaitForResult());
6870 std::unique_ptr<HttpStream> stream = CreateStream(&request);
6871 EXPECT_TRUE(stream.get());
6872
6873 // Cause QUIC stream to be created.
6874 HttpRequestInfo request_info;
6875 request_info.method = "GET";
6876 request_info.url = GURL("https://www.example.org/");
6877 request_info.traffic_annotation =
6878 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
6879 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
6880 net_log_, CompletionOnceCallback()));
6881
6882 // Ensure that session is alive and active.
6883 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
6884 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
6885 EXPECT_TRUE(HasActiveSession(host_port_pair_));
6886
6887 // Set up second socket data provider that is used after
6888 // migration. The request is rewritten to this new socket, and the
6889 // response to the request is read on this new socket.
6890 MockQuicData socket_data1(version_);
6891 socket_data1.AddWrite(
6892 SYNCHRONOUS,
6893 ConstructGetRequestPacket(packet_num++,
6894 GetNthClientInitiatedBidirectionalStreamId(0),
6895 true, true));
6896 socket_data1.AddRead(
6897 ASYNC,
6898 ConstructOkResponsePacket(
6899 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false));
6900 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
6901 if (VersionUsesHttp3(version_.transport_version)) {
6902 socket_data1.AddWrite(
6903 SYNCHRONOUS, client_maker_.MakeAckAndDataPacket(
6904 packet_num++, false, GetQpackDecoderStreamId(), 1, 1,
6905 false, StreamCancellationQpackDecoderInstruction(0)));
6906 socket_data1.AddWrite(
6907 SYNCHRONOUS,
6908 client_maker_.MakeRstPacket(
6909 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
6910 quic::QUIC_STREAM_CANCELLED));
6911 } else {
6912 socket_data1.AddWrite(
6913 SYNCHRONOUS,
6914 client_maker_.MakeAckAndRstPacket(
6915 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
6916 quic::QUIC_STREAM_CANCELLED, 1, 1));
6917 }
6918 socket_data1.AddSocketDataToFactory(socket_factory_.get());
6919
6920 // Send GET request on stream. This should cause a write error, which triggers
6921 // a connection migration attempt.
6922 HttpResponseInfo response;
6923 HttpRequestHeaders request_headers;
6924 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
6925 callback_.callback()));
6926
6927 // Run the message loop so that the migration attempt is executed and
6928 // data queued in the new socket is read by the packet reader.
6929 base::RunLoop().RunUntilIdle();
6930
6931 // Verify that session is alive and not marked as going awya.
6932 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
6933 EXPECT_TRUE(HasActiveSession(host_port_pair_));
6934 EXPECT_EQ(1u, session->GetNumActiveStreams());
6935
6936 // Verify that response headers on the migrated socket were delivered to the
6937 // stream.
6938 EXPECT_EQ(OK, stream->ReadResponseHeaders(callback_.callback()));
6939 EXPECT_EQ(200, response.headers->response_code());
6940
6941 stream.reset();
6942
6943 EXPECT_TRUE(socket_data.AllReadDataConsumed());
6944 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
6945 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
6946 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
6947 }
6948
TEST_P(QuicStreamFactoryTest,MigrateSessionOnWriteErrorSynchronous)6949 TEST_P(QuicStreamFactoryTest, MigrateSessionOnWriteErrorSynchronous) {
6950 TestMigrationOnWriteError(SYNCHRONOUS);
6951 }
6952
TEST_P(QuicStreamFactoryTest,MigrateSessionOnWriteErrorAsync)6953 TEST_P(QuicStreamFactoryTest, MigrateSessionOnWriteErrorAsync) {
6954 TestMigrationOnWriteError(ASYNC);
6955 }
6956
TestMigrationOnWriteErrorNoNewNetwork(IoMode write_error_mode)6957 void QuicStreamFactoryTestBase::TestMigrationOnWriteErrorNoNewNetwork(
6958 IoMode write_error_mode) {
6959 InitializeConnectionMigrationV2Test({kDefaultNetworkForTests});
6960 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
6961 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
6962
6963 // Use the test task runner, to force the migration alarm timeout later.
6964 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), runner_.get());
6965
6966 MockQuicData socket_data(version_);
6967 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
6968 if (VersionUsesHttp3(version_.transport_version))
6969 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
6970 socket_data.AddWrite(write_error_mode, ERR_ADDRESS_UNREACHABLE);
6971 socket_data.AddSocketDataToFactory(socket_factory_.get());
6972
6973 // Create request and QuicHttpStream.
6974 QuicStreamRequest request(factory_.get());
6975 EXPECT_EQ(
6976 ERR_IO_PENDING,
6977 request.Request(
6978 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
6979 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
6980 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
6981 failed_on_default_network_callback_, callback_.callback()));
6982 EXPECT_EQ(OK, callback_.WaitForResult());
6983 std::unique_ptr<HttpStream> stream = CreateStream(&request);
6984 EXPECT_TRUE(stream.get());
6985
6986 // Cause QUIC stream to be created.
6987 HttpRequestInfo request_info;
6988 request_info.method = "GET";
6989 request_info.url = GURL("https://www.example.org/");
6990 request_info.traffic_annotation =
6991 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
6992 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
6993 net_log_, CompletionOnceCallback()));
6994
6995 // Ensure that session is alive and active.
6996 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
6997 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
6998 EXPECT_TRUE(HasActiveSession(host_port_pair_));
6999
7000 // Send GET request on stream. This causes a write error, which triggers
7001 // a connection migration attempt. Since there are no networks
7002 // to migrate to, this causes the session to wait for a new network.
7003 HttpResponseInfo response;
7004 HttpRequestHeaders request_headers;
7005 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
7006 callback_.callback()));
7007
7008 // Complete any pending writes. Pending async MockQuicData writes
7009 // are run on the message loop, not on the test runner.
7010 base::RunLoop().RunUntilIdle();
7011
7012 // Write error causes migration task to be posted. Spin the loop.
7013 if (write_error_mode == ASYNC)
7014 runner_->RunNextTask();
7015
7016 // Migration has not yet failed. The session should be alive and active.
7017 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
7018 EXPECT_TRUE(HasActiveSession(host_port_pair_));
7019 EXPECT_EQ(1u, session->GetNumActiveStreams());
7020 EXPECT_TRUE(session->connection()->writer()->IsWriteBlocked());
7021
7022 // The migration will not fail until the migration alarm timeout.
7023 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
7024 EXPECT_TRUE(HasActiveSession(host_port_pair_));
7025 EXPECT_EQ(1u, session->GetNumActiveStreams());
7026 EXPECT_EQ(ERR_IO_PENDING, stream->ReadResponseHeaders(callback_.callback()));
7027
7028 // Force migration alarm timeout to run.
7029 RunTestLoopUntilIdle();
7030
7031 // The connection should be closed. A request for response headers
7032 // should fail.
7033 EXPECT_FALSE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
7034 EXPECT_FALSE(HasActiveSession(host_port_pair_));
7035 EXPECT_EQ(ERR_NETWORK_CHANGED, callback_.WaitForResult());
7036 EXPECT_EQ(ERR_NETWORK_CHANGED,
7037 stream->ReadResponseHeaders(callback_.callback()));
7038
7039 NetErrorDetails error_details;
7040 stream->PopulateNetErrorDetails(&error_details);
7041 EXPECT_EQ(error_details.quic_connection_error,
7042 quic::QUIC_CONNECTION_MIGRATION_NO_NEW_NETWORK);
7043
7044 EXPECT_TRUE(socket_data.AllReadDataConsumed());
7045 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
7046 }
7047
TEST_P(QuicStreamFactoryTest,MigrateSessionOnWriteErrorNoNewNetworkSynchronous)7048 TEST_P(QuicStreamFactoryTest,
7049 MigrateSessionOnWriteErrorNoNewNetworkSynchronous) {
7050 TestMigrationOnWriteErrorNoNewNetwork(SYNCHRONOUS);
7051 }
7052
TEST_P(QuicStreamFactoryTest,MigrateSessionOnWriteErrorNoNewNetworkAsync)7053 TEST_P(QuicStreamFactoryTest, MigrateSessionOnWriteErrorNoNewNetworkAsync) {
7054 TestMigrationOnWriteErrorNoNewNetwork(ASYNC);
7055 }
7056
TEST_P(QuicStreamFactoryTest,MigrateSessionOnWriteErrorWithMultipleRequestsSync)7057 TEST_P(QuicStreamFactoryTest,
7058 MigrateSessionOnWriteErrorWithMultipleRequestsSync) {
7059 TestMigrationOnWriteErrorWithMultipleRequests(SYNCHRONOUS);
7060 }
7061
TEST_P(QuicStreamFactoryTest,MigrateSessionOnWriteErrorWithMultipleRequestsAsync)7062 TEST_P(QuicStreamFactoryTest,
7063 MigrateSessionOnWriteErrorWithMultipleRequestsAsync) {
7064 TestMigrationOnWriteErrorWithMultipleRequests(ASYNC);
7065 }
7066
7067 // Sets up a test which verifies that connection migration on write error can
7068 // eventually succeed and rewrite the packet on the new network with *multiple*
7069 // migratable streams.
TestMigrationOnWriteErrorWithMultipleRequests(IoMode write_error_mode)7070 void QuicStreamFactoryTestBase::TestMigrationOnWriteErrorWithMultipleRequests(
7071 IoMode write_error_mode) {
7072 InitializeConnectionMigrationV2Test(
7073 {kDefaultNetworkForTests, kNewNetworkForTests});
7074 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
7075 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
7076 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
7077
7078 MockQuicData socket_data(version_);
7079 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
7080 int packet_num = 1;
7081 if (VersionUsesHttp3(version_.transport_version)) {
7082 socket_data.AddWrite(SYNCHRONOUS,
7083 ConstructInitialSettingsPacket(packet_num++));
7084 }
7085 socket_data.AddWrite(write_error_mode, ERR_ADDRESS_UNREACHABLE);
7086 socket_data.AddSocketDataToFactory(socket_factory_.get());
7087
7088 // Set up second socket data provider that is used after
7089 // migration. The request is rewritten to this new socket, and the
7090 // response to the request is read on this new socket.
7091 MockQuicData socket_data1(version_);
7092 socket_data1.AddWrite(
7093 SYNCHRONOUS,
7094 ConstructGetRequestPacket(packet_num++,
7095 GetNthClientInitiatedBidirectionalStreamId(0),
7096 true, true));
7097 socket_data1.AddRead(
7098 ASYNC,
7099 ConstructOkResponsePacket(
7100 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false));
7101 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
7102 if (VersionUsesHttp3(version_.transport_version)) {
7103 socket_data1.AddWrite(
7104 SYNCHRONOUS, client_maker_.MakeAckAndDataPacket(
7105 packet_num++, false, GetQpackDecoderStreamId(), 1, 1,
7106 false, StreamCancellationQpackDecoderInstruction(0)));
7107 socket_data1.AddWrite(
7108 SYNCHRONOUS,
7109 client_maker_.MakeRstPacket(
7110 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
7111 quic::QUIC_STREAM_CANCELLED));
7112 } else {
7113 socket_data1.AddWrite(
7114 SYNCHRONOUS,
7115 client_maker_.MakeAckAndRstPacket(
7116 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
7117 quic::QUIC_STREAM_CANCELLED, 1, 1));
7118 }
7119
7120 if (VersionUsesHttp3(version_.transport_version)) {
7121 socket_data1.AddWrite(
7122 SYNCHRONOUS, client_maker_.MakeDataPacket(
7123 packet_num++, GetQpackDecoderStreamId(), true, false,
7124 StreamCancellationQpackDecoderInstruction(1, false)));
7125 }
7126 socket_data1.AddWrite(
7127 SYNCHRONOUS,
7128 client_maker_.MakeRstPacket(packet_num++, false,
7129 GetNthClientInitiatedBidirectionalStreamId(1),
7130 quic::QUIC_STREAM_CANCELLED,
7131 /*include_stop_sending_if_v99=*/true));
7132
7133 socket_data1.AddSocketDataToFactory(socket_factory_.get());
7134
7135 // Create request #1 and QuicHttpStream.
7136 QuicStreamRequest request1(factory_.get());
7137 EXPECT_EQ(
7138 ERR_IO_PENDING,
7139 request1.Request(
7140 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
7141 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
7142 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
7143 failed_on_default_network_callback_, callback_.callback()));
7144 EXPECT_THAT(callback_.WaitForResult(), IsOk());
7145 std::unique_ptr<HttpStream> stream1 = CreateStream(&request1);
7146 EXPECT_TRUE(stream1.get());
7147
7148 HttpRequestInfo request_info1;
7149 request_info1.method = "GET";
7150 request_info1.url = GURL("https://www.example.org/");
7151 request_info1.traffic_annotation =
7152 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
7153 EXPECT_EQ(OK,
7154 stream1->InitializeStream(&request_info1, true, DEFAULT_PRIORITY,
7155 net_log_, CompletionOnceCallback()));
7156
7157 // Second request returns synchronously because it pools to existing session.
7158 TestCompletionCallback callback2;
7159 QuicStreamRequest request2(factory_.get());
7160 EXPECT_EQ(
7161 OK,
7162 request2.Request(
7163 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
7164 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
7165 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
7166 failed_on_default_network_callback_, callback2.callback()));
7167 std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
7168 EXPECT_TRUE(stream2.get());
7169 HttpRequestInfo request_info2;
7170 request_info2.method = "GET";
7171 request_info2.url = GURL("https://www.example.org/");
7172 request_info2.traffic_annotation =
7173 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
7174 EXPECT_EQ(OK,
7175 stream2->InitializeStream(&request_info2, true, DEFAULT_PRIORITY,
7176 net_log_, CompletionOnceCallback()));
7177
7178 // Ensure that session is alive and active.
7179 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
7180 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
7181 EXPECT_TRUE(HasActiveSession(host_port_pair_));
7182 EXPECT_EQ(2u, session->GetNumActiveStreams());
7183
7184 // Send GET request on stream. This should cause a write error, which triggers
7185 // a connection migration attempt.
7186 HttpResponseInfo response;
7187 HttpRequestHeaders request_headers;
7188 EXPECT_EQ(OK, stream1->SendRequest(request_headers, &response,
7189 callback_.callback()));
7190
7191 // Run the message loop so that the migration attempt is executed and
7192 // data queued in the new socket is read by the packet reader.
7193 base::RunLoop().RunUntilIdle();
7194
7195 // Verify session is still alive and not marked as going away.
7196 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
7197 EXPECT_TRUE(HasActiveSession(host_port_pair_));
7198 EXPECT_EQ(2u, session->GetNumActiveStreams());
7199
7200 // Verify that response headers on the migrated socket were delivered to the
7201 // stream.
7202 EXPECT_EQ(OK, stream1->ReadResponseHeaders(callback_.callback()));
7203 EXPECT_EQ(200, response.headers->response_code());
7204
7205 stream1.reset();
7206 stream2.reset();
7207
7208 EXPECT_TRUE(socket_data.AllReadDataConsumed());
7209 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
7210 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
7211 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
7212 }
7213
TEST_P(QuicStreamFactoryTest,MigrateOnWriteErrorWithMixedRequestsSync)7214 TEST_P(QuicStreamFactoryTest, MigrateOnWriteErrorWithMixedRequestsSync) {
7215 TestMigrationOnWriteErrorMixedStreams(SYNCHRONOUS);
7216 }
7217
TEST_P(QuicStreamFactoryTest,MigrateOnWriteErrorWithMixedRequestsAsync)7218 TEST_P(QuicStreamFactoryTest, MigrateOnWriteErrorWithMixedRequestsAsync) {
7219 TestMigrationOnWriteErrorMixedStreams(ASYNC);
7220 }
7221
7222 // Sets up a test that verifies connection migration manages to migrate to
7223 // alternate network after encountering a SYNC/ASYNC write error based on
7224 // |write_error_mode| on the original network.
7225 // Note there are mixed types of unfinished requests before migration: one
7226 // migratable and one non-migratable. The *migratable* one triggers write
7227 // error.
TestMigrationOnWriteErrorMixedStreams(IoMode write_error_mode)7228 void QuicStreamFactoryTestBase::TestMigrationOnWriteErrorMixedStreams(
7229 IoMode write_error_mode) {
7230 InitializeConnectionMigrationV2Test(
7231 {kDefaultNetworkForTests, kNewNetworkForTests});
7232 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
7233 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
7234 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
7235
7236 int packet_number = 1;
7237 MockQuicData socket_data(version_);
7238
7239 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
7240 if (VersionUsesHttp3(version_.transport_version)) {
7241 socket_data.AddWrite(SYNCHRONOUS,
7242 ConstructInitialSettingsPacket(packet_number++));
7243 }
7244 socket_data.AddWrite(write_error_mode, ERR_ADDRESS_UNREACHABLE);
7245 socket_data.AddSocketDataToFactory(socket_factory_.get());
7246
7247 // Set up second socket data provider that is used after
7248 // migration. The request is rewritten to this new socket, and the
7249 // response to the request is read on this new socket.
7250 MockQuicData socket_data1(version_);
7251 socket_data1.AddWrite(
7252 SYNCHRONOUS,
7253 ConstructGetRequestPacket(packet_number++,
7254 GetNthClientInitiatedBidirectionalStreamId(0),
7255 true, true));
7256 if (VersionUsesHttp3(version_.transport_version)) {
7257 socket_data1.AddWrite(
7258 SYNCHRONOUS, client_maker_.MakeRstAndDataPacket(
7259 packet_number++, true,
7260 GetNthClientInitiatedBidirectionalStreamId(1),
7261 quic::QUIC_STREAM_CANCELLED, GetQpackDecoderStreamId(),
7262 StreamCancellationQpackDecoderInstruction(1)));
7263 } else {
7264 socket_data1.AddWrite(SYNCHRONOUS,
7265 client_maker_.MakeRstPacket(
7266 packet_number++, true,
7267 GetNthClientInitiatedBidirectionalStreamId(1),
7268 quic::QUIC_STREAM_CANCELLED,
7269 /*include_stop_sending_if_v99=*/true));
7270 }
7271 socket_data1.AddRead(
7272 ASYNC,
7273 ConstructOkResponsePacket(
7274 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false));
7275 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
7276 if (VersionUsesHttp3(version_.transport_version)) {
7277 socket_data1.AddWrite(
7278 SYNCHRONOUS,
7279 client_maker_.MakeAckAndDataPacket(
7280 packet_number++, false, GetQpackDecoderStreamId(), 1, 1, false,
7281 StreamCancellationQpackDecoderInstruction(0, false)));
7282 socket_data1.AddWrite(SYNCHRONOUS,
7283 client_maker_.MakeRstPacket(
7284 packet_number++, false,
7285 GetNthClientInitiatedBidirectionalStreamId(0),
7286 quic::QUIC_STREAM_CANCELLED));
7287 } else {
7288 socket_data1.AddWrite(SYNCHRONOUS,
7289 client_maker_.MakeAckAndRstPacket(
7290 packet_number++, false,
7291 GetNthClientInitiatedBidirectionalStreamId(0),
7292 quic::QUIC_STREAM_CANCELLED, 1, 1));
7293 }
7294 socket_data1.AddSocketDataToFactory(socket_factory_.get());
7295
7296 // Create request #1 and QuicHttpStream.
7297 QuicStreamRequest request1(factory_.get());
7298 EXPECT_EQ(
7299 ERR_IO_PENDING,
7300 request1.Request(
7301 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
7302 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
7303 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
7304 failed_on_default_network_callback_, callback_.callback()));
7305 EXPECT_THAT(callback_.WaitForResult(), IsOk());
7306 std::unique_ptr<HttpStream> stream1 = CreateStream(&request1);
7307 EXPECT_TRUE(stream1.get());
7308
7309 HttpRequestInfo request_info1;
7310 request_info1.method = "GET";
7311 request_info1.url = GURL("https://www.example.org/");
7312 request_info1.traffic_annotation =
7313 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
7314 EXPECT_EQ(OK,
7315 stream1->InitializeStream(&request_info1, true, DEFAULT_PRIORITY,
7316 net_log_, CompletionOnceCallback()));
7317
7318 // Second request returns synchronously because it pools to existing session.
7319 TestCompletionCallback callback2;
7320 QuicStreamRequest request2(factory_.get());
7321 EXPECT_EQ(
7322 OK,
7323 request2.Request(
7324 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
7325 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
7326 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
7327 failed_on_default_network_callback_, callback2.callback()));
7328 std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
7329 EXPECT_TRUE(stream2.get());
7330
7331 HttpRequestInfo request_info2;
7332 request_info2.method = "GET";
7333 request_info2.load_flags |= LOAD_DISABLE_CONNECTION_MIGRATION_TO_CELLULAR;
7334 request_info2.url = GURL("https://www.example.org/");
7335 request_info2.traffic_annotation =
7336 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
7337 EXPECT_EQ(OK,
7338 stream2->InitializeStream(&request_info2, true, DEFAULT_PRIORITY,
7339 net_log_, CompletionOnceCallback()));
7340
7341 // Ensure that session is alive and active.
7342 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
7343 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
7344 EXPECT_TRUE(HasActiveSession(host_port_pair_));
7345 EXPECT_EQ(2u, session->GetNumActiveStreams());
7346
7347 // Send GET request on stream 1. This should cause a write error, which
7348 // triggers a connection migration attempt.
7349 HttpResponseInfo response;
7350 HttpRequestHeaders request_headers;
7351 EXPECT_EQ(OK, stream1->SendRequest(request_headers, &response,
7352 callback_.callback()));
7353
7354 // Run the message loop so that the migration attempt is executed and
7355 // data queued in the new socket is read by the packet reader.
7356 base::RunLoop().RunUntilIdle();
7357
7358 // Verify that the session is still alive and not marked as going away.
7359 // Non-migratable stream should be closed due to migration.
7360 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
7361 EXPECT_TRUE(HasActiveSession(host_port_pair_));
7362 EXPECT_EQ(1u, session->GetNumActiveStreams());
7363
7364 // Verify that response headers on the migrated socket were delivered to the
7365 // stream.
7366 EXPECT_EQ(OK, stream1->ReadResponseHeaders(callback_.callback()));
7367 EXPECT_EQ(200, response.headers->response_code());
7368
7369 stream1.reset();
7370
7371 EXPECT_TRUE(socket_data.AllReadDataConsumed());
7372 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
7373 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
7374 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
7375 }
7376
TEST_P(QuicStreamFactoryTest,MigrateOnWriteErrorWithMixedRequests2Sync)7377 TEST_P(QuicStreamFactoryTest, MigrateOnWriteErrorWithMixedRequests2Sync) {
7378 TestMigrationOnWriteErrorMixedStreams2(SYNCHRONOUS);
7379 }
7380
TEST_P(QuicStreamFactoryTest,MigrateOnWriteErrorWithMixedRequests2Async)7381 TEST_P(QuicStreamFactoryTest, MigrateOnWriteErrorWithMixedRequests2Async) {
7382 TestMigrationOnWriteErrorMixedStreams2(ASYNC);
7383 }
7384
7385 // The one triggers write error is a non-migratable stream.
7386 // Sets up a test that verifies connection migration manages to migrate to
7387 // alternate network after encountering a SYNC/ASYNC write error based on
7388 // |write_error_mode| on the original network.
7389 // Note there are mixed types of unfinished requests before migration: one
7390 // migratable and one non-migratable. The *non-migratable* one triggers write
7391 // error.
TestMigrationOnWriteErrorMixedStreams2(IoMode write_error_mode)7392 void QuicStreamFactoryTestBase::TestMigrationOnWriteErrorMixedStreams2(
7393 IoMode write_error_mode) {
7394 InitializeConnectionMigrationV2Test(
7395 {kDefaultNetworkForTests, kNewNetworkForTests});
7396 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
7397 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
7398 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
7399
7400 int packet_number = 1;
7401 MockQuicData socket_data(version_);
7402 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
7403 if (VersionUsesHttp3(version_.transport_version)) {
7404 socket_data.AddWrite(SYNCHRONOUS,
7405 ConstructInitialSettingsPacket(packet_number++));
7406 }
7407 socket_data.AddWrite(write_error_mode,
7408 ERR_ADDRESS_UNREACHABLE); // Write error.
7409 socket_data.AddSocketDataToFactory(socket_factory_.get());
7410
7411 // Set up second socket data provider that is used after
7412 // migration. The request is rewritten to this new socket, and the
7413 // response to the request is read on this new socket.
7414 MockQuicData socket_data1(version_);
7415 // The packet triggered writer error will be sent anyway even if the stream
7416 // will be cancelled later.
7417 socket_data1.AddWrite(
7418 SYNCHRONOUS,
7419 ConstructGetRequestPacket(packet_number++,
7420 GetNthClientInitiatedBidirectionalStreamId(1),
7421 true, true));
7422 if (VersionUsesHttp3(version_.transport_version)) {
7423 socket_data1.AddWrite(
7424 SYNCHRONOUS, client_maker_.MakeRstAndDataPacket(
7425 packet_number++, true,
7426 GetNthClientInitiatedBidirectionalStreamId(1),
7427 quic::QUIC_STREAM_CANCELLED, GetQpackDecoderStreamId(),
7428 StreamCancellationQpackDecoderInstruction(1)));
7429 } else {
7430 socket_data1.AddWrite(SYNCHRONOUS,
7431 client_maker_.MakeRstPacket(
7432 packet_number++, true,
7433 GetNthClientInitiatedBidirectionalStreamId(1),
7434 quic::QUIC_STREAM_CANCELLED,
7435 /*include_stop_sending_if_v99=*/true));
7436 }
7437 socket_data1.AddWrite(
7438 SYNCHRONOUS,
7439 ConstructGetRequestPacket(packet_number++,
7440 GetNthClientInitiatedBidirectionalStreamId(0),
7441 true, true));
7442 socket_data1.AddRead(
7443 ASYNC,
7444 ConstructOkResponsePacket(
7445 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false));
7446 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
7447 if (VersionUsesHttp3(version_.transport_version)) {
7448 socket_data1.AddWrite(
7449 SYNCHRONOUS,
7450 client_maker_.MakeAckAndDataPacket(
7451 packet_number++, false, GetQpackDecoderStreamId(), 1, 1, false,
7452 StreamCancellationQpackDecoderInstruction(0, false)));
7453 socket_data1.AddWrite(SYNCHRONOUS,
7454 client_maker_.MakeRstPacket(
7455 packet_number++, false,
7456 GetNthClientInitiatedBidirectionalStreamId(0),
7457 quic::QUIC_STREAM_CANCELLED));
7458 } else {
7459 socket_data1.AddWrite(SYNCHRONOUS,
7460 client_maker_.MakeAckAndRstPacket(
7461 packet_number++, false,
7462 GetNthClientInitiatedBidirectionalStreamId(0),
7463 quic::QUIC_STREAM_CANCELLED, 1, 1));
7464 }
7465 socket_data1.AddSocketDataToFactory(socket_factory_.get());
7466
7467 // Create request #1 and QuicHttpStream.
7468 QuicStreamRequest request1(factory_.get());
7469 EXPECT_EQ(
7470 ERR_IO_PENDING,
7471 request1.Request(
7472 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
7473 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
7474 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
7475 failed_on_default_network_callback_, callback_.callback()));
7476 EXPECT_THAT(callback_.WaitForResult(), IsOk());
7477 std::unique_ptr<HttpStream> stream1 = CreateStream(&request1);
7478 EXPECT_TRUE(stream1.get());
7479
7480 HttpRequestInfo request_info1;
7481 request_info1.method = "GET";
7482 request_info1.url = GURL("https://www.example.org/");
7483 request_info1.traffic_annotation =
7484 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
7485 EXPECT_EQ(OK,
7486 stream1->InitializeStream(&request_info1, true, DEFAULT_PRIORITY,
7487 net_log_, CompletionOnceCallback()));
7488
7489 // Second request returns synchronously because it pools to existing session.
7490 TestCompletionCallback callback2;
7491 QuicStreamRequest request2(factory_.get());
7492 EXPECT_EQ(
7493 OK,
7494 request2.Request(
7495 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
7496 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
7497 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
7498 failed_on_default_network_callback_, callback2.callback()));
7499 std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
7500 EXPECT_TRUE(stream2.get());
7501
7502 HttpRequestInfo request_info2;
7503 request_info2.method = "GET";
7504 request_info2.load_flags |= LOAD_DISABLE_CONNECTION_MIGRATION_TO_CELLULAR;
7505 request_info2.url = GURL("https://www.example.org/");
7506 request_info2.traffic_annotation =
7507 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
7508 EXPECT_EQ(OK,
7509 stream2->InitializeStream(&request_info2, true, DEFAULT_PRIORITY,
7510 net_log_, CompletionOnceCallback()));
7511
7512 // Ensure that session is alive and active.
7513 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
7514 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
7515 EXPECT_TRUE(HasActiveSession(host_port_pair_));
7516 EXPECT_EQ(2u, session->GetNumActiveStreams());
7517
7518 // Send GET request on stream 2 which is non-migratable. This should cause a
7519 // write error, which triggers a connection migration attempt.
7520 HttpResponseInfo response2;
7521 HttpRequestHeaders request_headers2;
7522 EXPECT_EQ(OK, stream2->SendRequest(request_headers2, &response2,
7523 callback2.callback()));
7524
7525 // Run the message loop so that the migration attempt is executed and
7526 // data queued in the new socket is read by the packet reader. Session is
7527 // still alive and not marked as going away, non-migratable stream will be
7528 // closed.
7529 base::RunLoop().RunUntilIdle();
7530 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
7531 EXPECT_TRUE(HasActiveSession(host_port_pair_));
7532 EXPECT_EQ(1u, session->GetNumActiveStreams());
7533
7534 // Send GET request on stream 1.
7535 HttpResponseInfo response;
7536 HttpRequestHeaders request_headers;
7537 EXPECT_EQ(OK, stream1->SendRequest(request_headers, &response,
7538 callback_.callback()));
7539
7540 base::RunLoop().RunUntilIdle();
7541
7542 // Verify that response headers on the migrated socket were delivered to the
7543 // stream.
7544 EXPECT_EQ(OK, stream1->ReadResponseHeaders(callback_.callback()));
7545 EXPECT_EQ(200, response.headers->response_code());
7546
7547 stream1.reset();
7548
7549 EXPECT_TRUE(socket_data.AllReadDataConsumed());
7550 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
7551 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
7552 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
7553 }
7554
7555 // This test verifies that when a connection encounters a packet write error, it
7556 // will cancel non-migratable streams, and migrate to the alternate network.
TestMigrationOnWriteErrorNonMigratableStream(IoMode write_error_mode,bool migrate_idle_sessions)7557 void QuicStreamFactoryTestBase::TestMigrationOnWriteErrorNonMigratableStream(
7558 IoMode write_error_mode,
7559 bool migrate_idle_sessions) {
7560 DVLOG(1) << "Write error mode: "
7561 << ((write_error_mode == SYNCHRONOUS) ? "SYNCHRONOUS" : "ASYNC");
7562 DVLOG(1) << "Migrate idle sessions: " << migrate_idle_sessions;
7563 quic_params_->migrate_idle_sessions = migrate_idle_sessions;
7564 InitializeConnectionMigrationV2Test(
7565 {kDefaultNetworkForTests, kNewNetworkForTests});
7566 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
7567 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
7568
7569 MockQuicData failed_socket_data(version_);
7570 MockQuicData socket_data(version_);
7571 int packet_num = 1;
7572 if (migrate_idle_sessions) {
7573 // The socket data provider for the original socket before migration.
7574 failed_socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
7575 if (VersionUsesHttp3(version_.transport_version)) {
7576 failed_socket_data.AddWrite(SYNCHRONOUS,
7577 ConstructInitialSettingsPacket(packet_num++));
7578 }
7579 failed_socket_data.AddWrite(write_error_mode, ERR_ADDRESS_UNREACHABLE);
7580 failed_socket_data.AddSocketDataToFactory(socket_factory_.get());
7581
7582 // Set up second socket data provider that is used after migration.
7583 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read.
7584 // Although the write error occurs when writing a packet for the
7585 // non-migratable stream and the stream will be cancelled during migration,
7586 // the packet will still be retransimitted at the connection level.
7587 socket_data.AddWrite(
7588 SYNCHRONOUS,
7589 ConstructGetRequestPacket(packet_num++,
7590 GetNthClientInitiatedBidirectionalStreamId(0),
7591 true, true));
7592 // A RESET will be sent to the peer to cancel the non-migratable stream.
7593 if (VersionUsesHttp3(version_.transport_version)) {
7594 socket_data.AddWrite(
7595 SYNCHRONOUS,
7596 client_maker_.MakeRstAndDataPacket(
7597 packet_num++, true, GetNthClientInitiatedBidirectionalStreamId(0),
7598 quic::QUIC_STREAM_CANCELLED, GetQpackDecoderStreamId(),
7599 StreamCancellationQpackDecoderInstruction(0)));
7600 } else {
7601 socket_data.AddWrite(
7602 SYNCHRONOUS,
7603 client_maker_.MakeRstPacket(
7604 packet_num++, true, GetNthClientInitiatedBidirectionalStreamId(0),
7605 quic::QUIC_STREAM_CANCELLED));
7606 }
7607 socket_data.AddSocketDataToFactory(socket_factory_.get());
7608 } else {
7609 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
7610 if (VersionUsesHttp3(version_.transport_version))
7611 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
7612 socket_data.AddWrite(write_error_mode, ERR_ADDRESS_UNREACHABLE);
7613 socket_data.AddSocketDataToFactory(socket_factory_.get());
7614 }
7615
7616 // Create request and QuicHttpStream.
7617 QuicStreamRequest request(factory_.get());
7618 EXPECT_EQ(
7619 ERR_IO_PENDING,
7620 request.Request(
7621 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
7622 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
7623 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
7624 failed_on_default_network_callback_, callback_.callback()));
7625 EXPECT_EQ(OK, callback_.WaitForResult());
7626 std::unique_ptr<HttpStream> stream = CreateStream(&request);
7627 EXPECT_TRUE(stream.get());
7628
7629 // Cause QUIC stream to be created, but marked as non-migratable.
7630 HttpRequestInfo request_info;
7631 request_info.load_flags |= LOAD_DISABLE_CONNECTION_MIGRATION_TO_CELLULAR;
7632 request_info.method = "GET";
7633 request_info.url = GURL("https://www.example.org/");
7634 request_info.traffic_annotation =
7635 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
7636 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
7637 net_log_, CompletionOnceCallback()));
7638
7639 // Ensure that session is alive and active.
7640 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
7641 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
7642 EXPECT_TRUE(HasActiveSession(host_port_pair_));
7643
7644 // Send GET request on stream. This should cause a write error, which triggers
7645 // a connection migration attempt.
7646 HttpResponseInfo response;
7647 HttpRequestHeaders request_headers;
7648 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
7649 callback_.callback()));
7650
7651 // Run message loop to execute migration attempt.
7652 base::RunLoop().RunUntilIdle();
7653
7654 // Migration closes the non-migratable stream and:
7655 // if migrate idle session is enabled, it migrates to the alternate network
7656 // successfully; otherwise the connection is closed.
7657 EXPECT_EQ(migrate_idle_sessions,
7658 QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
7659 EXPECT_EQ(migrate_idle_sessions, HasActiveSession(host_port_pair_));
7660
7661 if (migrate_idle_sessions) {
7662 EXPECT_TRUE(failed_socket_data.AllReadDataConsumed());
7663 EXPECT_TRUE(failed_socket_data.AllWriteDataConsumed());
7664 }
7665 EXPECT_TRUE(socket_data.AllReadDataConsumed());
7666 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
7667 }
7668
TEST_P(QuicStreamFactoryTest,MigrateSessionOnWriteErrorNonMigratableStreamSync_DoNotMigrateIdleSessions)7669 TEST_P(
7670 QuicStreamFactoryTest,
7671 MigrateSessionOnWriteErrorNonMigratableStreamSync_DoNotMigrateIdleSessions) {
7672 TestMigrationOnWriteErrorNonMigratableStream(SYNCHRONOUS, false);
7673 }
7674
TEST_P(QuicStreamFactoryTest,MigrateSessionOnWriteErrorNonMigratableStreamAsync_DoNotMigrateIdleSessions)7675 TEST_P(
7676 QuicStreamFactoryTest,
7677 MigrateSessionOnWriteErrorNonMigratableStreamAsync_DoNotMigrateIdleSessions) {
7678 TestMigrationOnWriteErrorNonMigratableStream(ASYNC, false);
7679 }
7680
TEST_P(QuicStreamFactoryTest,MigrateSessionOnWriteErrorNonMigratableStreamSync_MigrateIdleSessions)7681 TEST_P(QuicStreamFactoryTest,
7682 MigrateSessionOnWriteErrorNonMigratableStreamSync_MigrateIdleSessions) {
7683 TestMigrationOnWriteErrorNonMigratableStream(SYNCHRONOUS, true);
7684 }
7685
TEST_P(QuicStreamFactoryTest,MigrateSessionOnWriteErrorNonMigratableStreamAsync_MigrateIdleSessions)7686 TEST_P(QuicStreamFactoryTest,
7687 MigrateSessionOnWriteErrorNonMigratableStreamAsync_MigrateIdleSessions) {
7688 TestMigrationOnWriteErrorNonMigratableStream(ASYNC, true);
7689 }
7690
TestMigrationOnWriteErrorMigrationDisabled(IoMode write_error_mode)7691 void QuicStreamFactoryTestBase::TestMigrationOnWriteErrorMigrationDisabled(
7692 IoMode write_error_mode) {
7693 InitializeConnectionMigrationV2Test(
7694 {kDefaultNetworkForTests, kNewNetworkForTests});
7695 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
7696 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
7697
7698 MockQuicData socket_data(version_);
7699 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
7700 if (VersionUsesHttp3(version_.transport_version))
7701 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
7702 socket_data.AddWrite(write_error_mode, ERR_ADDRESS_UNREACHABLE);
7703 socket_data.AddSocketDataToFactory(socket_factory_.get());
7704
7705 // Create request and QuicHttpStream.
7706 QuicStreamRequest request(factory_.get());
7707 EXPECT_EQ(
7708 ERR_IO_PENDING,
7709 request.Request(
7710 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
7711 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
7712 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
7713 failed_on_default_network_callback_, callback_.callback()));
7714 EXPECT_EQ(OK, callback_.WaitForResult());
7715 std::unique_ptr<HttpStream> stream = CreateStream(&request);
7716 EXPECT_TRUE(stream.get());
7717
7718 // Cause QUIC stream to be created.
7719 HttpRequestInfo request_info;
7720 request_info.method = "GET";
7721 request_info.url = GURL("https://www.example.org/");
7722 request_info.traffic_annotation =
7723 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
7724 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
7725 net_log_, CompletionOnceCallback()));
7726
7727 // Ensure that session is alive and active.
7728 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
7729 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
7730 EXPECT_TRUE(HasActiveSession(host_port_pair_));
7731
7732 // Set session config to have connection migration disabled.
7733 quic::test::QuicConfigPeer::SetReceivedDisableConnectionMigration(
7734 session->config());
7735 EXPECT_TRUE(session->config()->DisableConnectionMigration());
7736
7737 // Send GET request on stream. This should cause a write error, which triggers
7738 // a connection migration attempt.
7739 HttpResponseInfo response;
7740 HttpRequestHeaders request_headers;
7741 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
7742 callback_.callback()));
7743 // Run message loop to execute migration attempt.
7744 base::RunLoop().RunUntilIdle();
7745 // Migration fails, and session is closed and deleted.
7746 EXPECT_FALSE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
7747 EXPECT_FALSE(HasActiveSession(host_port_pair_));
7748 EXPECT_TRUE(socket_data.AllReadDataConsumed());
7749 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
7750 }
7751
TEST_P(QuicStreamFactoryTest,MigrateSessionOnWriteErrorMigrationDisabledSynchronous)7752 TEST_P(QuicStreamFactoryTest,
7753 MigrateSessionOnWriteErrorMigrationDisabledSynchronous) {
7754 TestMigrationOnWriteErrorMigrationDisabled(SYNCHRONOUS);
7755 }
7756
TEST_P(QuicStreamFactoryTest,MigrateSessionOnWriteErrorMigrationDisabledAsync)7757 TEST_P(QuicStreamFactoryTest,
7758 MigrateSessionOnWriteErrorMigrationDisabledAsync) {
7759 TestMigrationOnWriteErrorMigrationDisabled(ASYNC);
7760 }
7761
7762 // Sets up a test which verifies that connection migration on write error can
7763 // eventually succeed and rewrite the packet on the new network with singals
7764 // delivered in the following order (alternate network is always availabe):
7765 // - original network encounters a SYNC/ASYNC write error based on
7766 // |write_error_mode_on_old_network|, the packet failed to be written is
7767 // cached, session migrates immediately to the alternate network.
7768 // - an immediate SYNC/ASYNC write error based on
7769 // |write_error_mode_on_new_network| is encountered after migration to the
7770 // alternate network, session migrates immediately to the original network.
7771 // - an immediate SYNC/ASYNC write error based on
7772 // |write_error_mode_on_old_network| is encountered after migration to the
7773 // original network, session migrates immediately to the alternate network.
7774 // - finally, session successfully sends the packet and reads the response on
7775 // the alternate network.
7776 // TODO(zhongyi): once https://crbug.com/855666 is fixed, this test should be
7777 // modified to test that session is closed early if hopping between networks
7778 // with consecutive write errors is detected.
TestMigrationOnMultipleWriteErrors(IoMode write_error_mode_on_old_network,IoMode write_error_mode_on_new_network)7779 void QuicStreamFactoryTestBase::TestMigrationOnMultipleWriteErrors(
7780 IoMode write_error_mode_on_old_network,
7781 IoMode write_error_mode_on_new_network) {
7782 InitializeConnectionMigrationV2Test(
7783 {kDefaultNetworkForTests, kNewNetworkForTests});
7784 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
7785 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
7786 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
7787
7788 // Set up the socket data used by the original network, which encounters a
7789 // write erorr.
7790 MockQuicData socket_data1(version_);
7791 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
7792 int packet_num = 1;
7793 if (VersionUsesHttp3(version_.transport_version)) {
7794 socket_data1.AddWrite(SYNCHRONOUS,
7795 ConstructInitialSettingsPacket(packet_num++));
7796 }
7797 socket_data1.AddWrite(write_error_mode_on_old_network,
7798 ERR_ADDRESS_UNREACHABLE); // Write Error
7799 socket_data1.AddSocketDataToFactory(socket_factory_.get());
7800
7801 // Set up the socket data used by the alternate network, which also
7802 // encounters a write error.
7803 MockQuicData failed_quic_data2(version_);
7804 failed_quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
7805 failed_quic_data2.AddWrite(write_error_mode_on_new_network, ERR_FAILED);
7806 failed_quic_data2.AddSocketDataToFactory(socket_factory_.get());
7807
7808 // Set up the third socket data used by original network, which encounters a
7809 // write error again.
7810 MockQuicData failed_quic_data1(version_);
7811 failed_quic_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
7812 failed_quic_data1.AddWrite(write_error_mode_on_old_network, ERR_FAILED);
7813 failed_quic_data1.AddSocketDataToFactory(socket_factory_.get());
7814
7815 // Set up the last socket data used by the alternate network, which will
7816 // finish migration successfully. The request is rewritten to this new socket,
7817 // and the response to the request is read on this socket.
7818 MockQuicData socket_data2(version_);
7819 socket_data2.AddWrite(
7820 SYNCHRONOUS,
7821 ConstructGetRequestPacket(packet_num++,
7822 GetNthClientInitiatedBidirectionalStreamId(0),
7823 true, true));
7824 socket_data2.AddRead(
7825 ASYNC,
7826 ConstructOkResponsePacket(
7827 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false));
7828 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
7829 if (VersionUsesHttp3(version_.transport_version)) {
7830 socket_data2.AddWrite(
7831 SYNCHRONOUS, client_maker_.MakeAckAndDataPacket(
7832 packet_num++, false, GetQpackDecoderStreamId(), 1, 1,
7833 false, StreamCancellationQpackDecoderInstruction(0)));
7834 socket_data2.AddWrite(
7835 SYNCHRONOUS,
7836 client_maker_.MakeRstPacket(
7837 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
7838 quic::QUIC_STREAM_CANCELLED));
7839 } else {
7840 socket_data2.AddWrite(
7841 SYNCHRONOUS,
7842 client_maker_.MakeAckAndRstPacket(
7843 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
7844 quic::QUIC_STREAM_CANCELLED, 1, 1));
7845 }
7846 socket_data2.AddSocketDataToFactory(socket_factory_.get());
7847
7848 // Create request and QuicHttpStream.
7849 QuicStreamRequest request(factory_.get());
7850 EXPECT_EQ(
7851 ERR_IO_PENDING,
7852 request.Request(
7853 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
7854 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
7855 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
7856 failed_on_default_network_callback_, callback_.callback()));
7857 EXPECT_EQ(OK, callback_.WaitForResult());
7858 std::unique_ptr<HttpStream> stream = CreateStream(&request);
7859 EXPECT_TRUE(stream.get());
7860
7861 // Cause QUIC stream to be created.
7862 HttpRequestInfo request_info;
7863 request_info.method = "GET";
7864 request_info.url = GURL("https://www.example.org/");
7865 request_info.traffic_annotation =
7866 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
7867 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
7868 net_log_, CompletionOnceCallback()));
7869
7870 // Ensure that session is alive and active.
7871 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
7872 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
7873 EXPECT_TRUE(HasActiveSession(host_port_pair_));
7874
7875 // Send GET request on stream.
7876 // This should encounter a write error on network 1,
7877 // then migrate to network 2, which encounters another write error,
7878 // and migrate again to network 1, which encoutners one more write error.
7879 // Finally the session migrates to network 2 successfully.
7880 HttpResponseInfo response;
7881 HttpRequestHeaders request_headers;
7882 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
7883 callback_.callback()));
7884
7885 base::RunLoop().RunUntilIdle();
7886 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
7887 EXPECT_EQ(1u, session->GetNumActiveStreams());
7888
7889 // Verify that response headers on the migrated socket were delivered to the
7890 // stream.
7891 EXPECT_EQ(OK, stream->ReadResponseHeaders(callback_.callback()));
7892 EXPECT_EQ(200, response.headers->response_code());
7893
7894 stream.reset();
7895 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
7896 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
7897 EXPECT_TRUE(failed_quic_data2.AllReadDataConsumed());
7898 EXPECT_TRUE(failed_quic_data2.AllWriteDataConsumed());
7899 EXPECT_TRUE(failed_quic_data1.AllReadDataConsumed());
7900 EXPECT_TRUE(failed_quic_data1.AllWriteDataConsumed());
7901 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
7902 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
7903 }
7904
TEST_P(QuicStreamFactoryTest,MigrateSessionOnMultipleWriteErrorsSyncSync)7905 TEST_P(QuicStreamFactoryTest, MigrateSessionOnMultipleWriteErrorsSyncSync) {
7906 TestMigrationOnMultipleWriteErrors(
7907 /*write_error_mode_on_old_network*/ SYNCHRONOUS,
7908 /*write_error_mode_on_new_network*/ SYNCHRONOUS);
7909 }
7910
TEST_P(QuicStreamFactoryTest,MigrateSessionOnMultipleWriteErrorsSyncAsync)7911 TEST_P(QuicStreamFactoryTest, MigrateSessionOnMultipleWriteErrorsSyncAsync) {
7912 TestMigrationOnMultipleWriteErrors(
7913 /*write_error_mode_on_old_network*/ SYNCHRONOUS,
7914 /*write_error_mode_on_new_network*/ ASYNC);
7915 }
7916
TEST_P(QuicStreamFactoryTest,MigrateSessionOnMultipleWriteErrorsAsyncSync)7917 TEST_P(QuicStreamFactoryTest, MigrateSessionOnMultipleWriteErrorsAsyncSync) {
7918 TestMigrationOnMultipleWriteErrors(
7919 /*write_error_mode_on_old_network*/ ASYNC,
7920 /*write_error_mode_on_new_network*/ SYNCHRONOUS);
7921 }
7922
TEST_P(QuicStreamFactoryTest,MigrateSessionOnMultipleWriteErrorsAsyncAsync)7923 TEST_P(QuicStreamFactoryTest, MigrateSessionOnMultipleWriteErrorsAsyncAsync) {
7924 TestMigrationOnMultipleWriteErrors(
7925 /*write_error_mode_on_old_network*/ ASYNC,
7926 /*write_error_mode_on_new_network*/ ASYNC);
7927 }
7928
7929 // Verifies that a connection is closed when connection migration is triggered
7930 // on network being disconnected and the handshake is not confirmed.
TEST_P(QuicStreamFactoryTest,NoMigrationBeforeHandshakeOnNetworkDisconnected)7931 TEST_P(QuicStreamFactoryTest, NoMigrationBeforeHandshakeOnNetworkDisconnected) {
7932 InitializeConnectionMigrationV2Test(
7933 {kDefaultNetworkForTests, kNewNetworkForTests});
7934
7935 // Use cold start mode to do crypto connect, and send CHLO packet on wire.
7936 crypto_client_stream_factory_.set_handshake_mode(
7937 MockCryptoClientStream::COLD_START_WITH_CHLO_SENT);
7938
7939 MockQuicData socket_data(version_);
7940 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
7941 socket_data.AddWrite(ASYNC, client_maker_.MakeDummyCHLOPacket(1));
7942 socket_data.AddSocketDataToFactory(socket_factory_.get());
7943
7944 // Create request and QuicHttpStream.
7945 QuicStreamRequest request(factory_.get());
7946 EXPECT_EQ(
7947 ERR_IO_PENDING,
7948 request.Request(
7949 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
7950 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
7951 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
7952 failed_on_default_network_callback_, callback_.callback()));
7953 // Deliver the network notification, which should cause the connection to be
7954 // closed.
7955 scoped_mock_network_change_notifier_->mock_network_change_notifier()
7956 ->NotifyNetworkDisconnected(kDefaultNetworkForTests);
7957 EXPECT_EQ(ERR_NETWORK_CHANGED, callback_.WaitForResult());
7958
7959 EXPECT_FALSE(HasActiveSession(host_port_pair_));
7960 EXPECT_FALSE(HasActiveJob(host_port_pair_, privacy_mode_));
7961 EXPECT_TRUE(socket_data.AllReadDataConsumed());
7962 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
7963 }
7964
7965 // Sets up the connection migration test where network change notification is
7966 // queued BEFORE connection migration attempt on write error is posted.
7967 void QuicStreamFactoryTestBase::
TestMigrationOnNetworkNotificationWithWriteErrorQueuedLater(bool disconnected)7968 TestMigrationOnNetworkNotificationWithWriteErrorQueuedLater(
7969 bool disconnected) {
7970 InitializeConnectionMigrationV2Test(
7971 {kDefaultNetworkForTests, kNewNetworkForTests});
7972 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
7973 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
7974 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
7975
7976 MockQuicData socket_data(version_);
7977 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
7978 int packet_num = 1;
7979 if (VersionUsesHttp3(version_.transport_version)) {
7980 socket_data.AddWrite(SYNCHRONOUS,
7981 ConstructInitialSettingsPacket(packet_num++));
7982 }
7983 socket_data.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE);
7984 socket_data.AddSocketDataToFactory(socket_factory_.get());
7985
7986 // Create request and QuicHttpStream.
7987 QuicStreamRequest request(factory_.get());
7988 EXPECT_EQ(
7989 ERR_IO_PENDING,
7990 request.Request(
7991 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
7992 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
7993 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
7994 failed_on_default_network_callback_, callback_.callback()));
7995 EXPECT_EQ(OK, callback_.WaitForResult());
7996 std::unique_ptr<HttpStream> stream = CreateStream(&request);
7997 EXPECT_TRUE(stream.get());
7998
7999 // Cause QUIC stream to be created.
8000 HttpRequestInfo request_info;
8001 request_info.method = "GET";
8002 request_info.url = GURL("https://www.example.org/");
8003 request_info.traffic_annotation =
8004 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
8005 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
8006 net_log_, CompletionOnceCallback()));
8007
8008 // Ensure that session is alive and active.
8009 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
8010 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
8011 EXPECT_TRUE(HasActiveSession(host_port_pair_));
8012
8013 // Set up second socket data provider that is used after
8014 // migration. The request is rewritten to this new socket, and the
8015 // response to the request is read on this new socket.
8016 MockQuicData socket_data1(version_);
8017 socket_data1.AddWrite(
8018 SYNCHRONOUS,
8019 ConstructGetRequestPacket(packet_num++,
8020 GetNthClientInitiatedBidirectionalStreamId(0),
8021 true, true));
8022 socket_data1.AddRead(
8023 ASYNC,
8024 ConstructOkResponsePacket(
8025 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false));
8026 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
8027 if (VersionUsesHttp3(version_.transport_version)) {
8028 socket_data1.AddWrite(
8029 SYNCHRONOUS, client_maker_.MakeAckAndDataPacket(
8030 packet_num++, false, GetQpackDecoderStreamId(), 1, 1,
8031 false, StreamCancellationQpackDecoderInstruction(0)));
8032 socket_data1.AddWrite(
8033 SYNCHRONOUS,
8034 client_maker_.MakeRstPacket(
8035 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
8036 quic::QUIC_STREAM_CANCELLED));
8037 } else {
8038 socket_data1.AddWrite(
8039 SYNCHRONOUS,
8040 client_maker_.MakeAckAndRstPacket(
8041 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
8042 quic::QUIC_STREAM_CANCELLED, 1, 1));
8043 }
8044 socket_data1.AddSocketDataToFactory(socket_factory_.get());
8045
8046 // First queue a network change notification in the message loop.
8047 if (disconnected) {
8048 scoped_mock_network_change_notifier_->mock_network_change_notifier()
8049 ->QueueNetworkDisconnected(kDefaultNetworkForTests);
8050 } else {
8051 scoped_mock_network_change_notifier_->mock_network_change_notifier()
8052 ->QueueNetworkMadeDefault(kNewNetworkForTests);
8053 }
8054 // Send GET request on stream. This should cause a write error,
8055 // which triggers a connection migration attempt. This will queue a
8056 // migration attempt behind the notification in the message loop.
8057 HttpResponseInfo response;
8058 HttpRequestHeaders request_headers;
8059 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
8060 callback_.callback()));
8061
8062 base::RunLoop().RunUntilIdle();
8063 // Verify the session is still alive and not marked as going away post
8064 // migration.
8065 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
8066 EXPECT_TRUE(HasActiveSession(host_port_pair_));
8067 EXPECT_EQ(1u, session->GetNumActiveStreams());
8068
8069 // Verify that response headers on the migrated socket were delivered to the
8070 // stream.
8071 EXPECT_EQ(OK, stream->ReadResponseHeaders(callback_.callback()));
8072 EXPECT_EQ(200, response.headers->response_code());
8073
8074 stream.reset();
8075
8076 EXPECT_TRUE(socket_data.AllReadDataConsumed());
8077 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
8078 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
8079 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
8080 }
8081
8082 // This test verifies that session attempts connection migration successfully
8083 // with signals delivered in the following order (alternate network is always
8084 // available):
8085 // - a notification that default network is disconnected is queued.
8086 // - write error is triggered: session posts a task to attempt connection
8087 // migration, |migration_pending_| set to true.
8088 // - default network disconnected is delivered: session immediately migrates to
8089 // the alternate network, |migration_pending_| set to false.
8090 // - connection migration on write error attempt aborts: writer encountered
8091 // error is no longer in active use.
TEST_P(QuicStreamFactoryTest,MigrateOnNetworkDisconnectedWithWriteErrorQueuedLater)8092 TEST_P(QuicStreamFactoryTest,
8093 MigrateOnNetworkDisconnectedWithWriteErrorQueuedLater) {
8094 TestMigrationOnNetworkNotificationWithWriteErrorQueuedLater(
8095 /*disconnected=*/true);
8096 }
8097
8098 // This test verifies that session attempts connection migration successfully
8099 // with signals delivered in the following order (alternate network is always
8100 // available):
8101 // - a notification that alternate network is made default is queued.
8102 // - write error is triggered: session posts a task to attempt connection
8103 // migration, block future migrations.
8104 // - new default notification is delivered: migrate back timer spins and task is
8105 // posted to migrate to the new default network.
8106 // - connection migration on write error attempt proceeds successfully: session
8107 // is
8108 // marked as going away, future migrations unblocked.
8109 // - migrate back to default network task executed: session is already on the
8110 // default network, no-op.
TEST_P(QuicStreamFactoryTest,MigrateOnWriteErrorWithNetworkMadeDefaultQueuedEarlier)8111 TEST_P(QuicStreamFactoryTest,
8112 MigrateOnWriteErrorWithNetworkMadeDefaultQueuedEarlier) {
8113 TestMigrationOnNetworkNotificationWithWriteErrorQueuedLater(
8114 /*disconnected=*/false);
8115 }
8116
8117 // Sets up the connection migration test where network change notification is
8118 // queued AFTER connection migration attempt on write error is posted.
8119 void QuicStreamFactoryTestBase::
TestMigrationOnWriteErrorWithNotificationQueuedLater(bool disconnected)8120 TestMigrationOnWriteErrorWithNotificationQueuedLater(bool disconnected) {
8121 InitializeConnectionMigrationV2Test(
8122 {kDefaultNetworkForTests, kNewNetworkForTests});
8123 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
8124 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
8125 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
8126
8127 MockQuicData socket_data(version_);
8128 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
8129 int packet_num = 1;
8130 if (VersionUsesHttp3(version_.transport_version)) {
8131 socket_data.AddWrite(SYNCHRONOUS,
8132 ConstructInitialSettingsPacket(packet_num++));
8133 }
8134 socket_data.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE);
8135 socket_data.AddSocketDataToFactory(socket_factory_.get());
8136
8137 // Create request and QuicHttpStream.
8138 QuicStreamRequest request(factory_.get());
8139 EXPECT_EQ(
8140 ERR_IO_PENDING,
8141 request.Request(
8142 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
8143 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
8144 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
8145 failed_on_default_network_callback_, callback_.callback()));
8146 EXPECT_EQ(OK, callback_.WaitForResult());
8147 std::unique_ptr<HttpStream> stream = CreateStream(&request);
8148 EXPECT_TRUE(stream.get());
8149
8150 // Cause QUIC stream to be created.
8151 HttpRequestInfo request_info;
8152 request_info.method = "GET";
8153 request_info.url = GURL("https://www.example.org/");
8154 request_info.traffic_annotation =
8155 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
8156 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
8157 net_log_, CompletionOnceCallback()));
8158
8159 // Ensure that session is alive and active.
8160 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
8161 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
8162 EXPECT_TRUE(HasActiveSession(host_port_pair_));
8163
8164 // Set up second socket data provider that is used after
8165 // migration. The request is rewritten to this new socket, and the
8166 // response to the request is read on this new socket.
8167 MockQuicData socket_data1(version_);
8168 socket_data1.AddWrite(
8169 SYNCHRONOUS,
8170 ConstructGetRequestPacket(packet_num++,
8171 GetNthClientInitiatedBidirectionalStreamId(0),
8172 true, true));
8173 socket_data1.AddRead(
8174 ASYNC,
8175 ConstructOkResponsePacket(
8176 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false));
8177 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
8178 if (VersionUsesHttp3(version_.transport_version)) {
8179 socket_data1.AddWrite(
8180 SYNCHRONOUS, client_maker_.MakeAckAndDataPacket(
8181 packet_num++, false, GetQpackDecoderStreamId(), 1, 1,
8182 false, StreamCancellationQpackDecoderInstruction(0)));
8183 socket_data1.AddWrite(
8184 SYNCHRONOUS,
8185 client_maker_.MakeRstPacket(
8186 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
8187 quic::QUIC_STREAM_CANCELLED));
8188 } else {
8189 socket_data1.AddWrite(
8190 SYNCHRONOUS,
8191 client_maker_.MakeAckAndRstPacket(
8192 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
8193 quic::QUIC_STREAM_CANCELLED, 1, 1));
8194 }
8195 socket_data1.AddSocketDataToFactory(socket_factory_.get());
8196
8197 // Send GET request on stream. This should cause a write error,
8198 // which triggers a connection migration attempt. This will queue a
8199 // migration attempt in the message loop.
8200 HttpResponseInfo response;
8201 HttpRequestHeaders request_headers;
8202 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
8203 callback_.callback()));
8204
8205 // Now queue a network change notification in the message loop behind
8206 // the migration attempt.
8207 if (disconnected) {
8208 scoped_mock_network_change_notifier_->mock_network_change_notifier()
8209 ->QueueNetworkDisconnected(kDefaultNetworkForTests);
8210 } else {
8211 scoped_mock_network_change_notifier_->mock_network_change_notifier()
8212 ->QueueNetworkMadeDefault(kNewNetworkForTests);
8213 }
8214
8215 base::RunLoop().RunUntilIdle();
8216 // Verify session is still alive and not marked as going away.
8217 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
8218 EXPECT_TRUE(HasActiveSession(host_port_pair_));
8219 EXPECT_EQ(1u, session->GetNumActiveStreams());
8220
8221 // Verify that response headers on the migrated socket were delivered to the
8222 // stream.
8223 EXPECT_EQ(OK, stream->ReadResponseHeaders(callback_.callback()));
8224 EXPECT_EQ(200, response.headers->response_code());
8225
8226 stream.reset();
8227
8228 EXPECT_TRUE(socket_data.AllReadDataConsumed());
8229 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
8230 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
8231 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
8232 }
8233
8234 // This test verifies that session attempts connection migration successfully
8235 // with signals delivered in the following order (alternate network is always
8236 // available):
8237 // - write error is triggered: session posts a task to complete connection
8238 // migration.
8239 // - a notification that alternate network is made default is queued.
8240 // - connection migration attempt proceeds successfully, session is marked as
8241 // going away.
8242 // - new default notification is delivered after connection migration has been
8243 // completed.
TEST_P(QuicStreamFactoryTest,MigrateOnWriteErrorWithNetworkMadeDefaultQueuedLater)8244 TEST_P(QuicStreamFactoryTest,
8245 MigrateOnWriteErrorWithNetworkMadeDefaultQueuedLater) {
8246 TestMigrationOnWriteErrorWithNotificationQueuedLater(/*disconnected=*/false);
8247 }
8248
8249 // This test verifies that session attempts connection migration successfully
8250 // with signals delivered in the following order (alternate network is always
8251 // available):
8252 // - write error is triggered: session posts a task to complete connection
8253 // migration.
8254 // - a notification that default network is diconnected is queued.
8255 // - connection migration attempt proceeds successfully, session is marked as
8256 // going away.
8257 // - disconnect notification is delivered after connection migration has been
8258 // completed.
TEST_P(QuicStreamFactoryTest,MigrateOnWriteErrorWithNetworkDisconnectedQueuedLater)8259 TEST_P(QuicStreamFactoryTest,
8260 MigrateOnWriteErrorWithNetworkDisconnectedQueuedLater) {
8261 TestMigrationOnWriteErrorWithNotificationQueuedLater(/*disconnected=*/true);
8262 }
8263
8264 // This tests connection migration on write error with signals delivered in the
8265 // following order:
8266 // - a synchronous/asynchronous write error is triggered base on
8267 // |write_error_mode|: connection migration attempt is posted.
8268 // - old default network disconnects, migration waits for a new network.
8269 // - after a pause, new network is connected: session will migrate to new
8270 // network immediately.
8271 // - migration on writer error is exectued and aborts as writer passed in is no
8272 // longer active in use.
8273 // - new network is made default.
TestMigrationOnWriteErrorPauseBeforeConnected(IoMode write_error_mode)8274 void QuicStreamFactoryTestBase::TestMigrationOnWriteErrorPauseBeforeConnected(
8275 IoMode write_error_mode) {
8276 InitializeConnectionMigrationV2Test({kDefaultNetworkForTests});
8277 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
8278 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
8279 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
8280
8281 // Use the test task runner.
8282 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), runner_.get());
8283
8284 MockQuicData socket_data(version_);
8285 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read.
8286 int packet_num = 1;
8287 if (VersionUsesHttp3(version_.transport_version)) {
8288 socket_data.AddWrite(SYNCHRONOUS,
8289 ConstructInitialSettingsPacket(packet_num++));
8290 }
8291 socket_data.AddWrite(write_error_mode, ERR_FAILED);
8292 socket_data.AddSocketDataToFactory(socket_factory_.get());
8293
8294 // Create request and QuicHttpStream.
8295 QuicStreamRequest request(factory_.get());
8296 EXPECT_EQ(
8297 ERR_IO_PENDING,
8298 request.Request(
8299 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
8300 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
8301 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
8302 failed_on_default_network_callback_, callback_.callback()));
8303 EXPECT_THAT(callback_.WaitForResult(), IsOk());
8304 std::unique_ptr<HttpStream> stream = CreateStream(&request);
8305 EXPECT_TRUE(stream.get());
8306
8307 // Cause QUIC stream to be created.
8308 HttpRequestInfo request_info;
8309 request_info.method = "GET";
8310 request_info.url = url_;
8311 request_info.traffic_annotation =
8312 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
8313 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
8314 net_log_, CompletionOnceCallback()));
8315
8316 // Ensure that session is alive and active.
8317 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
8318 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
8319 EXPECT_TRUE(HasActiveSession(host_port_pair_));
8320
8321 // Send GET request on stream.
8322 HttpResponseInfo response;
8323 HttpRequestHeaders request_headers;
8324 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
8325 callback_.callback()));
8326
8327 // The connection should still be alive, not marked as going away.
8328 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
8329 EXPECT_TRUE(HasActiveSession(host_port_pair_));
8330 EXPECT_EQ(1u, session->GetNumActiveStreams());
8331 EXPECT_EQ(ERR_IO_PENDING, stream->ReadResponseHeaders(callback_.callback()));
8332
8333 // Set up second socket data provider that is used after migration.
8334 // The response to the earlier request is read on this new socket.
8335 MockQuicData socket_data1(version_);
8336 socket_data1.AddWrite(
8337 SYNCHRONOUS,
8338 ConstructGetRequestPacket(packet_num++,
8339 GetNthClientInitiatedBidirectionalStreamId(0),
8340 true, true));
8341 socket_data1.AddRead(
8342 ASYNC,
8343 ConstructOkResponsePacket(
8344 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false));
8345 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
8346 if (VersionUsesHttp3(version_.transport_version)) {
8347 socket_data1.AddWrite(
8348 SYNCHRONOUS, client_maker_.MakeAckAndDataPacket(
8349 packet_num++, false, GetQpackDecoderStreamId(), 1, 1,
8350 false, StreamCancellationQpackDecoderInstruction(0)));
8351 socket_data1.AddWrite(
8352 SYNCHRONOUS,
8353 client_maker_.MakeRstPacket(
8354 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
8355 quic::QUIC_STREAM_CANCELLED));
8356 } else {
8357 socket_data1.AddWrite(
8358 SYNCHRONOUS,
8359 client_maker_.MakeAckAndRstPacket(
8360 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
8361 quic::QUIC_STREAM_CANCELLED, 1, 1));
8362 }
8363 socket_data1.AddSocketDataToFactory(socket_factory_.get());
8364
8365 // On a DISCONNECTED notification, nothing happens.
8366 scoped_mock_network_change_notifier_->mock_network_change_notifier()
8367 ->NotifyNetworkDisconnected(kDefaultNetworkForTests);
8368 // Add a new network and notify the stream factory of a new connected network.
8369 // This causes a PING packet to be sent over the new network.
8370 scoped_mock_network_change_notifier_->mock_network_change_notifier()
8371 ->SetConnectedNetworksList({kNewNetworkForTests});
8372 scoped_mock_network_change_notifier_->mock_network_change_notifier()
8373 ->NotifyNetworkConnected(kNewNetworkForTests);
8374
8375 // Ensure that the session is still alive.
8376 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
8377 EXPECT_TRUE(HasActiveSession(host_port_pair_));
8378 EXPECT_EQ(1u, session->GetNumActiveStreams());
8379
8380 // Run the message loop migration for write error can finish.
8381 runner_->RunUntilIdle();
8382
8383 // Response headers are received over the new network.
8384 EXPECT_THAT(callback_.WaitForResult(), IsOk());
8385 EXPECT_EQ(200, response.headers->response_code());
8386
8387 // Check that the session is still alive.
8388 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
8389 EXPECT_TRUE(HasActiveSession(host_port_pair_));
8390
8391 // There should be no posted tasks not executed, no way to migrate back to
8392 // default network.
8393 EXPECT_TRUE(runner_->GetPostedTasks().empty());
8394
8395 // Receive signal to mark new network as default.
8396 scoped_mock_network_change_notifier_->mock_network_change_notifier()
8397 ->NotifyNetworkMadeDefault(kNewNetworkForTests);
8398
8399 stream.reset();
8400 EXPECT_TRUE(socket_data.AllReadDataConsumed());
8401 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
8402 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
8403 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
8404 }
8405
TEST_P(QuicStreamFactoryTest,MigrateSessionOnSyncWriteErrorPauseBeforeConnected)8406 TEST_P(QuicStreamFactoryTest,
8407 MigrateSessionOnSyncWriteErrorPauseBeforeConnected) {
8408 TestMigrationOnWriteErrorPauseBeforeConnected(SYNCHRONOUS);
8409 }
8410
TEST_P(QuicStreamFactoryTest,MigrateSessionOnAsyncWriteErrorPauseBeforeConnected)8411 TEST_P(QuicStreamFactoryTest,
8412 MigrateSessionOnAsyncWriteErrorPauseBeforeConnected) {
8413 TestMigrationOnWriteErrorPauseBeforeConnected(ASYNC);
8414 }
8415
8416 // This test verifies that when session successfully migrate to the alternate
8417 // network, packet write error on the old writer will be ignored and will not
8418 // trigger connection migration on write error.
TEST_P(QuicStreamFactoryTest,IgnoreWriteErrorFromOldWriterAfterMigration)8419 TEST_P(QuicStreamFactoryTest, IgnoreWriteErrorFromOldWriterAfterMigration) {
8420 InitializeConnectionMigrationV2Test(
8421 {kDefaultNetworkForTests, kNewNetworkForTests});
8422 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
8423 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
8424 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
8425
8426 // Using a testing task runner so that we can verify whether the migrate on
8427 // write error task is posted.
8428 auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
8429 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
8430
8431 MockQuicData socket_data(version_);
8432 int packet_num = 1;
8433 if (VersionUsesHttp3(version_.transport_version)) {
8434 socket_data.AddWrite(SYNCHRONOUS,
8435 ConstructInitialSettingsPacket(packet_num++));
8436 }
8437 socket_data.AddRead(ASYNC, ERR_IO_PENDING); // Pause
8438 socket_data.AddWrite(
8439 ASYNC, ERR_ADDRESS_UNREACHABLE,
8440 ConstructGetRequestPacket(packet_num++,
8441 GetNthClientInitiatedBidirectionalStreamId(0),
8442 true, true));
8443 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
8444 socket_data.AddSocketDataToFactory(socket_factory_.get());
8445
8446 // Create request and QuicHttpStream.
8447 QuicStreamRequest request(factory_.get());
8448 EXPECT_EQ(
8449 ERR_IO_PENDING,
8450 request.Request(
8451 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
8452 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
8453 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
8454 failed_on_default_network_callback_, callback_.callback()));
8455 EXPECT_EQ(OK, callback_.WaitForResult());
8456 std::unique_ptr<HttpStream> stream = CreateStream(&request);
8457 EXPECT_TRUE(stream.get());
8458
8459 // Cause QUIC stream to be created.
8460 HttpRequestInfo request_info;
8461 request_info.method = "GET";
8462 request_info.url = GURL("https://www.example.org/");
8463 request_info.traffic_annotation =
8464 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
8465 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
8466 net_log_, CompletionOnceCallback()));
8467
8468 // Ensure that session is alive and active.
8469 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
8470 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
8471 EXPECT_TRUE(HasActiveSession(host_port_pair_));
8472
8473 // Set up second socket data provider that is used after
8474 // migration. The response to the request is read on this new socket.
8475 MockQuicData socket_data1(version_);
8476 socket_data1.AddWrite(
8477 SYNCHRONOUS,
8478 client_maker_.MakePingPacket(packet_num++, /*include_version=*/true));
8479 socket_data1.AddRead(
8480 ASYNC,
8481 ConstructOkResponsePacket(
8482 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false));
8483 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
8484 if (VersionUsesHttp3(version_.transport_version)) {
8485 socket_data1.AddWrite(
8486 SYNCHRONOUS, client_maker_.MakeAckAndDataPacket(
8487 packet_num++, false, GetQpackDecoderStreamId(), 1, 1,
8488 false, StreamCancellationQpackDecoderInstruction(0)));
8489 socket_data1.AddWrite(
8490 SYNCHRONOUS,
8491 client_maker_.MakeRstPacket(
8492 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
8493 quic::QUIC_STREAM_CANCELLED));
8494 } else {
8495 socket_data1.AddWrite(
8496 SYNCHRONOUS,
8497 client_maker_.MakeAckAndRstPacket(
8498 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
8499 quic::QUIC_STREAM_CANCELLED, 1, 1));
8500 }
8501 socket_data1.AddSocketDataToFactory(socket_factory_.get());
8502
8503 // Send GET request on stream.
8504 HttpResponseInfo response;
8505 HttpRequestHeaders request_headers;
8506 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
8507 callback_.callback()));
8508
8509 EXPECT_EQ(0u, task_runner->GetPendingTaskCount());
8510 // Now notify network is disconnected, cause the migration to complete
8511 // immediately.
8512 scoped_mock_network_change_notifier_->mock_network_change_notifier()
8513 ->NotifyNetworkDisconnected(kDefaultNetworkForTests);
8514 // There will be two pending task, one will complete migration with no delay
8515 // and the other will attempt to migrate back to the default network with
8516 // delay.
8517 EXPECT_EQ(2u, task_runner->GetPendingTaskCount());
8518
8519 // Complete migration.
8520 task_runner->RunUntilIdle();
8521 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
8522
8523 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
8524 EXPECT_TRUE(HasActiveSession(host_port_pair_));
8525 EXPECT_EQ(1u, session->GetNumActiveStreams());
8526
8527 // Verify that response headers on the migrated socket were delivered to the
8528 // stream.
8529 EXPECT_EQ(OK, stream->ReadResponseHeaders(callback_.callback()));
8530 EXPECT_EQ(200, response.headers->response_code());
8531
8532 // Resume the old socket data, a write error will be delivered to the old
8533 // packet writer. Verify no additional task is posted.
8534 socket_data.Resume();
8535 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
8536
8537 stream.reset();
8538 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
8539 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
8540 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
8541 }
8542
8543 // This test verifies that when session successfully migrate to the alternate
8544 // network, packet read error on the old reader will be ignored and will not
8545 // close the connection.
TEST_P(QuicStreamFactoryTest,IgnoreReadErrorFromOldReaderAfterMigration)8546 TEST_P(QuicStreamFactoryTest, IgnoreReadErrorFromOldReaderAfterMigration) {
8547 InitializeConnectionMigrationV2Test(
8548 {kDefaultNetworkForTests, kNewNetworkForTests});
8549 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
8550 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
8551 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
8552
8553 // Using a testing task runner.
8554 auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
8555 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
8556
8557 MockQuicData socket_data(version_);
8558 int packet_num = 1;
8559 if (VersionUsesHttp3(version_.transport_version)) {
8560 socket_data.AddWrite(SYNCHRONOUS,
8561 ConstructInitialSettingsPacket(packet_num++));
8562 }
8563 socket_data.AddRead(ASYNC, ERR_IO_PENDING); // Pause
8564 socket_data.AddRead(ASYNC, ERR_ADDRESS_UNREACHABLE);
8565 socket_data.AddSocketDataToFactory(socket_factory_.get());
8566
8567 // Create request and QuicHttpStream.
8568 QuicStreamRequest request(factory_.get());
8569 EXPECT_EQ(
8570 ERR_IO_PENDING,
8571 request.Request(
8572 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
8573 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
8574 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
8575 failed_on_default_network_callback_, callback_.callback()));
8576 EXPECT_EQ(OK, callback_.WaitForResult());
8577 std::unique_ptr<HttpStream> stream = CreateStream(&request);
8578 EXPECT_TRUE(stream.get());
8579
8580 // Cause QUIC stream to be created.
8581 HttpRequestInfo request_info;
8582 request_info.method = "GET";
8583 request_info.url = GURL("https://www.example.org/");
8584 request_info.traffic_annotation =
8585 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
8586 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
8587 net_log_, CompletionOnceCallback()));
8588
8589 // Ensure that session is alive and active.
8590 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
8591 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
8592 EXPECT_TRUE(HasActiveSession(host_port_pair_));
8593
8594 // Set up second socket data provider that is used after
8595 // migration. The request is written to this new socket, and the
8596 // response to the request is read on this new socket.
8597 MockQuicData socket_data1(version_);
8598 socket_data1.AddWrite(
8599 SYNCHRONOUS,
8600 client_maker_.MakePingPacket(packet_num++, /*include_version=*/true));
8601 socket_data1.AddWrite(
8602 SYNCHRONOUS,
8603 ConstructGetRequestPacket(packet_num++,
8604 GetNthClientInitiatedBidirectionalStreamId(0),
8605 true, true));
8606 socket_data1.AddRead(
8607 ASYNC,
8608 ConstructOkResponsePacket(
8609 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false));
8610 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
8611 if (VersionUsesHttp3(version_.transport_version)) {
8612 socket_data1.AddWrite(
8613 SYNCHRONOUS, client_maker_.MakeAckAndDataPacket(
8614 packet_num++, false, GetQpackDecoderStreamId(), 1, 1,
8615 false, StreamCancellationQpackDecoderInstruction(0)));
8616 socket_data1.AddWrite(
8617 SYNCHRONOUS,
8618 client_maker_.MakeRstPacket(
8619 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
8620 quic::QUIC_STREAM_CANCELLED));
8621 } else {
8622 socket_data1.AddWrite(
8623 SYNCHRONOUS,
8624 client_maker_.MakeAckAndRstPacket(
8625 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
8626 quic::QUIC_STREAM_CANCELLED, 1, 1));
8627 }
8628 socket_data1.AddSocketDataToFactory(socket_factory_.get());
8629
8630 EXPECT_EQ(0u, task_runner->GetPendingTaskCount());
8631 // Now notify network is disconnected, cause the migration to complete
8632 // immediately.
8633 scoped_mock_network_change_notifier_->mock_network_change_notifier()
8634 ->NotifyNetworkDisconnected(kDefaultNetworkForTests);
8635 // There will be two pending task, one will complete migration with no delay
8636 // and the other will attempt to migrate back to the default network with
8637 // delay.
8638 EXPECT_EQ(2u, task_runner->GetPendingTaskCount());
8639
8640 // Complete migration.
8641 task_runner->RunUntilIdle();
8642 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
8643
8644 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
8645 EXPECT_TRUE(HasActiveSession(host_port_pair_));
8646 EXPECT_EQ(1u, session->GetNumActiveStreams());
8647
8648 // Send GET request on stream.
8649 HttpResponseInfo response;
8650 HttpRequestHeaders request_headers;
8651 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
8652 callback_.callback()));
8653
8654 // Verify that response headers on the migrated socket were delivered to the
8655 // stream.
8656 EXPECT_EQ(ERR_IO_PENDING, stream->ReadResponseHeaders(callback_.callback()));
8657 EXPECT_EQ(OK, callback_.WaitForResult());
8658 EXPECT_EQ(200, response.headers->response_code());
8659
8660 // Resume the old socket data, a read error will be delivered to the old
8661 // packet reader. Verify that the session is not affected.
8662 socket_data.Resume();
8663 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
8664 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
8665 EXPECT_TRUE(HasActiveSession(host_port_pair_));
8666 EXPECT_EQ(1u, session->GetNumActiveStreams());
8667
8668 stream.reset();
8669 EXPECT_TRUE(socket_data.AllReadDataConsumed());
8670 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
8671 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
8672 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
8673 }
8674
8675 // This test verifies that after migration on network is executed, packet
8676 // read error on the old reader will be ignored and will not close the
8677 // connection.
TEST_P(QuicStreamFactoryTest,IgnoreReadErrorOnOldReaderDuringMigration)8678 TEST_P(QuicStreamFactoryTest, IgnoreReadErrorOnOldReaderDuringMigration) {
8679 InitializeConnectionMigrationV2Test(
8680 {kDefaultNetworkForTests, kNewNetworkForTests});
8681 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
8682 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
8683 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
8684
8685 // Using a testing task runner.
8686 auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
8687 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
8688
8689 MockQuicData socket_data(version_);
8690 int packet_num = 1;
8691 if (VersionUsesHttp3(version_.transport_version)) {
8692 socket_data.AddWrite(SYNCHRONOUS,
8693 ConstructInitialSettingsPacket(packet_num++));
8694 }
8695 socket_data.AddRead(ASYNC, ERR_IO_PENDING); // Pause
8696 socket_data.AddRead(ASYNC, ERR_ADDRESS_UNREACHABLE);
8697 socket_data.AddSocketDataToFactory(socket_factory_.get());
8698
8699 // Create request and QuicHttpStream.
8700 QuicStreamRequest request(factory_.get());
8701 EXPECT_EQ(
8702 ERR_IO_PENDING,
8703 request.Request(
8704 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
8705 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
8706 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
8707 failed_on_default_network_callback_, callback_.callback()));
8708 EXPECT_EQ(OK, callback_.WaitForResult());
8709 std::unique_ptr<HttpStream> stream = CreateStream(&request);
8710 EXPECT_TRUE(stream.get());
8711
8712 // Cause QUIC stream to be created.
8713 HttpRequestInfo request_info;
8714 request_info.method = "GET";
8715 request_info.url = GURL("https://www.example.org/");
8716 request_info.traffic_annotation =
8717 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
8718 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
8719 net_log_, CompletionOnceCallback()));
8720
8721 // Ensure that session is alive and active.
8722 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
8723 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
8724 EXPECT_TRUE(HasActiveSession(host_port_pair_));
8725
8726 // Set up second socket data provider that is used after
8727 // migration. The request is written to this new socket, and the
8728 // response to the request is read on this new socket.
8729 MockQuicData socket_data1(version_);
8730 socket_data1.AddWrite(
8731 SYNCHRONOUS,
8732 client_maker_.MakePingPacket(packet_num++, /*include_version=*/true));
8733 socket_data1.AddWrite(
8734 SYNCHRONOUS,
8735 ConstructGetRequestPacket(packet_num++,
8736 GetNthClientInitiatedBidirectionalStreamId(0),
8737 true, true));
8738 socket_data1.AddRead(
8739 ASYNC,
8740 ConstructOkResponsePacket(
8741 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false));
8742 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
8743 if (VersionUsesHttp3(version_.transport_version)) {
8744 socket_data1.AddWrite(
8745 SYNCHRONOUS, client_maker_.MakeAckAndDataPacket(
8746 packet_num++, false, GetQpackDecoderStreamId(), 1, 1,
8747 false, StreamCancellationQpackDecoderInstruction(0)));
8748 socket_data1.AddWrite(
8749 SYNCHRONOUS,
8750 client_maker_.MakeRstPacket(
8751 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
8752 quic::QUIC_STREAM_CANCELLED));
8753 } else {
8754 socket_data1.AddWrite(
8755 SYNCHRONOUS,
8756 client_maker_.MakeAckAndRstPacket(
8757 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
8758 quic::QUIC_STREAM_CANCELLED, 1, 1));
8759 }
8760 socket_data1.AddSocketDataToFactory(socket_factory_.get());
8761
8762 EXPECT_EQ(0u, task_runner->GetPendingTaskCount());
8763 // Now notify network is disconnected, cause the migration to complete
8764 // immediately.
8765 scoped_mock_network_change_notifier_->mock_network_change_notifier()
8766 ->NotifyNetworkDisconnected(kDefaultNetworkForTests);
8767 // There will be two pending task, one will complete migration with no delay
8768 // and the other will attempt to migrate back to the default network with
8769 // delay.
8770 EXPECT_EQ(2u, task_runner->GetPendingTaskCount());
8771
8772 // Resume the old socket data, a read error will be delivered to the old
8773 // packet reader. Verify that the session is not affected.
8774 socket_data.Resume();
8775 EXPECT_EQ(2u, task_runner->GetPendingTaskCount());
8776 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
8777 EXPECT_TRUE(HasActiveSession(host_port_pair_));
8778 EXPECT_EQ(1u, session->GetNumActiveStreams());
8779
8780 // Complete migration.
8781 task_runner->RunUntilIdle();
8782 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
8783
8784 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
8785 EXPECT_TRUE(HasActiveSession(host_port_pair_));
8786 EXPECT_EQ(1u, session->GetNumActiveStreams());
8787
8788 // Send GET request on stream.
8789 HttpResponseInfo response;
8790 HttpRequestHeaders request_headers;
8791 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
8792 callback_.callback()));
8793
8794 // Verify that response headers on the migrated socket were delivered to the
8795 // stream.
8796 EXPECT_EQ(ERR_IO_PENDING, stream->ReadResponseHeaders(callback_.callback()));
8797 EXPECT_EQ(OK, callback_.WaitForResult());
8798 EXPECT_EQ(200, response.headers->response_code());
8799
8800 stream.reset();
8801 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
8802 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
8803 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
8804 }
8805
8806 // This test verifies that when connection migration on path degrading is
8807 // enabled, and no custom retransmittable on wire timeout is specified, the
8808 // default value is used.
TEST_P(QuicStreamFactoryTest,DefaultRetransmittableOnWireTimeoutForMigration)8809 TEST_P(QuicStreamFactoryTest, DefaultRetransmittableOnWireTimeoutForMigration) {
8810 InitializeConnectionMigrationV2Test(
8811 {kDefaultNetworkForTests, kNewNetworkForTests});
8812 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
8813 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
8814 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
8815
8816 // Using a testing task runner.
8817 auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
8818 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
8819 QuicStreamFactoryPeer::SetAlarmFactory(
8820 factory_.get(), std::make_unique<QuicChromiumAlarmFactory>(
8821 task_runner.get(), context_.clock()));
8822
8823 MockQuicData socket_data(version_);
8824 int packet_num = 1;
8825 if (VersionUsesHttp3(version_.transport_version)) {
8826 socket_data.AddWrite(SYNCHRONOUS,
8827 ConstructInitialSettingsPacket(packet_num++));
8828 }
8829 socket_data.AddRead(ASYNC, ERR_IO_PENDING); // Pause
8830 socket_data.AddRead(ASYNC, ERR_ADDRESS_UNREACHABLE);
8831 socket_data.AddSocketDataToFactory(socket_factory_.get());
8832
8833 // Set up second socket data provider that is used after
8834 // migration. The request is written to this new socket, and the
8835 // response to the request is read on this new socket.
8836 MockQuicData socket_data1(version_);
8837 // The PING packet sent post migration.
8838 socket_data1.AddWrite(SYNCHRONOUS,
8839 client_maker_.MakePingPacket(packet_num++, true));
8840 socket_data1.AddWrite(
8841 SYNCHRONOUS,
8842 ConstructGetRequestPacket(packet_num++,
8843 GetNthClientInitiatedBidirectionalStreamId(0),
8844 true, true));
8845 socket_data1.AddRead(ASYNC, ERR_IO_PENDING); // Pause.
8846 // Read two packets so that client will send ACK immediately.
8847 socket_data1.AddRead(
8848 ASYNC,
8849 ConstructOkResponsePacket(
8850 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false));
8851 socket_data1.AddRead(
8852 ASYNC, server_maker_.MakeDataPacket(
8853 2, GetNthClientInitiatedBidirectionalStreamId(0), false, false,
8854 "Hello World"));
8855
8856 // Read an ACK from server which acks all client data.
8857 socket_data1.AddRead(SYNCHRONOUS, server_maker_.MakeAckPacket(3, 3, 1));
8858 socket_data1.AddWrite(ASYNC, client_maker_.MakeAckPacket(packet_num++, 2, 1));
8859 // The PING packet sent for retransmittable on wire.
8860 socket_data1.AddWrite(SYNCHRONOUS,
8861 client_maker_.MakePingPacket(packet_num++, false));
8862 socket_data1.AddRead(ASYNC, ERR_IO_PENDING); // Pause.
8863 std::string header = ConstructDataHeader(6);
8864 socket_data1.AddRead(
8865 ASYNC, ConstructServerDataPacket(
8866 3, GetNthClientInitiatedBidirectionalStreamId(0), false, true,
8867 header + "hello!"));
8868 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read.
8869 if (VersionUsesHttp3(version_.transport_version)) {
8870 socket_data1.AddWrite(
8871 SYNCHRONOUS, client_maker_.MakeDataPacket(
8872 packet_num++, GetQpackDecoderStreamId(), true, false,
8873 StreamCancellationQpackDecoderInstruction(0)));
8874 }
8875 socket_data1.AddWrite(
8876 SYNCHRONOUS,
8877 client_maker_.MakeRstPacket(packet_num++, false,
8878 GetNthClientInitiatedBidirectionalStreamId(0),
8879 quic::QUIC_STREAM_CANCELLED));
8880 socket_data1.AddSocketDataToFactory(socket_factory_.get());
8881
8882 // Create request and QuicHttpStream.
8883 QuicStreamRequest request(factory_.get());
8884 EXPECT_EQ(
8885 ERR_IO_PENDING,
8886 request.Request(
8887 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
8888 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
8889 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
8890 failed_on_default_network_callback_, callback_.callback()));
8891 EXPECT_EQ(OK, callback_.WaitForResult());
8892 std::unique_ptr<HttpStream> stream = CreateStream(&request);
8893 EXPECT_TRUE(stream.get());
8894
8895 // Cause QUIC stream to be created.
8896 HttpRequestInfo request_info;
8897 request_info.method = "GET";
8898 request_info.url = GURL("https://www.example.org/");
8899 request_info.traffic_annotation =
8900 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
8901 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
8902 net_log_, CompletionOnceCallback()));
8903
8904 // Ensure that session is alive and active.
8905 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
8906 EXPECT_TRUE(HasActiveSession(host_port_pair_));
8907
8908 // Now notify network is disconnected, cause the migration to complete
8909 // immediately.
8910 scoped_mock_network_change_notifier_->mock_network_change_notifier()
8911 ->NotifyNetworkDisconnected(kDefaultNetworkForTests);
8912
8913 // Complete migration.
8914 task_runner->RunUntilIdle();
8915 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
8916 EXPECT_TRUE(HasActiveSession(host_port_pair_));
8917 EXPECT_EQ(1u, session->GetNumActiveStreams());
8918
8919 // Send GET request on stream.
8920 HttpResponseInfo response;
8921 HttpRequestHeaders request_headers;
8922 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
8923 callback_.callback()));
8924 socket_data1.Resume();
8925 // Spin up the message loop to read incoming data from server till the ACK.
8926 base::RunLoop().RunUntilIdle();
8927
8928 // Ack delay time.
8929 base::TimeDelta delay = task_runner->NextPendingTaskDelay();
8930 EXPECT_GT(kDefaultRetransmittableOnWireTimeout, delay);
8931 // Fire the ack alarm, since ack has been sent, no ack will be sent.
8932 context_.AdvanceTime(
8933 quic::QuicTime::Delta::FromMilliseconds(delay.InMilliseconds()));
8934 task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
8935
8936 // Fire the ping alarm with retransmittable-on-wire timeout, send PING.
8937 delay = kDefaultRetransmittableOnWireTimeout - delay;
8938 EXPECT_EQ(delay, task_runner->NextPendingTaskDelay());
8939 context_.AdvanceTime(
8940 quic::QuicTime::Delta::FromMilliseconds(delay.InMilliseconds()));
8941 task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
8942
8943 socket_data1.Resume();
8944
8945 // Verify that response headers on the migrated socket were delivered to the
8946 // stream.
8947 EXPECT_EQ(OK, stream->ReadResponseHeaders(callback_.callback()));
8948 EXPECT_EQ(200, response.headers->response_code());
8949
8950 // Resume the old socket data, a read error will be delivered to the old
8951 // packet reader. Verify that the session is not affected.
8952 socket_data.Resume();
8953 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
8954 EXPECT_TRUE(HasActiveSession(host_port_pair_));
8955 EXPECT_EQ(1u, session->GetNumActiveStreams());
8956
8957 stream.reset();
8958 EXPECT_TRUE(socket_data.AllReadDataConsumed());
8959 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
8960 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
8961 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
8962 }
8963
8964 // This test verifies that when connection migration on path degrading is
8965 // enabled, and a custom retransmittable on wire timeout is specified, the
8966 // custom value is used.
TEST_P(QuicStreamFactoryTest,CustomRetransmittableOnWireTimeoutForMigration)8967 TEST_P(QuicStreamFactoryTest, CustomRetransmittableOnWireTimeoutForMigration) {
8968 constexpr base::TimeDelta custom_timeout_value =
8969 base::TimeDelta::FromMilliseconds(200);
8970 quic_params_->retransmittable_on_wire_timeout = custom_timeout_value;
8971 InitializeConnectionMigrationV2Test(
8972 {kDefaultNetworkForTests, kNewNetworkForTests});
8973 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
8974 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
8975 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
8976
8977 // Using a testing task runner.
8978 auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
8979 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
8980 QuicStreamFactoryPeer::SetAlarmFactory(
8981 factory_.get(), std::make_unique<QuicChromiumAlarmFactory>(
8982 task_runner.get(), context_.clock()));
8983
8984 MockQuicData socket_data(version_);
8985 int packet_num = 1;
8986 if (VersionUsesHttp3(version_.transport_version)) {
8987 socket_data.AddWrite(SYNCHRONOUS,
8988 ConstructInitialSettingsPacket(packet_num++));
8989 }
8990 socket_data.AddRead(ASYNC, ERR_IO_PENDING); // Pause
8991 socket_data.AddRead(ASYNC, ERR_ADDRESS_UNREACHABLE);
8992 socket_data.AddSocketDataToFactory(socket_factory_.get());
8993
8994 // Set up second socket data provider that is used after
8995 // migration. The request is written to this new socket, and the
8996 // response to the request is read on this new socket.
8997 MockQuicData socket_data1(version_);
8998 // The PING packet sent post migration.
8999 socket_data1.AddWrite(SYNCHRONOUS,
9000 client_maker_.MakePingPacket(packet_num++, true));
9001 socket_data1.AddWrite(
9002 SYNCHRONOUS,
9003 ConstructGetRequestPacket(packet_num++,
9004 GetNthClientInitiatedBidirectionalStreamId(0),
9005 true, true));
9006 socket_data1.AddRead(ASYNC, ERR_IO_PENDING); // Pause.
9007 // Read two packets so that client will send ACK immedaitely.
9008 socket_data1.AddRead(
9009 ASYNC,
9010 ConstructOkResponsePacket(
9011 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false));
9012 socket_data1.AddRead(
9013 ASYNC, server_maker_.MakeDataPacket(
9014 2, GetNthClientInitiatedBidirectionalStreamId(0), false, false,
9015 "Hello World"));
9016 // Read an ACK from server which acks all client data.
9017 socket_data1.AddRead(SYNCHRONOUS, server_maker_.MakeAckPacket(3, 3, 1));
9018 socket_data1.AddWrite(ASYNC, client_maker_.MakeAckPacket(packet_num++, 2, 1));
9019 // The PING packet sent for retransmittable on wire.
9020 socket_data1.AddWrite(SYNCHRONOUS,
9021 client_maker_.MakePingPacket(packet_num++, false));
9022 socket_data1.AddRead(ASYNC, ERR_IO_PENDING); // Pause.
9023 std::string header = ConstructDataHeader(6);
9024 socket_data1.AddRead(
9025 ASYNC, ConstructServerDataPacket(
9026 3, GetNthClientInitiatedBidirectionalStreamId(0), false, true,
9027 header + "hello!"));
9028 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read.
9029 if (VersionUsesHttp3(version_.transport_version)) {
9030 socket_data1.AddWrite(
9031 SYNCHRONOUS, client_maker_.MakeDataPacket(
9032 packet_num++, GetQpackDecoderStreamId(), true, false,
9033 StreamCancellationQpackDecoderInstruction(0)));
9034 }
9035 socket_data1.AddWrite(
9036 SYNCHRONOUS,
9037 client_maker_.MakeRstPacket(packet_num++, false,
9038 GetNthClientInitiatedBidirectionalStreamId(0),
9039 quic::QUIC_STREAM_CANCELLED));
9040 socket_data1.AddSocketDataToFactory(socket_factory_.get());
9041
9042 // Create request and QuicHttpStream.
9043 QuicStreamRequest request(factory_.get());
9044 EXPECT_EQ(
9045 ERR_IO_PENDING,
9046 request.Request(
9047 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
9048 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
9049 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
9050 failed_on_default_network_callback_, callback_.callback()));
9051 EXPECT_EQ(OK, callback_.WaitForResult());
9052 std::unique_ptr<HttpStream> stream = CreateStream(&request);
9053 EXPECT_TRUE(stream.get());
9054
9055 // Cause QUIC stream to be created.
9056 HttpRequestInfo request_info;
9057 request_info.method = "GET";
9058 request_info.url = GURL("https://www.example.org/");
9059 request_info.traffic_annotation =
9060 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
9061 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
9062 net_log_, CompletionOnceCallback()));
9063
9064 // Ensure that session is alive and active.
9065 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
9066 EXPECT_TRUE(HasActiveSession(host_port_pair_));
9067
9068 // Now notify network is disconnected, cause the migration to complete
9069 // immediately.
9070 scoped_mock_network_change_notifier_->mock_network_change_notifier()
9071 ->NotifyNetworkDisconnected(kDefaultNetworkForTests);
9072
9073 // Complete migration.
9074 task_runner->RunUntilIdle();
9075 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
9076 EXPECT_TRUE(HasActiveSession(host_port_pair_));
9077 EXPECT_EQ(1u, session->GetNumActiveStreams());
9078
9079 // Send GET request on stream.
9080 HttpResponseInfo response;
9081 HttpRequestHeaders request_headers;
9082 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
9083 callback_.callback()));
9084 socket_data1.Resume();
9085 // Spin up the message loop to read incoming data from server till the ACK.
9086 base::RunLoop().RunUntilIdle();
9087
9088 // Ack delay time.
9089 base::TimeDelta delay = task_runner->NextPendingTaskDelay();
9090 EXPECT_GT(custom_timeout_value, delay);
9091 // Fire the ack alarm, since ack has been sent, no ack will be sent.
9092 context_.AdvanceTime(
9093 quic::QuicTime::Delta::FromMilliseconds(delay.InMilliseconds()));
9094 task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
9095
9096 // Fire the ping alarm with retransmittable-on-wire timeout, send PING.
9097 delay = custom_timeout_value - delay;
9098 EXPECT_EQ(delay, task_runner->NextPendingTaskDelay());
9099 context_.AdvanceTime(
9100 quic::QuicTime::Delta::FromMilliseconds(delay.InMilliseconds()));
9101 task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
9102
9103 socket_data1.Resume();
9104
9105 // Verify that response headers on the migrated socket were delivered to the
9106 // stream.
9107 EXPECT_EQ(OK, stream->ReadResponseHeaders(callback_.callback()));
9108 EXPECT_EQ(200, response.headers->response_code());
9109
9110 // Resume the old socket data, a read error will be delivered to the old
9111 // packet reader. Verify that the session is not affected.
9112 socket_data.Resume();
9113 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
9114 EXPECT_TRUE(HasActiveSession(host_port_pair_));
9115 EXPECT_EQ(1u, session->GetNumActiveStreams());
9116
9117 stream.reset();
9118 EXPECT_TRUE(socket_data.AllReadDataConsumed());
9119 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
9120 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
9121 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
9122 }
9123
9124 // This test verifies that when no migration is enabled, but a custom value for
9125 // retransmittable-on-wire timeout is specified, the ping alarm is set up to
9126 // send retransmittable pings with the custom value.
TEST_P(QuicStreamFactoryTest,CustomRetransmittableOnWireTimeout)9127 TEST_P(QuicStreamFactoryTest, CustomRetransmittableOnWireTimeout) {
9128 constexpr base::TimeDelta custom_timeout_value =
9129 base::TimeDelta::FromMilliseconds(200);
9130 quic_params_->retransmittable_on_wire_timeout = custom_timeout_value;
9131 Initialize();
9132 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
9133 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
9134 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
9135
9136 // Using a testing task runner.
9137 auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
9138 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
9139 QuicStreamFactoryPeer::SetAlarmFactory(
9140 factory_.get(), std::make_unique<QuicChromiumAlarmFactory>(
9141 task_runner.get(), context_.clock()));
9142
9143 MockQuicData socket_data1(version_);
9144 int packet_num = 1;
9145 if (VersionUsesHttp3(version_.transport_version)) {
9146 socket_data1.AddWrite(SYNCHRONOUS,
9147 ConstructInitialSettingsPacket(packet_num++));
9148 }
9149 socket_data1.AddWrite(
9150 SYNCHRONOUS,
9151 ConstructGetRequestPacket(packet_num++,
9152 GetNthClientInitiatedBidirectionalStreamId(0),
9153 true, true));
9154 socket_data1.AddRead(ASYNC, ERR_IO_PENDING); // Pause.
9155 // Read two packets so that client will send ACK immedaitely.
9156 socket_data1.AddRead(
9157 ASYNC,
9158 ConstructOkResponsePacket(
9159 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false));
9160 socket_data1.AddRead(
9161 ASYNC, server_maker_.MakeDataPacket(
9162 2, GetNthClientInitiatedBidirectionalStreamId(0), false, false,
9163 "Hello World"));
9164 // Read an ACK from server which acks all client data.
9165 socket_data1.AddRead(SYNCHRONOUS, server_maker_.MakeAckPacket(3, 2, 1));
9166 socket_data1.AddWrite(ASYNC, client_maker_.MakeAckPacket(packet_num++, 2, 1));
9167 // The PING packet sent for retransmittable on wire.
9168 socket_data1.AddWrite(SYNCHRONOUS,
9169 client_maker_.MakePingPacket(packet_num++, false));
9170 socket_data1.AddRead(ASYNC, ERR_IO_PENDING); // Pause.
9171 std::string header = ConstructDataHeader(6);
9172 socket_data1.AddRead(
9173 ASYNC, ConstructServerDataPacket(
9174 3, GetNthClientInitiatedBidirectionalStreamId(0), false, true,
9175 header + "hello!"));
9176 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read.
9177 if (VersionUsesHttp3(version_.transport_version)) {
9178 socket_data1.AddWrite(
9179 SYNCHRONOUS, client_maker_.MakeDataPacket(
9180 packet_num++, GetQpackDecoderStreamId(), true, false,
9181 StreamCancellationQpackDecoderInstruction(0)));
9182 }
9183 socket_data1.AddWrite(
9184 SYNCHRONOUS,
9185 client_maker_.MakeRstPacket(packet_num++, false,
9186 GetNthClientInitiatedBidirectionalStreamId(0),
9187 quic::QUIC_STREAM_CANCELLED));
9188 socket_data1.AddSocketDataToFactory(socket_factory_.get());
9189
9190 // Create request and QuicHttpStream.
9191 QuicStreamRequest request(factory_.get());
9192 EXPECT_EQ(
9193 ERR_IO_PENDING,
9194 request.Request(
9195 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
9196 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
9197 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
9198 failed_on_default_network_callback_, callback_.callback()));
9199 EXPECT_EQ(OK, callback_.WaitForResult());
9200 std::unique_ptr<HttpStream> stream = CreateStream(&request);
9201 EXPECT_TRUE(stream.get());
9202
9203 // Cause QUIC stream to be created.
9204 HttpRequestInfo request_info;
9205 request_info.method = "GET";
9206 request_info.url = GURL("https://www.example.org/");
9207 request_info.traffic_annotation =
9208 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
9209 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
9210 net_log_, CompletionOnceCallback()));
9211
9212 // Ensure that session is alive and active.
9213 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
9214 EXPECT_TRUE(HasActiveSession(host_port_pair_));
9215
9216 // Complete migration.
9217 task_runner->RunUntilIdle();
9218 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
9219 EXPECT_TRUE(HasActiveSession(host_port_pair_));
9220 EXPECT_EQ(1u, session->GetNumActiveStreams());
9221
9222 // Send GET request on stream.
9223 HttpResponseInfo response;
9224 HttpRequestHeaders request_headers;
9225 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
9226 callback_.callback()));
9227 socket_data1.Resume();
9228 // Spin up the message loop to read incoming data from server till the ACK.
9229 base::RunLoop().RunUntilIdle();
9230
9231 // Ack delay time.
9232 base::TimeDelta delay = task_runner->NextPendingTaskDelay();
9233 EXPECT_GT(custom_timeout_value, delay);
9234 // Fire the ack alarm, since ack has been sent, no ack will be sent.
9235 context_.AdvanceTime(
9236 quic::QuicTime::Delta::FromMilliseconds(delay.InMilliseconds()));
9237 task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
9238
9239 // Fire the ping alarm with retransmittable-on-wire timeout, send PING.
9240 delay = custom_timeout_value - delay;
9241 EXPECT_EQ(delay, task_runner->NextPendingTaskDelay());
9242 context_.AdvanceTime(
9243 quic::QuicTime::Delta::FromMilliseconds(delay.InMilliseconds()));
9244 task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
9245
9246 socket_data1.Resume();
9247
9248 // Verify that response headers on the migrated socket were delivered to the
9249 // stream.
9250 EXPECT_EQ(OK, stream->ReadResponseHeaders(callback_.callback()));
9251 EXPECT_EQ(200, response.headers->response_code());
9252
9253 // Resume the old socket data, a read error will be delivered to the old
9254 // packet reader. Verify that the session is not affected.
9255 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
9256 EXPECT_TRUE(HasActiveSession(host_port_pair_));
9257 EXPECT_EQ(1u, session->GetNumActiveStreams());
9258
9259 stream.reset();
9260 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
9261 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
9262 }
9263
9264 // This test verifies that when no migration is enabled, and no custom value
9265 // for retransmittable-on-wire timeout is specified, the ping alarm will not
9266 // send any retransmittable pings.
TEST_P(QuicStreamFactoryTest,NoRetransmittableOnWireTimeout)9267 TEST_P(QuicStreamFactoryTest, NoRetransmittableOnWireTimeout) {
9268 // Use non-default initial srtt so that if QPACK emits additional setting
9269 // packet, it will not have the same retransmission timeout as the
9270 // default value of retransmittable-on-wire-ping timeout.
9271 ServerNetworkStats stats;
9272 stats.srtt = base::TimeDelta::FromMilliseconds(200);
9273 http_server_properties_->SetServerNetworkStats(url::SchemeHostPort(url_),
9274 NetworkIsolationKey(), stats);
9275 quic_params_->estimate_initial_rtt = true;
9276
9277 Initialize();
9278 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
9279 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
9280 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
9281
9282 // Using a testing task runner.
9283 auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
9284 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
9285 QuicStreamFactoryPeer::SetAlarmFactory(
9286 factory_.get(), std::make_unique<QuicChromiumAlarmFactory>(
9287 task_runner.get(), context_.clock()));
9288
9289 MockQuicData socket_data1(version_);
9290 int packet_num = 1;
9291 if (VersionUsesHttp3(version_.transport_version)) {
9292 socket_data1.AddWrite(SYNCHRONOUS,
9293 ConstructInitialSettingsPacket(packet_num++));
9294 }
9295 socket_data1.AddWrite(
9296 SYNCHRONOUS,
9297 ConstructGetRequestPacket(packet_num++,
9298 GetNthClientInitiatedBidirectionalStreamId(0),
9299 true, true));
9300 socket_data1.AddRead(ASYNC, ERR_IO_PENDING); // Pause.
9301 // Read two packets so that client will send ACK immedaitely.
9302 socket_data1.AddRead(
9303 ASYNC,
9304 ConstructOkResponsePacket(
9305 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false));
9306 socket_data1.AddRead(
9307 ASYNC, server_maker_.MakeDataPacket(
9308 2, GetNthClientInitiatedBidirectionalStreamId(0), false, false,
9309 "Hello World"));
9310 // Read an ACK from server which acks all client data.
9311 socket_data1.AddRead(SYNCHRONOUS, server_maker_.MakeAckPacket(3, 2, 1));
9312 socket_data1.AddWrite(ASYNC, client_maker_.MakeAckPacket(packet_num++, 2, 1));
9313 std::string header = ConstructDataHeader(6);
9314 socket_data1.AddRead(
9315 ASYNC, ConstructServerDataPacket(
9316 3, GetNthClientInitiatedBidirectionalStreamId(0), false, true,
9317 header + "hello!"));
9318 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read.
9319 if (VersionUsesHttp3(version_.transport_version)) {
9320 socket_data1.AddWrite(
9321 SYNCHRONOUS, client_maker_.MakeDataPacket(
9322 packet_num++, GetQpackDecoderStreamId(), true, false,
9323 StreamCancellationQpackDecoderInstruction(0)));
9324 }
9325 socket_data1.AddWrite(
9326 SYNCHRONOUS,
9327 client_maker_.MakeRstPacket(packet_num++, false,
9328 GetNthClientInitiatedBidirectionalStreamId(0),
9329 quic::QUIC_STREAM_CANCELLED));
9330 socket_data1.AddSocketDataToFactory(socket_factory_.get());
9331
9332 // Create request and QuicHttpStream.
9333 QuicStreamRequest request(factory_.get());
9334 EXPECT_EQ(
9335 ERR_IO_PENDING,
9336 request.Request(
9337 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
9338 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
9339 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
9340 failed_on_default_network_callback_, callback_.callback()));
9341 EXPECT_EQ(OK, callback_.WaitForResult());
9342 std::unique_ptr<HttpStream> stream = CreateStream(&request);
9343 EXPECT_TRUE(stream.get());
9344
9345 // Cause QUIC stream to be created.
9346 HttpRequestInfo request_info;
9347 request_info.method = "GET";
9348 request_info.url = GURL("https://www.example.org/");
9349 request_info.traffic_annotation =
9350 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
9351 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
9352 net_log_, CompletionOnceCallback()));
9353
9354 // Ensure that session is alive and active.
9355 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
9356 EXPECT_TRUE(HasActiveSession(host_port_pair_));
9357
9358 // Complete migration.
9359 task_runner->RunUntilIdle();
9360 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
9361 EXPECT_TRUE(HasActiveSession(host_port_pair_));
9362 EXPECT_EQ(1u, session->GetNumActiveStreams());
9363
9364 // Send GET request on stream.
9365 HttpResponseInfo response;
9366 HttpRequestHeaders request_headers;
9367 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
9368 callback_.callback()));
9369 socket_data1.Resume();
9370 // Spin up the message loop to read incoming data from server till the ACK.
9371 base::RunLoop().RunUntilIdle();
9372
9373 // Ack delay time.
9374 base::TimeDelta delay = task_runner->NextPendingTaskDelay();
9375 EXPECT_GT(kDefaultRetransmittableOnWireTimeout, delay);
9376 // Fire the ack alarm, since ack has been sent, no ack will be sent.
9377 context_.AdvanceTime(
9378 quic::QuicTime::Delta::FromMilliseconds(delay.InMilliseconds()));
9379 task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
9380
9381 // Verify that the ping alarm is not set with any default value.
9382 base::TimeDelta wrong_delay = kDefaultRetransmittableOnWireTimeout - delay;
9383 delay = task_runner->NextPendingTaskDelay();
9384 EXPECT_NE(wrong_delay, delay);
9385 context_.AdvanceTime(
9386 quic::QuicTime::Delta::FromMilliseconds(delay.InMilliseconds()));
9387 task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
9388
9389 // Verify that response headers on the migrated socket were delivered to the
9390 // stream.
9391 EXPECT_EQ(OK, stream->ReadResponseHeaders(callback_.callback()));
9392 EXPECT_EQ(200, response.headers->response_code());
9393
9394 // Resume the old socket data, a read error will be delivered to the old
9395 // packet reader. Verify that the session is not affected.
9396 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
9397 EXPECT_TRUE(HasActiveSession(host_port_pair_));
9398 EXPECT_EQ(1u, session->GetNumActiveStreams());
9399
9400 stream.reset();
9401 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
9402 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
9403 }
9404
9405 // This test verifies that when only migration on network change is enabled, and
9406 // a custom value for retransmittable-on-wire is specified, the ping alarm will
9407 // send retransmittable pings to the peer with custom value.
TEST_P(QuicStreamFactoryTest,CustomRetransmittableOnWireTimeoutWithMigrationOnNetworkChangeOnly)9408 TEST_P(QuicStreamFactoryTest,
9409 CustomRetransmittableOnWireTimeoutWithMigrationOnNetworkChangeOnly) {
9410 constexpr base::TimeDelta custom_timeout_value =
9411 base::TimeDelta::FromMilliseconds(200);
9412 quic_params_->retransmittable_on_wire_timeout = custom_timeout_value;
9413 quic_params_->migrate_sessions_on_network_change_v2 = true;
9414 Initialize();
9415 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
9416 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
9417 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
9418
9419 // Using a testing task runner.
9420 auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
9421 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
9422 QuicStreamFactoryPeer::SetAlarmFactory(
9423 factory_.get(), std::make_unique<QuicChromiumAlarmFactory>(
9424 task_runner.get(), context_.clock()));
9425
9426 MockQuicData socket_data1(version_);
9427 int packet_num = 1;
9428 if (VersionUsesHttp3(version_.transport_version)) {
9429 socket_data1.AddWrite(SYNCHRONOUS,
9430 ConstructInitialSettingsPacket(packet_num++));
9431 }
9432 socket_data1.AddWrite(
9433 SYNCHRONOUS,
9434 ConstructGetRequestPacket(packet_num++,
9435 GetNthClientInitiatedBidirectionalStreamId(0),
9436 true, true));
9437 socket_data1.AddRead(ASYNC, ERR_IO_PENDING); // Pause.
9438 // Read two packets so that client will send ACK immedaitely.
9439 socket_data1.AddRead(
9440 ASYNC,
9441 ConstructOkResponsePacket(
9442 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false));
9443 socket_data1.AddRead(
9444 ASYNC, server_maker_.MakeDataPacket(
9445 2, GetNthClientInitiatedBidirectionalStreamId(0), false, false,
9446 "Hello World"));
9447 // Read an ACK from server which acks all client data.
9448 socket_data1.AddRead(SYNCHRONOUS, server_maker_.MakeAckPacket(3, 2, 1));
9449 socket_data1.AddWrite(ASYNC, client_maker_.MakeAckPacket(packet_num++, 2, 1));
9450 // The PING packet sent for retransmittable on wire.
9451 socket_data1.AddWrite(SYNCHRONOUS,
9452 client_maker_.MakePingPacket(packet_num++, false));
9453 socket_data1.AddRead(ASYNC, ERR_IO_PENDING); // Pause.
9454 std::string header = ConstructDataHeader(6);
9455 socket_data1.AddRead(
9456 ASYNC, ConstructServerDataPacket(
9457 3, GetNthClientInitiatedBidirectionalStreamId(0), false, true,
9458 header + "hello!"));
9459 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read.
9460 if (VersionUsesHttp3(version_.transport_version)) {
9461 socket_data1.AddWrite(
9462 SYNCHRONOUS, client_maker_.MakeDataPacket(
9463 packet_num++, GetQpackDecoderStreamId(), true, false,
9464 StreamCancellationQpackDecoderInstruction(0)));
9465 }
9466 socket_data1.AddWrite(
9467 SYNCHRONOUS,
9468 client_maker_.MakeRstPacket(packet_num++, false,
9469 GetNthClientInitiatedBidirectionalStreamId(0),
9470 quic::QUIC_STREAM_CANCELLED));
9471 socket_data1.AddSocketDataToFactory(socket_factory_.get());
9472
9473 // Create request and QuicHttpStream.
9474 QuicStreamRequest request(factory_.get());
9475 EXPECT_EQ(
9476 ERR_IO_PENDING,
9477 request.Request(
9478 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
9479 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
9480 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
9481 failed_on_default_network_callback_, callback_.callback()));
9482 EXPECT_EQ(OK, callback_.WaitForResult());
9483 std::unique_ptr<HttpStream> stream = CreateStream(&request);
9484 EXPECT_TRUE(stream.get());
9485
9486 // Cause QUIC stream to be created.
9487 HttpRequestInfo request_info;
9488 request_info.method = "GET";
9489 request_info.url = GURL("https://www.example.org/");
9490 request_info.traffic_annotation =
9491 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
9492 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
9493 net_log_, CompletionOnceCallback()));
9494
9495 // Ensure that session is alive and active.
9496 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
9497 EXPECT_TRUE(HasActiveSession(host_port_pair_));
9498
9499 // Complete migration.
9500 task_runner->RunUntilIdle();
9501 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
9502 EXPECT_TRUE(HasActiveSession(host_port_pair_));
9503 EXPECT_EQ(1u, session->GetNumActiveStreams());
9504
9505 // Send GET request on stream.
9506 HttpResponseInfo response;
9507 HttpRequestHeaders request_headers;
9508 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
9509 callback_.callback()));
9510 socket_data1.Resume();
9511 // Spin up the message loop to read incoming data from server till the ACK.
9512 base::RunLoop().RunUntilIdle();
9513
9514 // Ack delay time.
9515 base::TimeDelta delay = task_runner->NextPendingTaskDelay();
9516 EXPECT_GT(custom_timeout_value, delay);
9517 // Fire the ack alarm, since ack has been sent, no ack will be sent.
9518 context_.AdvanceTime(
9519 quic::QuicTime::Delta::FromMilliseconds(delay.InMilliseconds()));
9520 task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
9521
9522 // Fire the ping alarm with retransmittable-on-wire timeout, send PING.
9523 delay = custom_timeout_value - delay;
9524 EXPECT_EQ(delay, task_runner->NextPendingTaskDelay());
9525 context_.AdvanceTime(
9526 quic::QuicTime::Delta::FromMilliseconds(delay.InMilliseconds()));
9527 task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
9528
9529 socket_data1.Resume();
9530
9531 // Verify that response headers on the migrated socket were delivered to the
9532 // stream.
9533 EXPECT_EQ(OK, stream->ReadResponseHeaders(callback_.callback()));
9534 EXPECT_EQ(200, response.headers->response_code());
9535
9536 // Resume the old socket data, a read error will be delivered to the old
9537 // packet reader. Verify that the session is not affected.
9538 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
9539 EXPECT_TRUE(HasActiveSession(host_port_pair_));
9540 EXPECT_EQ(1u, session->GetNumActiveStreams());
9541
9542 stream.reset();
9543 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
9544 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
9545 }
9546
9547 // This test verifies that when only migration on network change is enabled, and
9548 // no custom value for retransmittable-on-wire is specified, the ping alarm will
9549 // NOT send retransmittable pings to the peer with custom value.
TEST_P(QuicStreamFactoryTest,NoRetransmittableOnWireTimeoutWithMigrationOnNetworkChangeOnly)9550 TEST_P(QuicStreamFactoryTest,
9551 NoRetransmittableOnWireTimeoutWithMigrationOnNetworkChangeOnly) {
9552 // Use non-default initial srtt so that if QPACK emits additional setting
9553 // packet, it will not have the same retransmission timeout as the
9554 // default value of retransmittable-on-wire-ping timeout.
9555 ServerNetworkStats stats;
9556 stats.srtt = base::TimeDelta::FromMilliseconds(200);
9557 http_server_properties_->SetServerNetworkStats(url::SchemeHostPort(url_),
9558 NetworkIsolationKey(), stats);
9559 quic_params_->estimate_initial_rtt = true;
9560 quic_params_->migrate_sessions_on_network_change_v2 = true;
9561 Initialize();
9562
9563 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
9564 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
9565 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
9566
9567 // Using a testing task runner.
9568 auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
9569 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
9570 QuicStreamFactoryPeer::SetAlarmFactory(
9571 factory_.get(), std::make_unique<QuicChromiumAlarmFactory>(
9572 task_runner.get(), context_.clock()));
9573
9574 MockQuicData socket_data1(version_);
9575 int packet_num = 1;
9576 if (VersionUsesHttp3(version_.transport_version)) {
9577 socket_data1.AddWrite(SYNCHRONOUS,
9578 ConstructInitialSettingsPacket(packet_num++));
9579 }
9580 socket_data1.AddWrite(
9581 SYNCHRONOUS,
9582 ConstructGetRequestPacket(packet_num++,
9583 GetNthClientInitiatedBidirectionalStreamId(0),
9584 true, true));
9585 socket_data1.AddRead(ASYNC, ERR_IO_PENDING); // Pause.
9586 // Read two packets so that client will send ACK immedaitely.
9587 socket_data1.AddRead(
9588 ASYNC,
9589 ConstructOkResponsePacket(
9590 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false));
9591 socket_data1.AddRead(
9592 ASYNC, server_maker_.MakeDataPacket(
9593 2, GetNthClientInitiatedBidirectionalStreamId(0), false, false,
9594 "Hello World"));
9595 // Read an ACK from server which acks all client data.
9596 socket_data1.AddRead(SYNCHRONOUS, server_maker_.MakeAckPacket(3, 2, 1));
9597 socket_data1.AddWrite(ASYNC, client_maker_.MakeAckPacket(packet_num++, 2, 1));
9598 std::string header = ConstructDataHeader(6);
9599 socket_data1.AddRead(
9600 ASYNC, ConstructServerDataPacket(
9601 3, GetNthClientInitiatedBidirectionalStreamId(0), false, true,
9602 header + "hello!"));
9603 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read.
9604 if (VersionUsesHttp3(version_.transport_version)) {
9605 socket_data1.AddWrite(
9606 SYNCHRONOUS, client_maker_.MakeDataPacket(
9607 packet_num++, GetQpackDecoderStreamId(), true, false,
9608 StreamCancellationQpackDecoderInstruction(0)));
9609 }
9610 socket_data1.AddWrite(
9611 SYNCHRONOUS,
9612 client_maker_.MakeRstPacket(packet_num++, false,
9613 GetNthClientInitiatedBidirectionalStreamId(0),
9614 quic::QUIC_STREAM_CANCELLED));
9615 socket_data1.AddSocketDataToFactory(socket_factory_.get());
9616
9617 // Create request and QuicHttpStream.
9618 QuicStreamRequest request(factory_.get());
9619 EXPECT_EQ(
9620 ERR_IO_PENDING,
9621 request.Request(
9622 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
9623 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
9624 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
9625 failed_on_default_network_callback_, callback_.callback()));
9626 EXPECT_EQ(OK, callback_.WaitForResult());
9627 std::unique_ptr<HttpStream> stream = CreateStream(&request);
9628 EXPECT_TRUE(stream.get());
9629
9630 // Cause QUIC stream to be created.
9631 HttpRequestInfo request_info;
9632 request_info.method = "GET";
9633 request_info.url = GURL("https://www.example.org/");
9634 request_info.traffic_annotation =
9635 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
9636 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
9637 net_log_, CompletionOnceCallback()));
9638
9639 // Ensure that session is alive and active.
9640 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
9641 EXPECT_TRUE(HasActiveSession(host_port_pair_));
9642
9643 // Complete migration.
9644 task_runner->RunUntilIdle();
9645 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
9646 EXPECT_TRUE(HasActiveSession(host_port_pair_));
9647 EXPECT_EQ(1u, session->GetNumActiveStreams());
9648
9649 // Send GET request on stream.
9650 HttpResponseInfo response;
9651 HttpRequestHeaders request_headers;
9652 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
9653 callback_.callback()));
9654 socket_data1.Resume();
9655 // Spin up the message loop to read incoming data from server till the ACK.
9656 base::RunLoop().RunUntilIdle();
9657
9658 // Ack delay time.
9659 base::TimeDelta delay = task_runner->NextPendingTaskDelay();
9660 EXPECT_GT(kDefaultRetransmittableOnWireTimeout, delay);
9661 // Fire the ack alarm, since ack has been sent, no ack will be sent.
9662 context_.AdvanceTime(
9663 quic::QuicTime::Delta::FromMilliseconds(delay.InMilliseconds()));
9664 task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
9665
9666 // Verify the ping alarm is not set with default value.
9667 base::TimeDelta wrong_delay = kDefaultRetransmittableOnWireTimeout - delay;
9668 delay = task_runner->NextPendingTaskDelay();
9669 EXPECT_NE(wrong_delay, delay);
9670 context_.AdvanceTime(
9671 quic::QuicTime::Delta::FromMilliseconds(delay.InMilliseconds()));
9672 task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
9673
9674 // Verify that response headers on the migrated socket were delivered to the
9675 // stream.
9676 EXPECT_EQ(OK, stream->ReadResponseHeaders(callback_.callback()));
9677 EXPECT_EQ(200, response.headers->response_code());
9678
9679 // Resume the old socket data, a read error will be delivered to the old
9680 // packet reader. Verify that the session is not affected.
9681 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
9682 EXPECT_TRUE(HasActiveSession(host_port_pair_));
9683 EXPECT_EQ(1u, session->GetNumActiveStreams());
9684
9685 stream.reset();
9686 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
9687 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
9688 }
9689
9690 // This test verifies that after migration on write error is posted, packet
9691 // read error on the old reader will be ignored and will not close the
9692 // connection.
TEST_P(QuicStreamFactoryTest,IgnoreReadErrorOnOldReaderDuringPendingMigrationOnWriteError)9693 TEST_P(QuicStreamFactoryTest,
9694 IgnoreReadErrorOnOldReaderDuringPendingMigrationOnWriteError) {
9695 InitializeConnectionMigrationV2Test(
9696 {kDefaultNetworkForTests, kNewNetworkForTests});
9697 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
9698 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
9699 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
9700
9701 // Using a testing task runner.
9702 auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
9703 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
9704
9705 MockQuicData socket_data(version_);
9706 int packet_num = 1;
9707 if (VersionUsesHttp3(version_.transport_version)) {
9708 socket_data.AddWrite(SYNCHRONOUS,
9709 ConstructInitialSettingsPacket(packet_num++));
9710 }
9711 socket_data.AddWrite(ASYNC, ERR_FAILED); // Write error.
9712 socket_data.AddRead(ASYNC, ERR_ADDRESS_UNREACHABLE); // Read error.
9713 socket_data.AddSocketDataToFactory(socket_factory_.get());
9714
9715 // Create request and QuicHttpStream.
9716 QuicStreamRequest request(factory_.get());
9717 EXPECT_EQ(
9718 ERR_IO_PENDING,
9719 request.Request(
9720 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
9721 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
9722 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
9723 failed_on_default_network_callback_, callback_.callback()));
9724 EXPECT_EQ(OK, callback_.WaitForResult());
9725 std::unique_ptr<HttpStream> stream = CreateStream(&request);
9726 EXPECT_TRUE(stream.get());
9727
9728 // Cause QUIC stream to be created.
9729 HttpRequestInfo request_info;
9730 request_info.method = "GET";
9731 request_info.url = GURL("https://www.example.org/");
9732 request_info.traffic_annotation =
9733 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
9734 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
9735 net_log_, CompletionOnceCallback()));
9736
9737 // Ensure that session is alive and active.
9738 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
9739 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
9740 EXPECT_TRUE(HasActiveSession(host_port_pair_));
9741
9742 // Set up second socket data provider that is used after
9743 // migration. The request is written to this new socket, and the
9744 // response to the request is read on this new socket.
9745 MockQuicData socket_data1(version_);
9746 socket_data1.AddWrite(
9747 SYNCHRONOUS,
9748 ConstructGetRequestPacket(packet_num++,
9749 GetNthClientInitiatedBidirectionalStreamId(0),
9750 true, true));
9751 socket_data1.AddRead(
9752 ASYNC,
9753 ConstructOkResponsePacket(
9754 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false));
9755
9756 socket_data1.AddRead(ASYNC, ERR_IO_PENDING); // Pause.
9757 socket_data1.AddRead(ASYNC, ERR_FAILED); // Read error to close connection.
9758 socket_data1.AddSocketDataToFactory(socket_factory_.get());
9759
9760 EXPECT_EQ(0u, task_runner->GetPendingTaskCount());
9761 // Send GET request on stream.
9762 HttpResponseInfo response;
9763 HttpRequestHeaders request_headers;
9764 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
9765 callback_.callback()));
9766 // Run the message loop to complete asynchronous write and read with errors.
9767 base::RunLoop().RunUntilIdle();
9768 // There will be one pending task to complete migration on write error.
9769 // Verify session is not closed with read error.
9770 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
9771 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
9772 EXPECT_TRUE(HasActiveSession(host_port_pair_));
9773 EXPECT_EQ(1u, session->GetNumActiveStreams());
9774
9775 // Complete migration.
9776 task_runner->RunUntilIdle();
9777 // There will be one more task posted attempting to migrate back to the
9778 // default network.
9779 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
9780 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
9781 EXPECT_TRUE(HasActiveSession(host_port_pair_));
9782 EXPECT_EQ(1u, session->GetNumActiveStreams());
9783
9784 // Verify that response headers on the migrated socket were delivered to the
9785 // stream.
9786 EXPECT_EQ(OK, stream->ReadResponseHeaders(callback_.callback()));
9787 EXPECT_EQ(200, response.headers->response_code());
9788
9789 // Resume to consume the read error on new socket, which will close
9790 // the connection.
9791 socket_data1.Resume();
9792
9793 EXPECT_TRUE(socket_data.AllReadDataConsumed());
9794 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
9795 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
9796 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
9797 }
9798
9799 // Migrate on asynchronous write error, old network disconnects after alternate
9800 // network connects.
TEST_P(QuicStreamFactoryTest,MigrateSessionOnWriteErrorWithDisconnectAfterConnectAsync)9801 TEST_P(QuicStreamFactoryTest,
9802 MigrateSessionOnWriteErrorWithDisconnectAfterConnectAsync) {
9803 TestMigrationOnWriteErrorWithMultipleNotifications(
9804 ASYNC, /*disconnect_before_connect*/ false);
9805 }
9806
9807 // Migrate on synchronous write error, old network disconnects after alternate
9808 // network connects.
TEST_P(QuicStreamFactoryTest,MigrateSessionOnWriteErrorWithDisconnectAfterConnectSync)9809 TEST_P(QuicStreamFactoryTest,
9810 MigrateSessionOnWriteErrorWithDisconnectAfterConnectSync) {
9811 TestMigrationOnWriteErrorWithMultipleNotifications(
9812 SYNCHRONOUS, /*disconnect_before_connect*/ false);
9813 }
9814
9815 // Migrate on asynchronous write error, old network disconnects before alternate
9816 // network connects.
TEST_P(QuicStreamFactoryTest,MigrateSessionOnWriteErrorWithDisconnectBeforeConnectAsync)9817 TEST_P(QuicStreamFactoryTest,
9818 MigrateSessionOnWriteErrorWithDisconnectBeforeConnectAsync) {
9819 TestMigrationOnWriteErrorWithMultipleNotifications(
9820 ASYNC, /*disconnect_before_connect*/ true);
9821 }
9822
9823 // Migrate on synchronous write error, old network disconnects before alternate
9824 // network connects.
TEST_P(QuicStreamFactoryTest,MigrateSessionOnWriteErrorWithDisconnectBeforeConnectSync)9825 TEST_P(QuicStreamFactoryTest,
9826 MigrateSessionOnWriteErrorWithDisconnectBeforeConnectSync) {
9827 TestMigrationOnWriteErrorWithMultipleNotifications(
9828 SYNCHRONOUS, /*disconnect_before_connect*/ true);
9829 }
9830
9831 // Setps up test which verifies that session successfully migrate to alternate
9832 // network with signals delivered in the following order:
9833 // *NOTE* Signal (A) and (B) can reverse order based on
9834 // |disconnect_before_connect|.
9835 // - (No alternate network is connected) session connects to
9836 // kDefaultNetworkForTests.
9837 // - An async/sync write error is encountered based on |write_error_mode|:
9838 // session posted task to migrate session on write error.
9839 // - Posted task is executed, miration moves to pending state due to lack of
9840 // alternate network.
9841 // - (A) An alternate network is connected, pending migration completes.
9842 // - (B) Old default network disconnects, no migration will be attempted as
9843 // session has already migrate to the alternate network.
9844 // - The alternate network is made default.
9845 void QuicStreamFactoryTestBase::
TestMigrationOnWriteErrorWithMultipleNotifications(IoMode write_error_mode,bool disconnect_before_connect)9846 TestMigrationOnWriteErrorWithMultipleNotifications(
9847 IoMode write_error_mode,
9848 bool disconnect_before_connect) {
9849 InitializeConnectionMigrationV2Test({kDefaultNetworkForTests});
9850 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
9851 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
9852 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
9853
9854 MockQuicData socket_data(version_);
9855 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
9856 int packet_num = 1;
9857 if (VersionUsesHttp3(version_.transport_version)) {
9858 socket_data.AddWrite(SYNCHRONOUS,
9859 ConstructInitialSettingsPacket(packet_num++));
9860 }
9861 socket_data.AddWrite(write_error_mode, ERR_FAILED); // Write error.
9862 socket_data.AddSocketDataToFactory(socket_factory_.get());
9863
9864 // Create request and QuicHttpStream.
9865 QuicStreamRequest request(factory_.get());
9866 EXPECT_EQ(
9867 ERR_IO_PENDING,
9868 request.Request(
9869 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
9870 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
9871 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
9872 failed_on_default_network_callback_, callback_.callback()));
9873 EXPECT_EQ(OK, callback_.WaitForResult());
9874 std::unique_ptr<HttpStream> stream = CreateStream(&request);
9875 EXPECT_TRUE(stream.get());
9876
9877 // Cause QUIC stream to be created.
9878 HttpRequestInfo request_info;
9879 request_info.method = "GET";
9880 request_info.url = GURL("https://www.example.org/");
9881 request_info.traffic_annotation =
9882 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
9883 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
9884 net_log_, CompletionOnceCallback()));
9885
9886 // Ensure that session is alive and active.
9887 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
9888 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
9889 EXPECT_TRUE(HasActiveSession(host_port_pair_));
9890
9891 // Send GET request on stream. This should cause a write error, which triggers
9892 // a connection migration attempt.
9893 HttpResponseInfo response;
9894 HttpRequestHeaders request_headers;
9895 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
9896 callback_.callback()));
9897 // Run the message loop so that posted task to migrate to socket will be
9898 // executed. A new task will be posted to wait for a new network.
9899 base::RunLoop().RunUntilIdle();
9900
9901 // In this particular code path, the network will not yet be marked
9902 // as going away and the session will still be alive.
9903 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
9904 EXPECT_TRUE(HasActiveSession(host_port_pair_));
9905 EXPECT_EQ(1u, session->GetNumActiveStreams());
9906 EXPECT_EQ(ERR_IO_PENDING, stream->ReadResponseHeaders(callback_.callback()));
9907
9908 // Set up second socket data provider that is used after
9909 // migration. The request is rewritten to this new socket, and the
9910 // response to the request is read on this new socket.
9911 MockQuicData socket_data1(version_);
9912 socket_data1.AddWrite(
9913 SYNCHRONOUS,
9914 ConstructGetRequestPacket(packet_num++,
9915 GetNthClientInitiatedBidirectionalStreamId(0),
9916 true, true));
9917 socket_data1.AddRead(
9918 ASYNC,
9919 ConstructOkResponsePacket(
9920 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false));
9921 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
9922 if (VersionUsesHttp3(version_.transport_version)) {
9923 socket_data1.AddWrite(
9924 SYNCHRONOUS, client_maker_.MakeAckAndDataPacket(
9925 packet_num++, false, GetQpackDecoderStreamId(), 1, 1,
9926 false, StreamCancellationQpackDecoderInstruction(0)));
9927 socket_data1.AddWrite(
9928 SYNCHRONOUS,
9929 client_maker_.MakeRstPacket(
9930 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
9931 quic::QUIC_STREAM_CANCELLED));
9932 } else {
9933 socket_data1.AddWrite(
9934 SYNCHRONOUS,
9935 client_maker_.MakeAckAndRstPacket(
9936 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
9937 quic::QUIC_STREAM_CANCELLED, 1, 1));
9938 }
9939 socket_data1.AddSocketDataToFactory(socket_factory_.get());
9940
9941 scoped_mock_network_change_notifier_->mock_network_change_notifier()
9942 ->SetConnectedNetworksList(
9943 {kDefaultNetworkForTests, kNewNetworkForTests});
9944 if (disconnect_before_connect) {
9945 // Now deliver a DISCONNECT notification.
9946 scoped_mock_network_change_notifier_->mock_network_change_notifier()
9947 ->NotifyNetworkDisconnected(kDefaultNetworkForTests);
9948
9949 // Now deliver a CONNECTED notification and completes migration.
9950 scoped_mock_network_change_notifier_->mock_network_change_notifier()
9951 ->NotifyNetworkConnected(kNewNetworkForTests);
9952 } else {
9953 // Now deliver a CONNECTED notification and completes migration.
9954 scoped_mock_network_change_notifier_->mock_network_change_notifier()
9955 ->NotifyNetworkConnected(kNewNetworkForTests);
9956
9957 // Now deliver a DISCONNECT notification.
9958 scoped_mock_network_change_notifier_->mock_network_change_notifier()
9959 ->NotifyNetworkDisconnected(kDefaultNetworkForTests);
9960 }
9961 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
9962 EXPECT_TRUE(HasActiveSession(host_port_pair_));
9963 EXPECT_EQ(1u, session->GetNumActiveStreams());
9964
9965 // This is the callback for the response headers that returned
9966 // pending previously, because no result was available. Check that
9967 // the result is now available due to the successful migration.
9968 EXPECT_THAT(callback_.WaitForResult(), IsOk());
9969 EXPECT_EQ(200, response.headers->response_code());
9970
9971 // Deliver a MADEDEFAULT notification.
9972 scoped_mock_network_change_notifier_->mock_network_change_notifier()
9973 ->NotifyNetworkMadeDefault(kNewNetworkForTests);
9974
9975 QuicStreamRequest request2(factory_.get());
9976 EXPECT_EQ(
9977 OK,
9978 request2.Request(
9979 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
9980 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
9981 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
9982 failed_on_default_network_callback_, callback_.callback()));
9983 std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
9984 EXPECT_TRUE(stream2.get());
9985
9986 EXPECT_TRUE(HasActiveSession(host_port_pair_));
9987 EXPECT_EQ(session, GetActiveSession(host_port_pair_));
9988
9989 stream.reset();
9990 stream2.reset();
9991
9992 EXPECT_TRUE(socket_data.AllReadDataConsumed());
9993 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
9994 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
9995 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
9996 }
9997
9998 // This test verifies after session migrates off the default network, it keeps
9999 // retrying migrate back to the default network until successfully gets on the
10000 // default network or the idle migration period threshold is exceeded.
10001 // The default threshold is 30s.
TEST_P(QuicStreamFactoryTest,DefaultIdleMigrationPeriod)10002 TEST_P(QuicStreamFactoryTest, DefaultIdleMigrationPeriod) {
10003 quic_params_->migrate_idle_sessions = true;
10004 InitializeConnectionMigrationV2Test(
10005 {kDefaultNetworkForTests, kNewNetworkForTests});
10006 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
10007 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
10008
10009 // Using a testing task runner and a test tick tock.
10010 auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
10011 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
10012 QuicStreamFactoryPeer::SetTickClock(factory_.get(),
10013 task_runner->GetMockTickClock());
10014
10015 MockQuicData default_socket_data(version_);
10016 default_socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
10017 int packet_num = 1;
10018 if (VersionUsesHttp3(version_.transport_version)) {
10019 default_socket_data.AddWrite(SYNCHRONOUS,
10020 ConstructInitialSettingsPacket(packet_num++));
10021 }
10022 default_socket_data.AddSocketDataToFactory(socket_factory_.get());
10023
10024 // Set up second socket data provider that is used after migration.
10025 MockQuicData alternate_socket_data(version_);
10026 alternate_socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read.
10027 // Ping packet to send after migration.
10028 alternate_socket_data.AddWrite(
10029 SYNCHRONOUS,
10030 client_maker_.MakePingPacket(packet_num++, /*include_version=*/true));
10031 alternate_socket_data.AddSocketDataToFactory(socket_factory_.get());
10032
10033 // Set up probing socket for migrating back to the default network.
10034 MockQuicData quic_data(version_); // retry count: 0.
10035 quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read.
10036 quic_data.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE);
10037 quic_data.AddSocketDataToFactory(socket_factory_.get());
10038
10039 MockQuicData quic_data1(version_); // retry count: 1
10040 quic_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read.
10041 quic_data1.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE);
10042 quic_data1.AddSocketDataToFactory(socket_factory_.get());
10043
10044 MockQuicData quic_data2(version_); // retry count: 2
10045 quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read.
10046 quic_data2.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE);
10047 quic_data2.AddSocketDataToFactory(socket_factory_.get());
10048
10049 MockQuicData quic_data3(version_); // retry count: 3
10050 quic_data3.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read.
10051 quic_data3.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE);
10052 quic_data3.AddSocketDataToFactory(socket_factory_.get());
10053
10054 MockQuicData quic_data4(version_); // retry count: 4
10055 quic_data4.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read.
10056 quic_data4.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE);
10057 quic_data4.AddSocketDataToFactory(socket_factory_.get());
10058
10059 MockQuicData quic_data5(version_); // retry count: 5
10060 quic_data5.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read.
10061 quic_data5.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE);
10062 quic_data5.AddSocketDataToFactory(socket_factory_.get());
10063
10064 // Create request and QuicHttpStream.
10065 QuicStreamRequest request(factory_.get());
10066 EXPECT_EQ(
10067 ERR_IO_PENDING,
10068 request.Request(
10069 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
10070 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
10071 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
10072 failed_on_default_network_callback_, callback_.callback()));
10073 EXPECT_THAT(callback_.WaitForResult(), IsOk());
10074 std::unique_ptr<HttpStream> stream = CreateStream(&request);
10075 EXPECT_TRUE(stream.get());
10076
10077 // Ensure that session is active.
10078 EXPECT_TRUE(HasActiveSession(host_port_pair_));
10079
10080 // Trigger connection migration. Since there are no active streams,
10081 // the session will be closed.
10082 scoped_mock_network_change_notifier_->mock_network_change_notifier()
10083 ->NotifyNetworkDisconnected(kDefaultNetworkForTests);
10084
10085 // The nearest task will complete migration.
10086 EXPECT_EQ(2u, task_runner->GetPendingTaskCount());
10087 EXPECT_EQ(base::TimeDelta(), task_runner->NextPendingTaskDelay());
10088 task_runner->FastForwardBy(base::TimeDelta());
10089
10090 // The migrate back timer will fire. Due to default network
10091 // being disconnected, no attempt will be exercised to migrate back.
10092 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
10093 EXPECT_EQ(base::TimeDelta::FromSeconds(kMinRetryTimeForDefaultNetworkSecs),
10094 task_runner->NextPendingTaskDelay());
10095 task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
10096 EXPECT_EQ(0u, task_runner->GetPendingTaskCount());
10097
10098 // Deliver the signal that the old default network now backs up.
10099 scoped_mock_network_change_notifier_->mock_network_change_notifier()
10100 ->NotifyNetworkMadeDefault(kDefaultNetworkForTests);
10101
10102 // A task is posted to migrate back to the default network immediately.
10103 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
10104 EXPECT_EQ(base::TimeDelta(), task_runner->NextPendingTaskDelay());
10105 task_runner->FastForwardBy(base::TimeDelta());
10106
10107 // Retry migrate back in 1, 2, 4, 8, 16s.
10108 // Session will be closed due to idle migration timeout.
10109 for (int i = 0; i < 5; i++) {
10110 EXPECT_TRUE(HasActiveSession(host_port_pair_));
10111 // A task is posted to migrate back to the default network in 2^i seconds.
10112 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
10113 EXPECT_EQ(base::TimeDelta::FromSeconds(UINT64_C(1) << i),
10114 task_runner->NextPendingTaskDelay());
10115 task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
10116 }
10117
10118 EXPECT_TRUE(default_socket_data.AllReadDataConsumed());
10119 EXPECT_TRUE(default_socket_data.AllWriteDataConsumed());
10120 EXPECT_TRUE(alternate_socket_data.AllReadDataConsumed());
10121 EXPECT_TRUE(alternate_socket_data.AllWriteDataConsumed());
10122 }
10123
TEST_P(QuicStreamFactoryTest,CustomIdleMigrationPeriod)10124 TEST_P(QuicStreamFactoryTest, CustomIdleMigrationPeriod) {
10125 // The customized threshold is 15s.
10126 quic_params_->migrate_idle_sessions = true;
10127 quic_params_->idle_session_migration_period =
10128 base::TimeDelta::FromSeconds(15);
10129 InitializeConnectionMigrationV2Test(
10130 {kDefaultNetworkForTests, kNewNetworkForTests});
10131 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
10132 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
10133
10134 // Using a testing task runner and a test tick tock.
10135 auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
10136 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
10137 QuicStreamFactoryPeer::SetTickClock(factory_.get(),
10138 task_runner->GetMockTickClock());
10139
10140 MockQuicData default_socket_data(version_);
10141 default_socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
10142 int packet_num = 1;
10143 if (VersionUsesHttp3(version_.transport_version)) {
10144 default_socket_data.AddWrite(SYNCHRONOUS,
10145 ConstructInitialSettingsPacket(packet_num++));
10146 }
10147 default_socket_data.AddSocketDataToFactory(socket_factory_.get());
10148
10149 // Set up second socket data provider that is used after migration.
10150 MockQuicData alternate_socket_data(version_);
10151 alternate_socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read.
10152 // Ping packet to send after migration.
10153 alternate_socket_data.AddWrite(
10154 SYNCHRONOUS,
10155 client_maker_.MakePingPacket(packet_num++, /*include_version=*/true));
10156 alternate_socket_data.AddSocketDataToFactory(socket_factory_.get());
10157
10158 // Set up probing socket for migrating back to the default network.
10159 MockQuicData quic_data(version_); // retry count: 0.
10160 quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read.
10161 quic_data.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE);
10162 quic_data.AddSocketDataToFactory(socket_factory_.get());
10163
10164 MockQuicData quic_data1(version_); // retry count: 1
10165 quic_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read.
10166 quic_data1.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE);
10167 quic_data1.AddSocketDataToFactory(socket_factory_.get());
10168
10169 MockQuicData quic_data2(version_); // retry count: 2
10170 quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read.
10171 quic_data2.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE);
10172 quic_data2.AddSocketDataToFactory(socket_factory_.get());
10173
10174 MockQuicData quic_data3(version_); // retry count: 3
10175 quic_data3.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read.
10176 quic_data3.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE);
10177 quic_data3.AddSocketDataToFactory(socket_factory_.get());
10178
10179 MockQuicData quic_data4(version_); // retry count: 4
10180 quic_data4.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // Hanging read.
10181 quic_data4.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE);
10182 quic_data4.AddSocketDataToFactory(socket_factory_.get());
10183
10184 // Create request and QuicHttpStream.
10185 QuicStreamRequest request(factory_.get());
10186 EXPECT_EQ(
10187 ERR_IO_PENDING,
10188 request.Request(
10189 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
10190 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
10191 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
10192 failed_on_default_network_callback_, callback_.callback()));
10193 EXPECT_THAT(callback_.WaitForResult(), IsOk());
10194 std::unique_ptr<HttpStream> stream = CreateStream(&request);
10195 EXPECT_TRUE(stream.get());
10196
10197 // Ensure that session is active.
10198 EXPECT_TRUE(HasActiveSession(host_port_pair_));
10199
10200 // Trigger connection migration. Since there are no active streams,
10201 // the session will be closed.
10202 scoped_mock_network_change_notifier_->mock_network_change_notifier()
10203 ->NotifyNetworkDisconnected(kDefaultNetworkForTests);
10204
10205 // The nearest task will complete migration.
10206 EXPECT_EQ(2u, task_runner->GetPendingTaskCount());
10207 EXPECT_EQ(base::TimeDelta(), task_runner->NextPendingTaskDelay());
10208 task_runner->FastForwardBy(base::TimeDelta());
10209
10210 // The migrate back timer will fire. Due to default network
10211 // being disconnected, no attempt will be exercised to migrate back.
10212 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
10213 EXPECT_EQ(base::TimeDelta::FromSeconds(kMinRetryTimeForDefaultNetworkSecs),
10214 task_runner->NextPendingTaskDelay());
10215 task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
10216 EXPECT_EQ(0u, task_runner->GetPendingTaskCount());
10217
10218 // Deliver the signal that the old default network now backs up.
10219 scoped_mock_network_change_notifier_->mock_network_change_notifier()
10220 ->NotifyNetworkMadeDefault(kDefaultNetworkForTests);
10221
10222 // A task is posted to migrate back to the default network immediately.
10223 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
10224 EXPECT_EQ(base::TimeDelta(), task_runner->NextPendingTaskDelay());
10225 task_runner->FastForwardBy(base::TimeDelta());
10226
10227 // Retry migrate back in 1, 2, 4, 8s.
10228 // Session will be closed due to idle migration timeout.
10229 for (int i = 0; i < 4; i++) {
10230 EXPECT_TRUE(HasActiveSession(host_port_pair_));
10231 // A task is posted to migrate back to the default network in 2^i seconds.
10232 EXPECT_EQ(1u, task_runner->GetPendingTaskCount());
10233 EXPECT_EQ(base::TimeDelta::FromSeconds(UINT64_C(1) << i),
10234 task_runner->NextPendingTaskDelay());
10235 task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
10236 }
10237
10238 EXPECT_TRUE(default_socket_data.AllReadDataConsumed());
10239 EXPECT_TRUE(default_socket_data.AllWriteDataConsumed());
10240 EXPECT_TRUE(alternate_socket_data.AllReadDataConsumed());
10241 EXPECT_TRUE(alternate_socket_data.AllWriteDataConsumed());
10242 }
10243
TEST_P(QuicStreamFactoryTest,ServerMigration)10244 TEST_P(QuicStreamFactoryTest, ServerMigration) {
10245 quic_params_->allow_server_migration = true;
10246 Initialize();
10247
10248 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
10249 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
10250 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
10251
10252 MockQuicData socket_data1(version_);
10253 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
10254 int packet_num = 1;
10255 if (VersionUsesHttp3(version_.transport_version)) {
10256 socket_data1.AddWrite(SYNCHRONOUS,
10257 ConstructInitialSettingsPacket(packet_num++));
10258 }
10259 socket_data1.AddWrite(
10260 SYNCHRONOUS,
10261 ConstructGetRequestPacket(packet_num++,
10262 GetNthClientInitiatedBidirectionalStreamId(0),
10263 true, true));
10264 socket_data1.AddSocketDataToFactory(socket_factory_.get());
10265
10266 // Create request and QuicHttpStream.
10267 QuicStreamRequest request(factory_.get());
10268 EXPECT_EQ(
10269 ERR_IO_PENDING,
10270 request.Request(
10271 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
10272 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
10273 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
10274 failed_on_default_network_callback_, callback_.callback()));
10275 EXPECT_EQ(OK, callback_.WaitForResult());
10276 std::unique_ptr<HttpStream> stream = CreateStream(&request);
10277 EXPECT_TRUE(stream.get());
10278
10279 // Cause QUIC stream to be created.
10280 HttpRequestInfo request_info;
10281 request_info.method = "GET";
10282 request_info.url = GURL("https://www.example.org/");
10283 request_info.traffic_annotation =
10284 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
10285 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
10286 net_log_, CompletionOnceCallback()));
10287
10288 // Ensure that session is alive and active.
10289 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
10290 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
10291 EXPECT_TRUE(HasActiveSession(host_port_pair_));
10292
10293 // Send GET request on stream.
10294 HttpResponseInfo response;
10295 HttpRequestHeaders request_headers;
10296 EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
10297 callback_.callback()));
10298
10299 IPEndPoint ip;
10300 session->GetDefaultSocket()->GetPeerAddress(&ip);
10301 DVLOG(1) << "Socket connected to: " << ip.address().ToString() << " "
10302 << ip.port();
10303
10304 // Set up second socket data provider that is used after
10305 // migration. The request is rewritten to this new socket, and the
10306 // response to the request is read on this new socket.
10307 MockQuicData socket_data2(version_);
10308 socket_data2.AddWrite(
10309 SYNCHRONOUS,
10310 client_maker_.MakePingPacket(packet_num++, /*include_version=*/true));
10311 socket_data2.AddRead(
10312 ASYNC,
10313 ConstructOkResponsePacket(
10314 1, GetNthClientInitiatedBidirectionalStreamId(0), false, false));
10315 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
10316 if (VersionUsesHttp3(version_.transport_version)) {
10317 socket_data2.AddWrite(
10318 SYNCHRONOUS, client_maker_.MakeAckAndDataPacket(
10319 packet_num++, false, GetQpackDecoderStreamId(), 1, 1,
10320 false, StreamCancellationQpackDecoderInstruction(0)));
10321 socket_data2.AddWrite(
10322 SYNCHRONOUS,
10323 client_maker_.MakeRstPacket(
10324 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
10325 quic::QUIC_STREAM_CANCELLED));
10326 } else {
10327 socket_data2.AddWrite(
10328 SYNCHRONOUS,
10329 client_maker_.MakeAckAndRstPacket(
10330 packet_num++, false, GetNthClientInitiatedBidirectionalStreamId(0),
10331 quic::QUIC_STREAM_CANCELLED, 1, 1));
10332 }
10333 socket_data2.AddSocketDataToFactory(socket_factory_.get());
10334
10335 const uint8_t kTestIpAddress[] = {1, 2, 3, 4};
10336 const uint16_t kTestPort = 123;
10337 session->Migrate(NetworkChangeNotifier::kInvalidNetworkHandle,
10338 IPEndPoint(IPAddress(kTestIpAddress), kTestPort), true);
10339
10340 session->GetDefaultSocket()->GetPeerAddress(&ip);
10341 DVLOG(1) << "Socket migrated to: " << ip.address().ToString() << " "
10342 << ip.port();
10343
10344 // The session should be alive and active.
10345 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
10346 EXPECT_TRUE(HasActiveSession(host_port_pair_));
10347 EXPECT_EQ(1u, session->GetNumActiveStreams());
10348
10349 // Run the message loop so that data queued in the new socket is read by the
10350 // packet reader.
10351 base::RunLoop().RunUntilIdle();
10352
10353 // Verify that response headers on the migrated socket were delivered to the
10354 // stream.
10355 EXPECT_EQ(OK, stream->ReadResponseHeaders(callback_.callback()));
10356 EXPECT_EQ(200, response.headers->response_code());
10357
10358 stream.reset();
10359
10360 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
10361 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
10362 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
10363 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
10364 }
10365
TEST_P(QuicStreamFactoryTest,ServerMigrationIPv4ToIPv4)10366 TEST_P(QuicStreamFactoryTest, ServerMigrationIPv4ToIPv4) {
10367 // Add alternate IPv4 server address to config.
10368 IPEndPoint alt_address = IPEndPoint(IPAddress(1, 2, 3, 4), 123);
10369 quic::QuicConfig config;
10370 config.SetIPv4AlternateServerAddressToSend(ToQuicSocketAddress(alt_address));
10371 VerifyServerMigration(config, alt_address);
10372 }
10373
TEST_P(QuicStreamFactoryTest,ServerMigrationIPv6ToIPv6)10374 TEST_P(QuicStreamFactoryTest, ServerMigrationIPv6ToIPv6) {
10375 // Add a resolver rule to make initial connection to an IPv6 address.
10376 host_resolver_->rules()->AddIPLiteralRule(host_port_pair_.host(),
10377 "fe80::aebc:32ff:febb:1e33", "");
10378 // Add alternate IPv6 server address to config.
10379 IPEndPoint alt_address = IPEndPoint(
10380 IPAddress(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16), 123);
10381 quic::QuicConfig config;
10382 config.SetIPv6AlternateServerAddressToSend(ToQuicSocketAddress(alt_address));
10383 VerifyServerMigration(config, alt_address);
10384 }
10385
TEST_P(QuicStreamFactoryTest,ServerMigrationIPv6ToIPv4Fails)10386 TEST_P(QuicStreamFactoryTest, ServerMigrationIPv6ToIPv4Fails) {
10387 quic_params_->allow_server_migration = true;
10388 Initialize();
10389
10390 // Add a resolver rule to make initial connection to an IPv6 address.
10391 host_resolver_->rules()->AddIPLiteralRule(host_port_pair_.host(),
10392 "fe80::aebc:32ff:febb:1e33", "");
10393 // Add alternate IPv4 server address to config.
10394 IPEndPoint alt_address = IPEndPoint(IPAddress(1, 2, 3, 4), 123);
10395 quic::QuicConfig config;
10396 config.SetIPv4AlternateServerAddressToSend(ToQuicSocketAddress(alt_address));
10397
10398 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
10399 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
10400 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
10401
10402 crypto_client_stream_factory_.SetConfig(config);
10403
10404 // Set up only socket data provider.
10405 MockQuicData socket_data1(version_);
10406 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
10407 int packet_num = 1;
10408 if (VersionUsesHttp3(version_.transport_version)) {
10409 socket_data1.AddWrite(SYNCHRONOUS,
10410 ConstructInitialSettingsPacket(packet_num++));
10411 socket_data1.AddWrite(
10412 SYNCHRONOUS, client_maker_.MakeDataPacket(
10413 packet_num++, GetQpackDecoderStreamId(), true, false,
10414 StreamCancellationQpackDecoderInstruction(0)));
10415 }
10416 socket_data1.AddWrite(
10417 SYNCHRONOUS,
10418 client_maker_.MakeRstPacket(packet_num++, true,
10419 GetNthClientInitiatedBidirectionalStreamId(0),
10420 quic::QUIC_STREAM_CANCELLED));
10421 socket_data1.AddSocketDataToFactory(socket_factory_.get());
10422
10423 // Create request and QuicHttpStream.
10424 QuicStreamRequest request(factory_.get());
10425 EXPECT_EQ(
10426 ERR_IO_PENDING,
10427 request.Request(
10428 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
10429 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
10430 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
10431 failed_on_default_network_callback_, callback_.callback()));
10432 EXPECT_EQ(OK, callback_.WaitForResult());
10433 std::unique_ptr<HttpStream> stream = CreateStream(&request);
10434 EXPECT_TRUE(stream.get());
10435
10436 // Cause QUIC stream to be created.
10437 HttpRequestInfo request_info;
10438 request_info.method = "GET";
10439 request_info.url = GURL("https://www.example.org/");
10440 request_info.traffic_annotation =
10441 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
10442 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
10443 net_log_, CompletionOnceCallback()));
10444
10445 // Ensure that session is alive and active.
10446 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
10447 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
10448 EXPECT_TRUE(HasActiveSession(host_port_pair_));
10449
10450 IPEndPoint actual_address;
10451 session->GetDefaultSocket()->GetPeerAddress(&actual_address);
10452 // No migration should have happened.
10453 IPEndPoint expected_address =
10454 IPEndPoint(IPAddress(0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0xae, 0xbc, 0x32, 0xff,
10455 0xfe, 0xbb, 0x1e, 0x33),
10456 kDefaultServerPort);
10457 EXPECT_EQ(actual_address, expected_address);
10458 DVLOG(1) << "Socket connected to: " << actual_address.address().ToString()
10459 << " " << actual_address.port();
10460 DVLOG(1) << "Expected address: " << expected_address.address().ToString()
10461 << " " << expected_address.port();
10462
10463 stream.reset();
10464 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
10465 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
10466 }
10467
TEST_P(QuicStreamFactoryTest,ServerMigrationIPv4ToIPv6Fails)10468 TEST_P(QuicStreamFactoryTest, ServerMigrationIPv4ToIPv6Fails) {
10469 quic_params_->allow_server_migration = true;
10470 Initialize();
10471
10472 // Add a resolver rule to make initial connection to an IPv4 address.
10473 host_resolver_->rules()->AddIPLiteralRule(host_port_pair_.host(), "1.2.3.4",
10474 "");
10475 // Add alternate IPv6 server address to config.
10476 IPEndPoint alt_address = IPEndPoint(
10477 IPAddress(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16), 123);
10478 quic::QuicConfig config;
10479 config.SetIPv6AlternateServerAddressToSend(ToQuicSocketAddress(alt_address));
10480
10481 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
10482 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
10483 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
10484
10485 crypto_client_stream_factory_.SetConfig(config);
10486
10487 // Set up only socket data provider.
10488 MockQuicData socket_data1(version_);
10489 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
10490 int packet_num = 1;
10491 if (VersionUsesHttp3(version_.transport_version)) {
10492 socket_data1.AddWrite(SYNCHRONOUS,
10493 ConstructInitialSettingsPacket(packet_num++));
10494 socket_data1.AddWrite(
10495 SYNCHRONOUS, client_maker_.MakeDataPacket(
10496 packet_num++, GetQpackDecoderStreamId(), true, false,
10497 StreamCancellationQpackDecoderInstruction(0)));
10498 }
10499 socket_data1.AddWrite(
10500 SYNCHRONOUS,
10501 client_maker_.MakeRstPacket(packet_num++, true,
10502 GetNthClientInitiatedBidirectionalStreamId(0),
10503 quic::QUIC_STREAM_CANCELLED));
10504 socket_data1.AddSocketDataToFactory(socket_factory_.get());
10505
10506 // Create request and QuicHttpStream.
10507 QuicStreamRequest request(factory_.get());
10508 EXPECT_EQ(
10509 ERR_IO_PENDING,
10510 request.Request(
10511 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
10512 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
10513 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
10514 failed_on_default_network_callback_, callback_.callback()));
10515 EXPECT_EQ(OK, callback_.WaitForResult());
10516 std::unique_ptr<HttpStream> stream = CreateStream(&request);
10517 EXPECT_TRUE(stream.get());
10518
10519 // Cause QUIC stream to be created.
10520 HttpRequestInfo request_info;
10521 request_info.method = "GET";
10522 request_info.url = GURL("https://www.example.org/");
10523 request_info.traffic_annotation =
10524 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
10525 EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
10526 net_log_, CompletionOnceCallback()));
10527
10528 // Ensure that session is alive and active.
10529 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
10530 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
10531 EXPECT_TRUE(HasActiveSession(host_port_pair_));
10532
10533 IPEndPoint actual_address;
10534 session->GetDefaultSocket()->GetPeerAddress(&actual_address);
10535 // No migration should have happened.
10536 IPEndPoint expected_address =
10537 IPEndPoint(IPAddress(1, 2, 3, 4), kDefaultServerPort);
10538 EXPECT_EQ(actual_address, expected_address);
10539 DVLOG(1) << "Socket connected to: " << actual_address.address().ToString()
10540 << " " << actual_address.port();
10541 DVLOG(1) << "Expected address: " << expected_address.address().ToString()
10542 << " " << expected_address.port();
10543
10544 stream.reset();
10545 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
10546 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
10547 }
10548
TEST_P(QuicStreamFactoryTest,OnCertDBChanged)10549 TEST_P(QuicStreamFactoryTest, OnCertDBChanged) {
10550 Initialize();
10551 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
10552 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
10553 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
10554
10555 MockQuicData socket_data(version_);
10556 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
10557 if (VersionUsesHttp3(version_.transport_version))
10558 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
10559 socket_data.AddSocketDataToFactory(socket_factory_.get());
10560
10561 client_maker_.Reset();
10562 MockQuicData socket_data2(version_);
10563 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
10564 if (VersionUsesHttp3(version_.transport_version))
10565 socket_data2.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
10566 socket_data2.AddSocketDataToFactory(socket_factory_.get());
10567
10568 QuicStreamRequest request(factory_.get());
10569 EXPECT_EQ(
10570 ERR_IO_PENDING,
10571 request.Request(
10572 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
10573 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
10574 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
10575 failed_on_default_network_callback_, callback_.callback()));
10576
10577 EXPECT_THAT(callback_.WaitForResult(), IsOk());
10578 std::unique_ptr<HttpStream> stream = CreateStream(&request);
10579 EXPECT_TRUE(stream);
10580 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
10581
10582 // Change the CA cert and verify that stream saw the event.
10583 factory_->OnCertDBChanged();
10584
10585 EXPECT_TRUE(factory_->is_quic_known_to_work_on_current_network());
10586 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
10587 EXPECT_FALSE(HasActiveSession(host_port_pair_));
10588
10589 // Now attempting to request a stream to the same origin should create
10590 // a new session.
10591
10592 QuicStreamRequest request2(factory_.get());
10593 EXPECT_EQ(
10594 ERR_IO_PENDING,
10595 request2.Request(
10596 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
10597 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
10598 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
10599 failed_on_default_network_callback_, callback_.callback()));
10600
10601 EXPECT_THAT(callback_.WaitForResult(), IsOk());
10602 std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
10603 EXPECT_TRUE(stream2);
10604 QuicChromiumClientSession* session2 = GetActiveSession(host_port_pair_);
10605 EXPECT_TRUE(HasActiveSession(host_port_pair_));
10606 EXPECT_NE(session, session2);
10607 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
10608 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session2));
10609
10610 stream2.reset();
10611 stream.reset();
10612
10613 EXPECT_TRUE(socket_data.AllReadDataConsumed());
10614 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
10615 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
10616 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
10617 }
10618
TEST_P(QuicStreamFactoryTest,SharedCryptoConfig)10619 TEST_P(QuicStreamFactoryTest, SharedCryptoConfig) {
10620 Initialize();
10621
10622 std::vector<string> cannoncial_suffixes;
10623 cannoncial_suffixes.push_back(string(".c.youtube.com"));
10624 cannoncial_suffixes.push_back(string(".googlevideo.com"));
10625
10626 for (unsigned i = 0; i < cannoncial_suffixes.size(); ++i) {
10627 string r1_host_name("r1");
10628 string r2_host_name("r2");
10629 r1_host_name.append(cannoncial_suffixes[i]);
10630 r2_host_name.append(cannoncial_suffixes[i]);
10631
10632 HostPortPair host_port_pair1(r1_host_name, 80);
10633 // Need to hold onto this through the test, to keep the
10634 // QuicCryptoClientConfig alive.
10635 std::unique_ptr<QuicCryptoClientConfigHandle> crypto_config_handle =
10636 QuicStreamFactoryPeer::GetCryptoConfig(factory_.get(),
10637 NetworkIsolationKey());
10638 quic::QuicServerId server_id1(host_port_pair1.host(),
10639 host_port_pair1.port(), privacy_mode_);
10640 quic::QuicCryptoClientConfig::CachedState* cached1 =
10641 crypto_config_handle->GetConfig()->LookupOrCreate(server_id1);
10642 EXPECT_FALSE(cached1->proof_valid());
10643 EXPECT_TRUE(cached1->source_address_token().empty());
10644
10645 // Mutate the cached1 to have different data.
10646 // TODO(rtenneti): mutate other members of CachedState.
10647 cached1->set_source_address_token(r1_host_name);
10648 cached1->SetProofValid();
10649
10650 HostPortPair host_port_pair2(r2_host_name, 80);
10651 quic::QuicServerId server_id2(host_port_pair2.host(),
10652 host_port_pair2.port(), privacy_mode_);
10653 quic::QuicCryptoClientConfig::CachedState* cached2 =
10654 crypto_config_handle->GetConfig()->LookupOrCreate(server_id2);
10655 EXPECT_EQ(cached1->source_address_token(), cached2->source_address_token());
10656 EXPECT_TRUE(cached2->proof_valid());
10657 }
10658 }
10659
TEST_P(QuicStreamFactoryTest,CryptoConfigWhenProofIsInvalid)10660 TEST_P(QuicStreamFactoryTest, CryptoConfigWhenProofIsInvalid) {
10661 Initialize();
10662 std::vector<string> cannoncial_suffixes;
10663 cannoncial_suffixes.push_back(string(".c.youtube.com"));
10664 cannoncial_suffixes.push_back(string(".googlevideo.com"));
10665
10666 for (unsigned i = 0; i < cannoncial_suffixes.size(); ++i) {
10667 string r3_host_name("r3");
10668 string r4_host_name("r4");
10669 r3_host_name.append(cannoncial_suffixes[i]);
10670 r4_host_name.append(cannoncial_suffixes[i]);
10671
10672 HostPortPair host_port_pair1(r3_host_name, 80);
10673 // Need to hold onto this through the test, to keep the
10674 // QuicCryptoClientConfig alive.
10675 std::unique_ptr<QuicCryptoClientConfigHandle> crypto_config_handle =
10676 QuicStreamFactoryPeer::GetCryptoConfig(factory_.get(),
10677 NetworkIsolationKey());
10678 quic::QuicServerId server_id1(host_port_pair1.host(),
10679 host_port_pair1.port(), privacy_mode_);
10680 quic::QuicCryptoClientConfig::CachedState* cached1 =
10681 crypto_config_handle->GetConfig()->LookupOrCreate(server_id1);
10682 EXPECT_FALSE(cached1->proof_valid());
10683 EXPECT_TRUE(cached1->source_address_token().empty());
10684
10685 // Mutate the cached1 to have different data.
10686 // TODO(rtenneti): mutate other members of CachedState.
10687 cached1->set_source_address_token(r3_host_name);
10688 cached1->SetProofInvalid();
10689
10690 HostPortPair host_port_pair2(r4_host_name, 80);
10691 quic::QuicServerId server_id2(host_port_pair2.host(),
10692 host_port_pair2.port(), privacy_mode_);
10693 quic::QuicCryptoClientConfig::CachedState* cached2 =
10694 crypto_config_handle->GetConfig()->LookupOrCreate(server_id2);
10695 EXPECT_NE(cached1->source_address_token(), cached2->source_address_token());
10696 EXPECT_TRUE(cached2->source_address_token().empty());
10697 EXPECT_FALSE(cached2->proof_valid());
10698 }
10699 }
10700
TEST_P(QuicStreamFactoryTest,EnableNotLoadFromDiskCache)10701 TEST_P(QuicStreamFactoryTest, EnableNotLoadFromDiskCache) {
10702 Initialize();
10703 factory_->set_is_quic_known_to_work_on_current_network(true);
10704 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
10705 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
10706
10707 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), runner_.get());
10708
10709 MockQuicData socket_data(version_);
10710 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
10711 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
10712 if (VersionUsesHttp3(version_.transport_version))
10713 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
10714 socket_data.AddSocketDataToFactory(socket_factory_.get());
10715
10716 crypto_client_stream_factory_.set_handshake_mode(
10717 MockCryptoClientStream::ZERO_RTT);
10718 host_resolver_->set_synchronous_mode(true);
10719 host_resolver_->rules()->AddIPLiteralRule(host_port_pair_.host(),
10720 "192.168.0.1", "");
10721
10722 QuicStreamRequest request(factory_.get());
10723 EXPECT_EQ(
10724 OK,
10725 request.Request(
10726 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
10727 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
10728 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
10729 failed_on_default_network_callback_, callback_.callback()));
10730
10731 // If we are waiting for disk cache, we would have posted a task. Verify that
10732 // the CancelWaitForDataReady task hasn't been posted.
10733 ASSERT_EQ(0u, runner_->GetPostedTasks().size());
10734
10735 std::unique_ptr<HttpStream> stream = CreateStream(&request);
10736 EXPECT_TRUE(stream.get());
10737 EXPECT_TRUE(socket_data.AllReadDataConsumed());
10738 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
10739 }
10740
TEST_P(QuicStreamFactoryTest,ReducePingTimeoutOnConnectionTimeOutOpenStreams)10741 TEST_P(QuicStreamFactoryTest, ReducePingTimeoutOnConnectionTimeOutOpenStreams) {
10742 quic_params_->reduced_ping_timeout = base::TimeDelta::FromSeconds(10);
10743 Initialize();
10744 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
10745 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
10746 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
10747
10748 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), runner_.get());
10749
10750 MockQuicData socket_data(version_);
10751 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
10752 if (VersionUsesHttp3(version_.transport_version))
10753 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
10754 socket_data.AddSocketDataToFactory(socket_factory_.get());
10755
10756 client_maker_.Reset();
10757 MockQuicData socket_data2(version_);
10758 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
10759 if (VersionUsesHttp3(version_.transport_version))
10760 socket_data2.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
10761 socket_data2.AddSocketDataToFactory(socket_factory_.get());
10762
10763 HostPortPair server2(kServer2HostName, kDefaultServerPort);
10764
10765 crypto_client_stream_factory_.set_handshake_mode(
10766 MockCryptoClientStream::CONFIRM_HANDSHAKE);
10767 host_resolver_->set_synchronous_mode(true);
10768 host_resolver_->rules()->AddIPLiteralRule(host_port_pair_.host(),
10769 "192.168.0.1", "");
10770 host_resolver_->rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
10771
10772 // Quic should use default PING timeout when no previous connection times out
10773 // with open stream.
10774 EXPECT_EQ(quic::QuicTime::Delta::FromSeconds(quic::kPingTimeoutSecs),
10775 QuicStreamFactoryPeer::GetPingTimeout(factory_.get()));
10776 QuicStreamRequest request(factory_.get());
10777 EXPECT_EQ(
10778 OK,
10779 request.Request(
10780 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
10781 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
10782 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
10783 failed_on_default_network_callback_, callback_.callback()));
10784
10785 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
10786 EXPECT_EQ(quic::QuicTime::Delta::FromSeconds(quic::kPingTimeoutSecs),
10787 session->connection()->ping_timeout());
10788
10789 std::unique_ptr<HttpStream> stream = CreateStream(&request);
10790 EXPECT_TRUE(stream.get());
10791 HttpRequestInfo request_info;
10792 request_info.traffic_annotation =
10793 MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
10794 EXPECT_EQ(OK, stream->InitializeStream(&request_info, false, DEFAULT_PRIORITY,
10795 net_log_, CompletionOnceCallback()));
10796
10797 DVLOG(1)
10798 << "Created 1st session and initialized a stream. Now trigger timeout";
10799 session->connection()->CloseConnection(
10800 quic::QUIC_NETWORK_IDLE_TIMEOUT, "test",
10801 quic::ConnectionCloseBehavior::SILENT_CLOSE);
10802 // Need to spin the loop now to ensure that
10803 // QuicStreamFactory::OnSessionClosed() runs.
10804 base::RunLoop run_loop;
10805 run_loop.RunUntilIdle();
10806
10807 // The first connection times out with open stream, QUIC should reduce initial
10808 // PING time for subsequent connections.
10809 EXPECT_EQ(quic::QuicTime::Delta::FromSeconds(10),
10810 QuicStreamFactoryPeer::GetPingTimeout(factory_.get()));
10811
10812 // Test two-in-a-row timeouts with open streams.
10813 DVLOG(1) << "Create 2nd session and timeout with open stream";
10814 TestCompletionCallback callback2;
10815 QuicStreamRequest request2(factory_.get());
10816 EXPECT_EQ(OK,
10817 request2.Request(
10818 server2, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
10819 NetworkIsolationKey(), false /* disable_secure_dns */,
10820 /*cert_verify_flags=*/0, url2_, net_log_, &net_error_details_,
10821 failed_on_default_network_callback_, callback2.callback()));
10822 QuicChromiumClientSession* session2 = GetActiveSession(server2);
10823 EXPECT_EQ(quic::QuicTime::Delta::FromSeconds(10),
10824 session2->connection()->ping_timeout());
10825
10826 std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
10827 EXPECT_TRUE(stream2.get());
10828 EXPECT_EQ(OK,
10829 stream2->InitializeStream(&request_info, false, DEFAULT_PRIORITY,
10830 net_log_, CompletionOnceCallback()));
10831 session2->connection()->CloseConnection(
10832 quic::QUIC_NETWORK_IDLE_TIMEOUT, "test",
10833 quic::ConnectionCloseBehavior::SILENT_CLOSE);
10834 // Need to spin the loop now to ensure that
10835 // QuicStreamFactory::OnSessionClosed() runs.
10836 base::RunLoop run_loop2;
10837 run_loop2.RunUntilIdle();
10838
10839 EXPECT_TRUE(socket_data.AllReadDataConsumed());
10840 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
10841 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
10842 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
10843 }
10844
10845 // Verifies that the QUIC stream factory is initialized correctly.
TEST_P(QuicStreamFactoryTest,MaybeInitialize)10846 TEST_P(QuicStreamFactoryTest, MaybeInitialize) {
10847 VerifyInitialization(false /* vary_network_isolation_key */);
10848 }
10849
TEST_P(QuicStreamFactoryTest,MaybeInitializeWithNetworkIsolationKey)10850 TEST_P(QuicStreamFactoryTest, MaybeInitializeWithNetworkIsolationKey) {
10851 base::test::ScopedFeatureList feature_list;
10852 feature_list.InitWithFeatures(
10853 // enabled_features
10854 {features::kPartitionHttpServerPropertiesByNetworkIsolationKey,
10855 // Need to partition connections by NetworkIsolationKey for
10856 // QuicSessionAliasKey to include NetworkIsolationKeys.
10857 features::kPartitionConnectionsByNetworkIsolationKey},
10858 // disabled_features
10859 {});
10860 // Since HttpServerProperties caches the feature value, have to create a new
10861 // one.
10862 http_server_properties_ = std::make_unique<HttpServerProperties>();
10863
10864 VerifyInitialization(true /* vary_network_isolation_key */);
10865 }
10866
10867 // Without NetworkIsolationKeys enabled for HttpServerProperties, there should
10868 // only be one global CryptoCache.
TEST_P(QuicStreamFactoryTest,CryptoConfigCache)10869 TEST_P(QuicStreamFactoryTest, CryptoConfigCache) {
10870 const char kUserAgentId[] = "spoon";
10871
10872 base::test::ScopedFeatureList feature_list;
10873 feature_list.InitAndEnableFeature(
10874 features::kPartitionConnectionsByNetworkIsolationKey);
10875
10876 const url::Origin kOrigin1 = url::Origin::Create(GURL("https://foo.test/"));
10877 const NetworkIsolationKey kNetworkIsolationKey1(kOrigin1, kOrigin1);
10878
10879 const url::Origin kOrigin2 = url::Origin::Create(GURL("https://bar.test/"));
10880 const NetworkIsolationKey kNetworkIsolationKey2(kOrigin2, kOrigin2);
10881
10882 const url::Origin kOrigin3 = url::Origin::Create(GURL("https://baz.test/"));
10883 const NetworkIsolationKey kNetworkIsolationKey3(kOrigin3, kOrigin3);
10884
10885 Initialize();
10886
10887 // Create a QuicCryptoClientConfigHandle for kNetworkIsolationKey1, and set
10888 // the user agent.
10889 std::unique_ptr<QuicCryptoClientConfigHandle> crypto_config_handle1 =
10890 QuicStreamFactoryPeer::GetCryptoConfig(factory_.get(),
10891 kNetworkIsolationKey1);
10892 crypto_config_handle1->GetConfig()->set_user_agent_id(kUserAgentId);
10893 EXPECT_EQ(kUserAgentId, crypto_config_handle1->GetConfig()->user_agent_id());
10894
10895 // Create another crypto config handle using a different NetworkIsolationKey
10896 // while the first one is still alive should return the same config, with the
10897 // user agent that was just set.
10898 std::unique_ptr<QuicCryptoClientConfigHandle> crypto_config_handle2 =
10899 QuicStreamFactoryPeer::GetCryptoConfig(factory_.get(),
10900 kNetworkIsolationKey2);
10901 EXPECT_EQ(kUserAgentId, crypto_config_handle2->GetConfig()->user_agent_id());
10902
10903 // Destroying both handles and creating a new one with yet another
10904 // NetworkIsolationKey should again return the same config.
10905 crypto_config_handle1.reset();
10906 crypto_config_handle2.reset();
10907
10908 std::unique_ptr<QuicCryptoClientConfigHandle> crypto_config_handle3 =
10909 QuicStreamFactoryPeer::GetCryptoConfig(factory_.get(),
10910 kNetworkIsolationKey3);
10911 EXPECT_EQ(kUserAgentId, crypto_config_handle3->GetConfig()->user_agent_id());
10912 }
10913
10914 // With different NetworkIsolationKeys enabled for HttpServerProperties, there
10915 // should only be one global CryptoCache per NetworkIsolationKey.
TEST_P(QuicStreamFactoryTest,CryptoConfigCacheWithNetworkIsolationKey)10916 TEST_P(QuicStreamFactoryTest, CryptoConfigCacheWithNetworkIsolationKey) {
10917 const char kUserAgentId1[] = "spoon";
10918 const char kUserAgentId2[] = "fork";
10919 const char kUserAgentId3[] = "another spoon";
10920
10921 base::test::ScopedFeatureList feature_list;
10922 feature_list.InitWithFeatures(
10923 // enabled_features
10924 {features::kPartitionHttpServerPropertiesByNetworkIsolationKey,
10925 // Need to partition connections by NetworkIsolationKey for
10926 // QuicSessionAliasKey to include NetworkIsolationKeys.
10927 features::kPartitionConnectionsByNetworkIsolationKey},
10928 // disabled_features
10929 {});
10930
10931 const url::Origin kOrigin1 = url::Origin::Create(GURL("https://foo.test/"));
10932 const NetworkIsolationKey kNetworkIsolationKey1(kOrigin1, kOrigin1);
10933
10934 const url::Origin kOrigin2 = url::Origin::Create(GURL("https://bar.test/"));
10935 const NetworkIsolationKey kNetworkIsolationKey2(kOrigin2, kOrigin2);
10936
10937 const url::Origin kOrigin3 = url::Origin::Create(GURL("https://baz.test/"));
10938 const NetworkIsolationKey kNetworkIsolationKey3(kOrigin3, kOrigin3);
10939
10940 Initialize();
10941
10942 // Create a QuicCryptoClientConfigHandle for kNetworkIsolationKey1, and set
10943 // the user agent.
10944 std::unique_ptr<QuicCryptoClientConfigHandle> crypto_config_handle1 =
10945 QuicStreamFactoryPeer::GetCryptoConfig(factory_.get(),
10946 kNetworkIsolationKey1);
10947 crypto_config_handle1->GetConfig()->set_user_agent_id(kUserAgentId1);
10948 EXPECT_EQ(kUserAgentId1, crypto_config_handle1->GetConfig()->user_agent_id());
10949
10950 // Create another crypto config handle using a different NetworkIsolationKey
10951 // while the first one is still alive should return a different config.
10952 std::unique_ptr<QuicCryptoClientConfigHandle> crypto_config_handle2 =
10953 QuicStreamFactoryPeer::GetCryptoConfig(factory_.get(),
10954 kNetworkIsolationKey2);
10955 EXPECT_EQ("", crypto_config_handle2->GetConfig()->user_agent_id());
10956 crypto_config_handle2->GetConfig()->set_user_agent_id(kUserAgentId2);
10957 EXPECT_EQ(kUserAgentId1, crypto_config_handle1->GetConfig()->user_agent_id());
10958 EXPECT_EQ(kUserAgentId2, crypto_config_handle2->GetConfig()->user_agent_id());
10959
10960 // Creating handles with the same NIKs while the old handles are still alive
10961 // should result in getting the same CryptoConfigs.
10962 std::unique_ptr<QuicCryptoClientConfigHandle> crypto_config_handle1_2 =
10963 QuicStreamFactoryPeer::GetCryptoConfig(factory_.get(),
10964 kNetworkIsolationKey1);
10965 std::unique_ptr<QuicCryptoClientConfigHandle> crypto_config_handle2_2 =
10966 QuicStreamFactoryPeer::GetCryptoConfig(factory_.get(),
10967 kNetworkIsolationKey2);
10968 EXPECT_EQ(kUserAgentId1,
10969 crypto_config_handle1_2->GetConfig()->user_agent_id());
10970 EXPECT_EQ(kUserAgentId2,
10971 crypto_config_handle2_2->GetConfig()->user_agent_id());
10972
10973 // Destroying all handles and creating a new one with yet another
10974 // NetworkIsolationKey return yet another config.
10975 crypto_config_handle1.reset();
10976 crypto_config_handle2.reset();
10977 crypto_config_handle1_2.reset();
10978 crypto_config_handle2_2.reset();
10979
10980 std::unique_ptr<QuicCryptoClientConfigHandle> crypto_config_handle3 =
10981 QuicStreamFactoryPeer::GetCryptoConfig(factory_.get(),
10982 kNetworkIsolationKey3);
10983 EXPECT_EQ("", crypto_config_handle3->GetConfig()->user_agent_id());
10984 crypto_config_handle3->GetConfig()->set_user_agent_id(kUserAgentId3);
10985 EXPECT_EQ(kUserAgentId3, crypto_config_handle3->GetConfig()->user_agent_id());
10986 crypto_config_handle3.reset();
10987
10988 // The old CryptoConfigs should be recovered when creating handles with the
10989 // same NIKs as before.
10990 crypto_config_handle2 = QuicStreamFactoryPeer::GetCryptoConfig(
10991 factory_.get(), kNetworkIsolationKey2);
10992 crypto_config_handle1 = QuicStreamFactoryPeer::GetCryptoConfig(
10993 factory_.get(), kNetworkIsolationKey1);
10994 crypto_config_handle3 = QuicStreamFactoryPeer::GetCryptoConfig(
10995 factory_.get(), kNetworkIsolationKey3);
10996 EXPECT_EQ(kUserAgentId1, crypto_config_handle1->GetConfig()->user_agent_id());
10997 EXPECT_EQ(kUserAgentId2, crypto_config_handle2->GetConfig()->user_agent_id());
10998 EXPECT_EQ(kUserAgentId3, crypto_config_handle3->GetConfig()->user_agent_id());
10999 }
11000
11001 // Makes Verifies MRU behavior of the crypto config caches. Without
11002 // NetworkIsolationKeys enabled, behavior is uninteresting, since there's only
11003 // one cache, so nothing is ever evicted.
TEST_P(QuicStreamFactoryTest,CryptoConfigCacheMRUWithNetworkIsolationKey)11004 TEST_P(QuicStreamFactoryTest, CryptoConfigCacheMRUWithNetworkIsolationKey) {
11005 base::test::ScopedFeatureList feature_list;
11006 feature_list.InitWithFeatures(
11007 // enabled_features
11008 {features::kPartitionHttpServerPropertiesByNetworkIsolationKey,
11009 // Need to partition connections by NetworkIsolationKey for
11010 // QuicSessionAliasKey to include NetworkIsolationKeys.
11011 features::kPartitionConnectionsByNetworkIsolationKey},
11012 // disabled_features
11013 {});
11014
11015 const int kNumSessionsToMake = kMaxRecentCryptoConfigs + 5;
11016
11017 Initialize();
11018
11019 // Make more entries than the maximum, setting a unique user agent for each,
11020 // and keeping the handles alives.
11021 std::vector<std::unique_ptr<QuicCryptoClientConfigHandle>>
11022 crypto_config_handles;
11023 std::vector<NetworkIsolationKey> network_isolation_keys;
11024 for (int i = 0; i < kNumSessionsToMake; ++i) {
11025 url::Origin origin =
11026 url::Origin::Create(GURL(base::StringPrintf("https://foo%i.test/", i)));
11027 network_isolation_keys.push_back(NetworkIsolationKey(origin, origin));
11028
11029 std::unique_ptr<QuicCryptoClientConfigHandle> crypto_config_handle =
11030 QuicStreamFactoryPeer::GetCryptoConfig(factory_.get(),
11031 network_isolation_keys[i]);
11032 crypto_config_handle->GetConfig()->set_user_agent_id(
11033 base::NumberToString(i));
11034 crypto_config_handles.emplace_back(std::move(crypto_config_handle));
11035 }
11036
11037 // Since all the handles are still alive, nothing should be evicted yet.
11038 for (int i = 0; i < kNumSessionsToMake; ++i) {
11039 SCOPED_TRACE(i);
11040 EXPECT_EQ(base::NumberToString(i),
11041 crypto_config_handles[i]->GetConfig()->user_agent_id());
11042
11043 // A new handle for the same NIK returns the same crypto config.
11044 std::unique_ptr<QuicCryptoClientConfigHandle> crypto_config_handle =
11045 QuicStreamFactoryPeer::GetCryptoConfig(factory_.get(),
11046 network_isolation_keys[i]);
11047 EXPECT_EQ(base::NumberToString(i),
11048 crypto_config_handle->GetConfig()->user_agent_id());
11049 }
11050
11051 // Destroying the only remaining handle for a NIK results in evicting entries,
11052 // until there are exactly |kMaxRecentCryptoConfigs| handles.
11053 for (int i = 0; i < kNumSessionsToMake; ++i) {
11054 SCOPED_TRACE(i);
11055 EXPECT_EQ(base::NumberToString(i),
11056 crypto_config_handles[i]->GetConfig()->user_agent_id());
11057
11058 crypto_config_handles[i].reset();
11059
11060 // A new handle for the same NIK will return a new config, if the config was
11061 // evicted. Otherwise, it will return the same one.
11062 std::unique_ptr<QuicCryptoClientConfigHandle> crypto_config_handle =
11063 QuicStreamFactoryPeer::GetCryptoConfig(factory_.get(),
11064 network_isolation_keys[i]);
11065 if (kNumSessionsToMake - i > kNumSessionsToMake) {
11066 EXPECT_EQ("", crypto_config_handle->GetConfig()->user_agent_id());
11067 } else {
11068 EXPECT_EQ(base::NumberToString(i),
11069 crypto_config_handle->GetConfig()->user_agent_id());
11070 }
11071 }
11072 }
11073
11074 // Similar to above test, but uses real requests, and doesn't keep Handles
11075 // around, so evictions happen immediately.
TEST_P(QuicStreamFactoryTest,CryptoConfigCacheMRUWithRealRequestsAndWithNetworkIsolationKey)11076 TEST_P(QuicStreamFactoryTest,
11077 CryptoConfigCacheMRUWithRealRequestsAndWithNetworkIsolationKey) {
11078 const int kNumSessionsToMake = kMaxRecentCryptoConfigs + 5;
11079
11080 base::test::ScopedFeatureList feature_list;
11081 feature_list.InitWithFeatures(
11082 // enabled_features
11083 {features::kPartitionHttpServerPropertiesByNetworkIsolationKey,
11084 // Need to partition connections by NetworkIsolationKey for
11085 // QuicSessionAliasKey to include NetworkIsolationKeys.
11086 features::kPartitionConnectionsByNetworkIsolationKey},
11087 // disabled_features
11088 {});
11089 // Since HttpServerProperties caches the feature value, have to create a new
11090 // one.
11091 http_server_properties_ = std::make_unique<HttpServerProperties>();
11092
11093 std::vector<NetworkIsolationKey> network_isolation_keys;
11094 for (int i = 0; i < kNumSessionsToMake; ++i) {
11095 url::Origin origin =
11096 url::Origin::Create(GURL(base::StringPrintf("https://foo%i.test/", i)));
11097 network_isolation_keys.push_back(NetworkIsolationKey(origin, origin));
11098 }
11099
11100 const quic::QuicServerId kQuicServerId(
11101 kDefaultServerHostName, kDefaultServerPort, PRIVACY_MODE_DISABLED);
11102
11103 quic_params_->max_server_configs_stored_in_properties = 1;
11104 quic_params_->idle_connection_timeout = base::TimeDelta::FromSeconds(500);
11105 Initialize();
11106 factory_->set_is_quic_known_to_work_on_current_network(true);
11107 crypto_client_stream_factory_.set_handshake_mode(
11108 MockCryptoClientStream::ZERO_RTT);
11109 const quic::QuicConfig* config =
11110 QuicStreamFactoryPeer::GetConfig(factory_.get());
11111 EXPECT_EQ(500, config->IdleNetworkTimeout().ToSeconds());
11112 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
11113
11114 for (int i = 0; i < kNumSessionsToMake; ++i) {
11115 SCOPED_TRACE(i);
11116 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
11117
11118 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), runner_.get());
11119
11120 const AlternativeService alternative_service1(
11121 kProtoQUIC, host_port_pair_.host(), host_port_pair_.port());
11122 AlternativeServiceInfoVector alternative_service_info_vector;
11123 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
11124 alternative_service_info_vector.push_back(
11125 AlternativeServiceInfo::CreateQuicAlternativeServiceInfo(
11126 alternative_service1, expiration, {version_}));
11127 http_server_properties_->SetAlternativeServices(
11128 url::SchemeHostPort(url_), network_isolation_keys[i],
11129 alternative_service_info_vector);
11130
11131 http_server_properties_->SetMaxServerConfigsStoredInProperties(
11132 kDefaultMaxQuicServerEntries);
11133
11134 std::unique_ptr<QuicServerInfo> quic_server_info =
11135 std::make_unique<PropertiesBasedQuicServerInfo>(
11136 kQuicServerId, network_isolation_keys[i],
11137 http_server_properties_.get());
11138
11139 // Update quic_server_info's server_config and persist it.
11140 QuicServerInfo::State* state = quic_server_info->mutable_state();
11141 // Minimum SCFG that passes config validation checks.
11142 const char scfg[] = {// SCFG
11143 0x53, 0x43, 0x46, 0x47,
11144 // num entries
11145 0x01, 0x00,
11146 // padding
11147 0x00, 0x00,
11148 // EXPY
11149 0x45, 0x58, 0x50, 0x59,
11150 // EXPY end offset
11151 0x08, 0x00, 0x00, 0x00,
11152 // Value
11153 '1', '2', '3', '4', '5', '6', '7', '8'};
11154
11155 // Create temporary strings because Persist() clears string data in |state|.
11156 string server_config(reinterpret_cast<const char*>(&scfg), sizeof(scfg));
11157 string source_address_token("test_source_address_token");
11158 string cert_sct("test_cert_sct");
11159 string chlo_hash("test_chlo_hash");
11160 string signature("test_signature");
11161 string test_cert("test_cert");
11162 std::vector<string> certs;
11163 certs.push_back(test_cert);
11164 state->server_config = server_config;
11165 state->source_address_token = source_address_token;
11166 state->cert_sct = cert_sct;
11167 state->chlo_hash = chlo_hash;
11168 state->server_config_sig = signature;
11169 state->certs = certs;
11170
11171 quic_server_info->Persist();
11172
11173 // Create a session and verify that the cached state is loaded.
11174 MockQuicData socket_data(version_);
11175 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
11176 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
11177 if (VersionUsesHttp3(version_.transport_version))
11178 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
11179 // For the close socket message.
11180 socket_data.AddWrite(SYNCHRONOUS, ERR_IO_PENDING);
11181 socket_data.AddSocketDataToFactory(socket_factory_.get());
11182 client_maker_.Reset();
11183
11184 QuicStreamRequest request(factory_.get());
11185 int rv = request.Request(
11186 HostPortPair(kDefaultServerHostName, kDefaultServerPort), version_,
11187 privacy_mode_, DEFAULT_PRIORITY, SocketTag(), network_isolation_keys[i],
11188 false /* disable_secure_dns */,
11189 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
11190 failed_on_default_network_callback_, callback_.callback());
11191 EXPECT_THAT(callback_.GetResult(rv), IsOk());
11192
11193 // While the session is still alive, there should be
11194 // kMaxRecentCryptoConfigs+1 CryptoConfigCaches alive, since active configs
11195 // don't count towards the limit.
11196 for (int j = 0; j < kNumSessionsToMake; ++j) {
11197 SCOPED_TRACE(j);
11198 EXPECT_EQ(i - (kMaxRecentCryptoConfigs + 1) < j && j <= i,
11199 !QuicStreamFactoryPeer::CryptoConfigCacheIsEmpty(
11200 factory_.get(), kQuicServerId, network_isolation_keys[j]));
11201 }
11202
11203 // Close the sessions, which should cause its CryptoConfigCache to be moved
11204 // to the MRU cache, potentially evicting the oldest entry..
11205 factory_->CloseAllSessions(ERR_FAILED, quic::QUIC_PEER_GOING_AWAY);
11206
11207 // There should now be at most kMaxRecentCryptoConfigs live
11208 // CryptoConfigCaches
11209 for (int j = 0; j < kNumSessionsToMake; ++j) {
11210 SCOPED_TRACE(j);
11211 EXPECT_EQ(i - kMaxRecentCryptoConfigs < j && j <= i,
11212 !QuicStreamFactoryPeer::CryptoConfigCacheIsEmpty(
11213 factory_.get(), kQuicServerId, network_isolation_keys[j]));
11214 }
11215 }
11216 }
11217
TEST_P(QuicStreamFactoryTest,YieldAfterPackets)11218 TEST_P(QuicStreamFactoryTest, YieldAfterPackets) {
11219 Initialize();
11220 factory_->set_is_quic_known_to_work_on_current_network(true);
11221 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
11222 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
11223 QuicStreamFactoryPeer::SetYieldAfterPackets(factory_.get(), 0);
11224
11225 MockQuicData socket_data(version_);
11226 socket_data.AddRead(SYNCHRONOUS, ConstructClientConnectionClosePacket(1));
11227 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
11228 if (VersionUsesHttp3(version_.transport_version))
11229 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
11230 socket_data.AddRead(ASYNC, OK);
11231 socket_data.AddSocketDataToFactory(socket_factory_.get());
11232
11233 crypto_client_stream_factory_.set_handshake_mode(
11234 MockCryptoClientStream::ZERO_RTT);
11235 host_resolver_->set_synchronous_mode(true);
11236 host_resolver_->rules()->AddIPLiteralRule(host_port_pair_.host(),
11237 "192.168.0.1", "");
11238
11239 // Set up the TaskObserver to verify QuicChromiumPacketReader::StartReading
11240 // posts a task.
11241 // TODO(rtenneti): Change SpdySessionTestTaskObserver to NetTestTaskObserver??
11242 SpdySessionTestTaskObserver observer("quic_chromium_packet_reader.cc",
11243 "StartReading");
11244
11245 QuicStreamRequest request(factory_.get());
11246 EXPECT_EQ(
11247 OK,
11248 request.Request(
11249 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
11250 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
11251 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
11252 failed_on_default_network_callback_, callback_.callback()));
11253
11254 // Call run_loop so that QuicChromiumPacketReader::OnReadComplete() gets
11255 // called.
11256 base::RunLoop run_loop;
11257 run_loop.RunUntilIdle();
11258
11259 // Verify task that the observer's executed_count is 1, which indicates
11260 // QuicChromiumPacketReader::StartReading() has posted only one task and
11261 // yielded the read.
11262 EXPECT_EQ(1u, observer.executed_count());
11263
11264 std::unique_ptr<HttpStream> stream = CreateStream(&request);
11265 EXPECT_FALSE(stream.get()); // Session is already closed.
11266 EXPECT_TRUE(socket_data.AllReadDataConsumed());
11267 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
11268 }
11269
TEST_P(QuicStreamFactoryTest,YieldAfterDuration)11270 TEST_P(QuicStreamFactoryTest, YieldAfterDuration) {
11271 Initialize();
11272 factory_->set_is_quic_known_to_work_on_current_network(true);
11273 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
11274 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
11275 QuicStreamFactoryPeer::SetYieldAfterDuration(
11276 factory_.get(), quic::QuicTime::Delta::FromMilliseconds(-1));
11277
11278 MockQuicData socket_data(version_);
11279 socket_data.AddRead(SYNCHRONOUS, ConstructClientConnectionClosePacket(1));
11280 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
11281 if (VersionUsesHttp3(version_.transport_version))
11282 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
11283 socket_data.AddRead(ASYNC, OK);
11284 socket_data.AddSocketDataToFactory(socket_factory_.get());
11285
11286 crypto_client_stream_factory_.set_handshake_mode(
11287 MockCryptoClientStream::ZERO_RTT);
11288 host_resolver_->set_synchronous_mode(true);
11289 host_resolver_->rules()->AddIPLiteralRule(host_port_pair_.host(),
11290 "192.168.0.1", "");
11291
11292 // Set up the TaskObserver to verify QuicChromiumPacketReader::StartReading
11293 // posts a task.
11294 // TODO(rtenneti): Change SpdySessionTestTaskObserver to NetTestTaskObserver??
11295 SpdySessionTestTaskObserver observer("quic_chromium_packet_reader.cc",
11296 "StartReading");
11297
11298 QuicStreamRequest request(factory_.get());
11299 EXPECT_EQ(
11300 OK,
11301 request.Request(
11302 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
11303 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
11304 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
11305 failed_on_default_network_callback_, callback_.callback()));
11306
11307 // Call run_loop so that QuicChromiumPacketReader::OnReadComplete() gets
11308 // called.
11309 base::RunLoop run_loop;
11310 run_loop.RunUntilIdle();
11311
11312 // Verify task that the observer's executed_count is 1, which indicates
11313 // QuicChromiumPacketReader::StartReading() has posted only one task and
11314 // yielded the read.
11315 EXPECT_EQ(1u, observer.executed_count());
11316
11317 std::unique_ptr<HttpStream> stream = CreateStream(&request);
11318 EXPECT_FALSE(stream.get()); // Session is already closed.
11319 EXPECT_TRUE(socket_data.AllReadDataConsumed());
11320 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
11321 }
11322
TEST_P(QuicStreamFactoryTest,ServerPushSessionAffinity)11323 TEST_P(QuicStreamFactoryTest, ServerPushSessionAffinity) {
11324 Initialize();
11325 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
11326 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
11327
11328 MockQuicData socket_data(version_);
11329 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
11330 if (VersionUsesHttp3(version_.transport_version))
11331 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
11332 socket_data.AddSocketDataToFactory(socket_factory_.get());
11333
11334 QuicStreamRequest request(factory_.get());
11335 EXPECT_EQ(
11336 ERR_IO_PENDING,
11337 request.Request(
11338 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
11339 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
11340 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
11341 failed_on_default_network_callback_, callback_.callback()));
11342
11343 EXPECT_THAT(callback_.WaitForResult(), IsOk());
11344 std::unique_ptr<HttpStream> stream = CreateStream(&request);
11345 EXPECT_TRUE(stream.get());
11346
11347 EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumPushStreamsCreated(factory_.get()));
11348
11349 string url = "https://www.example.org/";
11350
11351 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
11352
11353 quic::QuicClientPromisedInfo promised(
11354 session, GetNthServerInitiatedUnidirectionalStreamId(0), kDefaultUrl);
11355 (*session->push_promise_index()->promised_by_url())[kDefaultUrl] = &promised;
11356
11357 QuicStreamRequest request2(factory_.get());
11358 EXPECT_EQ(
11359 OK,
11360 request2.Request(
11361 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
11362 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
11363 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
11364 failed_on_default_network_callback_, callback_.callback()));
11365
11366 EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumPushStreamsCreated(factory_.get()));
11367 }
11368
TEST_P(QuicStreamFactoryTest,ServerPushPrivacyModeMismatch)11369 TEST_P(QuicStreamFactoryTest, ServerPushPrivacyModeMismatch) {
11370 Initialize();
11371 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
11372 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
11373 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
11374
11375 MockQuicData socket_data1(version_);
11376 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
11377 if (VersionUsesHttp3(version_.transport_version)) {
11378 socket_data1.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
11379 }
11380 socket_data1.AddSocketDataToFactory(socket_factory_.get());
11381
11382 client_maker_.Reset();
11383 MockQuicData socket_data2(version_);
11384 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
11385 if (VersionUsesHttp3(version_.transport_version))
11386 socket_data2.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
11387 socket_data2.AddSocketDataToFactory(socket_factory_.get());
11388
11389 QuicStreamRequest request(factory_.get());
11390 EXPECT_EQ(
11391 ERR_IO_PENDING,
11392 request.Request(
11393 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
11394 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
11395 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
11396 failed_on_default_network_callback_, callback_.callback()));
11397
11398 EXPECT_THAT(callback_.WaitForResult(), IsOk());
11399 std::unique_ptr<HttpStream> stream = CreateStream(&request);
11400 EXPECT_TRUE(stream.get());
11401
11402 EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumPushStreamsCreated(factory_.get()));
11403
11404 string url = "https://www.example.org/";
11405 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
11406
11407 quic::QuicClientPromisedInfo promised(
11408 session, GetNthServerInitiatedUnidirectionalStreamId(0), kDefaultUrl);
11409
11410 quic::QuicClientPushPromiseIndex* index = session->push_promise_index();
11411
11412 (*index->promised_by_url())[kDefaultUrl] = &promised;
11413 EXPECT_EQ(index->GetPromised(kDefaultUrl), &promised);
11414
11415 // Sending the request should not use the push stream, since the privacy mode
11416 // is different.
11417 QuicStreamRequest request2(factory_.get());
11418 EXPECT_EQ(
11419 ERR_IO_PENDING,
11420 request2.Request(
11421 host_port_pair_, version_, PRIVACY_MODE_ENABLED, DEFAULT_PRIORITY,
11422 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
11423 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
11424 failed_on_default_network_callback_, callback_.callback()));
11425
11426 EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumPushStreamsCreated(factory_.get()));
11427 // The pushed stream should still be pending.
11428 EXPECT_EQ(&promised, index->GetPromised(kDefaultUrl));
11429
11430 EXPECT_THAT(callback_.WaitForResult(), IsOk());
11431 std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
11432 EXPECT_TRUE(stream2.get());
11433
11434 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
11435 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
11436 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
11437 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
11438 }
11439
TEST_P(QuicStreamFactoryTest,ServerPushNetworkIsolationKeyMismatch)11440 TEST_P(QuicStreamFactoryTest, ServerPushNetworkIsolationKeyMismatch) {
11441 base::test::ScopedFeatureList feature_list;
11442 feature_list.InitWithFeatures(
11443 // enabled_features
11444 {features::kPartitionHttpServerPropertiesByNetworkIsolationKey,
11445 // Need to partition connections by NetworkIsolationKey for
11446 // QuicSessionAliasKey to include NetworkIsolationKeys.
11447 features::kPartitionConnectionsByNetworkIsolationKey},
11448 // disabled_features
11449 {});
11450
11451 Initialize();
11452 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
11453 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
11454 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
11455
11456 MockQuicData socket_data1(version_);
11457 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
11458 if (VersionUsesHttp3(version_.transport_version)) {
11459 socket_data1.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
11460 }
11461 socket_data1.AddSocketDataToFactory(socket_factory_.get());
11462
11463 client_maker_.Reset();
11464 MockQuicData socket_data2(version_);
11465 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
11466 if (VersionUsesHttp3(version_.transport_version))
11467 socket_data2.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
11468 socket_data2.AddSocketDataToFactory(socket_factory_.get());
11469
11470 QuicStreamRequest request(factory_.get());
11471 EXPECT_EQ(
11472 ERR_IO_PENDING,
11473 request.Request(
11474 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
11475 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
11476 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
11477 failed_on_default_network_callback_, callback_.callback()));
11478
11479 EXPECT_THAT(callback_.WaitForResult(), IsOk());
11480 std::unique_ptr<HttpStream> stream = CreateStream(&request);
11481 EXPECT_TRUE(stream.get());
11482
11483 EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumPushStreamsCreated(factory_.get()));
11484
11485 string url = "https://www.example.org/";
11486 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
11487
11488 quic::QuicClientPromisedInfo promised(
11489 session, GetNthServerInitiatedUnidirectionalStreamId(0), kDefaultUrl);
11490
11491 quic::QuicClientPushPromiseIndex* index = session->push_promise_index();
11492
11493 (*index->promised_by_url())[kDefaultUrl] = &promised;
11494 EXPECT_EQ(index->GetPromised(kDefaultUrl), &promised);
11495
11496 // Sending the request should not use the push stream, since the
11497 // NetworkIsolationKey is different.
11498 QuicStreamRequest request2(factory_.get());
11499 EXPECT_EQ(
11500 ERR_IO_PENDING,
11501 request2.Request(
11502 host_port_pair_, version_, PRIVACY_MODE_DISABLED, DEFAULT_PRIORITY,
11503 SocketTag(), NetworkIsolationKey::CreateTransient(),
11504 false /* disable_secure_dns */,
11505 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
11506 failed_on_default_network_callback_, callback_.callback()));
11507
11508 EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumPushStreamsCreated(factory_.get()));
11509 EXPECT_EQ(&promised, index->GetPromised(kDefaultUrl));
11510
11511 EXPECT_THAT(callback_.WaitForResult(), IsOk());
11512 std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
11513 EXPECT_TRUE(stream2.get());
11514
11515 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
11516 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
11517 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
11518 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
11519 }
11520
11521 // Pool to existing session with matching quic::QuicServerId
11522 // even if destination is different.
TEST_P(QuicStreamFactoryTest,PoolByOrigin)11523 TEST_P(QuicStreamFactoryTest, PoolByOrigin) {
11524 Initialize();
11525
11526 HostPortPair destination1("first.example.com", 443);
11527 HostPortPair destination2("second.example.com", 443);
11528
11529 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
11530 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
11531
11532 MockQuicData socket_data(version_);
11533 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
11534 if (VersionUsesHttp3(version_.transport_version))
11535 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
11536 socket_data.AddSocketDataToFactory(socket_factory_.get());
11537
11538 QuicStreamRequest request1(factory_.get());
11539 EXPECT_EQ(
11540 ERR_IO_PENDING,
11541 request1.Request(
11542 destination1, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
11543 NetworkIsolationKey(), false /* disable_secure_dns */,
11544 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
11545 failed_on_default_network_callback_, callback_.callback()));
11546 EXPECT_THAT(callback_.WaitForResult(), IsOk());
11547 std::unique_ptr<HttpStream> stream1 = CreateStream(&request1);
11548 EXPECT_TRUE(stream1.get());
11549 EXPECT_TRUE(HasActiveSession(host_port_pair_));
11550
11551 // Second request returns synchronously because it pools to existing session.
11552 TestCompletionCallback callback2;
11553 QuicStreamRequest request2(factory_.get());
11554 EXPECT_EQ(
11555 OK,
11556 request2.Request(
11557 destination2, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
11558 NetworkIsolationKey(), false /* disable_secure_dns */,
11559 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
11560 failed_on_default_network_callback_, callback2.callback()));
11561 std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
11562 EXPECT_TRUE(stream2.get());
11563
11564 QuicChromiumClientSession::Handle* session1 =
11565 QuicHttpStreamPeer::GetSessionHandle(stream1.get());
11566 QuicChromiumClientSession::Handle* session2 =
11567 QuicHttpStreamPeer::GetSessionHandle(stream2.get());
11568 EXPECT_TRUE(session1->SharesSameSession(*session2));
11569 EXPECT_EQ(quic::QuicServerId(host_port_pair_.host(), host_port_pair_.port(),
11570 privacy_mode_ == PRIVACY_MODE_ENABLED),
11571 session1->server_id());
11572
11573 EXPECT_TRUE(socket_data.AllReadDataConsumed());
11574 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
11575 }
11576
11577 class QuicStreamFactoryWithDestinationTest
11578 : public QuicStreamFactoryTestBase,
11579 public ::testing::TestWithParam<PoolingTestParams> {
11580 protected:
QuicStreamFactoryWithDestinationTest()11581 QuicStreamFactoryWithDestinationTest()
11582 : QuicStreamFactoryTestBase(
11583 GetParam().version,
11584 GetParam().client_headers_include_h2_stream_dependency),
11585 destination_type_(GetParam().destination_type),
11586 hanging_read_(SYNCHRONOUS, ERR_IO_PENDING, 0) {}
11587
GetDestination()11588 HostPortPair GetDestination() {
11589 switch (destination_type_) {
11590 case SAME_AS_FIRST:
11591 return origin1_;
11592 case SAME_AS_SECOND:
11593 return origin2_;
11594 case DIFFERENT:
11595 return HostPortPair(kDifferentHostname, 443);
11596 default:
11597 NOTREACHED();
11598 return HostPortPair();
11599 }
11600 }
11601
AddHangingSocketData()11602 void AddHangingSocketData() {
11603 std::unique_ptr<SequencedSocketData> sequenced_socket_data(
11604 new SequencedSocketData(base::make_span(&hanging_read_, 1),
11605 base::span<MockWrite>()));
11606 socket_factory_->AddSocketDataProvider(sequenced_socket_data.get());
11607 sequenced_socket_data_vector_.push_back(std::move(sequenced_socket_data));
11608 }
11609
AllDataConsumed()11610 bool AllDataConsumed() {
11611 for (const auto& socket_data_ptr : sequenced_socket_data_vector_) {
11612 if (!socket_data_ptr->AllReadDataConsumed() ||
11613 !socket_data_ptr->AllWriteDataConsumed()) {
11614 return false;
11615 }
11616 }
11617 return true;
11618 }
11619
11620 DestinationType destination_type_;
11621 HostPortPair origin1_;
11622 HostPortPair origin2_;
11623 MockRead hanging_read_;
11624 std::vector<std::unique_ptr<SequencedSocketData>>
11625 sequenced_socket_data_vector_;
11626 };
11627
11628 INSTANTIATE_TEST_SUITE_P(VersionIncludeStreamDependencySequence,
11629 QuicStreamFactoryWithDestinationTest,
11630 ::testing::ValuesIn(GetPoolingTestParams()),
11631 ::testing::PrintToStringParamName());
11632
11633 // A single QUIC request fails because the certificate does not match the origin
11634 // hostname, regardless of whether it matches the alternative service hostname.
TEST_P(QuicStreamFactoryWithDestinationTest,InvalidCertificate)11635 TEST_P(QuicStreamFactoryWithDestinationTest, InvalidCertificate) {
11636 if (destination_type_ == DIFFERENT)
11637 return;
11638
11639 Initialize();
11640
11641 GURL url("https://mail.example.com/");
11642 origin1_ = HostPortPair::FromURL(url);
11643
11644 // Not used for requests, but this provides a test case where the certificate
11645 // is valid for the hostname of the alternative service.
11646 origin2_ = HostPortPair("mail.example.org", 433);
11647
11648 HostPortPair destination = GetDestination();
11649
11650 scoped_refptr<X509Certificate> cert(
11651 ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem"));
11652 ASSERT_FALSE(cert->VerifyNameMatch(origin1_.host()));
11653 ASSERT_TRUE(cert->VerifyNameMatch(origin2_.host()));
11654
11655 ProofVerifyDetailsChromium verify_details;
11656 verify_details.cert_verify_result.verified_cert = cert;
11657 verify_details.cert_verify_result.is_issued_by_known_root = true;
11658 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
11659
11660 AddHangingSocketData();
11661
11662 QuicStreamRequest request(factory_.get());
11663 EXPECT_EQ(
11664 ERR_IO_PENDING,
11665 request.Request(
11666 destination, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
11667 NetworkIsolationKey(), false /* disable_secure_dns */,
11668 /*cert_verify_flags=*/0, url, net_log_, &net_error_details_,
11669 failed_on_default_network_callback_, callback_.callback()));
11670
11671 EXPECT_THAT(callback_.WaitForResult(), IsError(ERR_QUIC_HANDSHAKE_FAILED));
11672
11673 EXPECT_TRUE(AllDataConsumed());
11674 }
11675
11676 // QuicStreamRequest is pooled based on |destination| if certificate matches.
TEST_P(QuicStreamFactoryWithDestinationTest,SharedCertificate)11677 TEST_P(QuicStreamFactoryWithDestinationTest, SharedCertificate) {
11678 Initialize();
11679
11680 GURL url1("https://www.example.org/");
11681 GURL url2("https://mail.example.org/");
11682 origin1_ = HostPortPair::FromURL(url1);
11683 origin2_ = HostPortPair::FromURL(url2);
11684
11685 HostPortPair destination = GetDestination();
11686
11687 scoped_refptr<X509Certificate> cert(
11688 ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem"));
11689 ASSERT_TRUE(cert->VerifyNameMatch(origin1_.host()));
11690 ASSERT_TRUE(cert->VerifyNameMatch(origin2_.host()));
11691 ASSERT_FALSE(cert->VerifyNameMatch(kDifferentHostname));
11692
11693 ProofVerifyDetailsChromium verify_details;
11694 verify_details.cert_verify_result.verified_cert = cert;
11695 verify_details.cert_verify_result.is_issued_by_known_root = true;
11696 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
11697
11698 MockQuicData socket_data(version_);
11699 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
11700 if (VersionUsesHttp3(version_.transport_version))
11701 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
11702 socket_data.AddSocketDataToFactory(socket_factory_.get());
11703
11704 QuicStreamRequest request1(factory_.get());
11705 EXPECT_EQ(
11706 ERR_IO_PENDING,
11707 request1.Request(
11708 destination, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
11709 NetworkIsolationKey(), false /* disable_secure_dns */,
11710 /*cert_verify_flags=*/0, url1, net_log_, &net_error_details_,
11711 failed_on_default_network_callback_, callback_.callback()));
11712 EXPECT_THAT(callback_.WaitForResult(), IsOk());
11713
11714 std::unique_ptr<HttpStream> stream1 = CreateStream(&request1);
11715 EXPECT_TRUE(stream1.get());
11716 EXPECT_TRUE(HasActiveSession(origin1_));
11717
11718 // Second request returns synchronously because it pools to existing session.
11719 TestCompletionCallback callback2;
11720 QuicStreamRequest request2(factory_.get());
11721 EXPECT_EQ(
11722 OK,
11723 request2.Request(
11724 destination, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
11725 NetworkIsolationKey(), false /* disable_secure_dns */,
11726 /*cert_verify_flags=*/0, url2, net_log_, &net_error_details_,
11727 failed_on_default_network_callback_, callback2.callback()));
11728 std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
11729 EXPECT_TRUE(stream2.get());
11730
11731 QuicChromiumClientSession::Handle* session1 =
11732 QuicHttpStreamPeer::GetSessionHandle(stream1.get());
11733 QuicChromiumClientSession::Handle* session2 =
11734 QuicHttpStreamPeer::GetSessionHandle(stream2.get());
11735 EXPECT_TRUE(session1->SharesSameSession(*session2));
11736
11737 EXPECT_EQ(quic::QuicServerId(origin1_.host(), origin1_.port(),
11738 privacy_mode_ == PRIVACY_MODE_ENABLED),
11739 session1->server_id());
11740
11741 EXPECT_TRUE(socket_data.AllReadDataConsumed());
11742 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
11743 }
11744
11745 // QuicStreamRequest is not pooled if PrivacyMode differs.
TEST_P(QuicStreamFactoryWithDestinationTest,DifferentPrivacyMode)11746 TEST_P(QuicStreamFactoryWithDestinationTest, DifferentPrivacyMode) {
11747 Initialize();
11748
11749 GURL url1("https://www.example.org/");
11750 GURL url2("https://mail.example.org/");
11751 origin1_ = HostPortPair::FromURL(url1);
11752 origin2_ = HostPortPair::FromURL(url2);
11753
11754 HostPortPair destination = GetDestination();
11755
11756 scoped_refptr<X509Certificate> cert(
11757 ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem"));
11758 ASSERT_TRUE(cert->VerifyNameMatch(origin1_.host()));
11759 ASSERT_TRUE(cert->VerifyNameMatch(origin2_.host()));
11760 ASSERT_FALSE(cert->VerifyNameMatch(kDifferentHostname));
11761
11762 ProofVerifyDetailsChromium verify_details1;
11763 verify_details1.cert_verify_result.verified_cert = cert;
11764 verify_details1.cert_verify_result.is_issued_by_known_root = true;
11765 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details1);
11766
11767 ProofVerifyDetailsChromium verify_details2;
11768 verify_details2.cert_verify_result.verified_cert = cert;
11769 verify_details2.cert_verify_result.is_issued_by_known_root = true;
11770 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details2);
11771
11772 MockQuicData socket_data1(version_);
11773 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
11774 if (VersionUsesHttp3(version_.transport_version))
11775 socket_data1.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
11776 socket_data1.AddSocketDataToFactory(socket_factory_.get());
11777 client_maker_.Reset();
11778 MockQuicData socket_data2(version_);
11779 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
11780 if (VersionUsesHttp3(version_.transport_version))
11781 socket_data2.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
11782 socket_data2.AddSocketDataToFactory(socket_factory_.get());
11783
11784 QuicStreamRequest request1(factory_.get());
11785 EXPECT_EQ(
11786 ERR_IO_PENDING,
11787 request1.Request(
11788 destination, version_, PRIVACY_MODE_DISABLED, DEFAULT_PRIORITY,
11789 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
11790 /*cert_verify_flags=*/0, url1, net_log_, &net_error_details_,
11791 failed_on_default_network_callback_, callback_.callback()));
11792 EXPECT_EQ(OK, callback_.WaitForResult());
11793 std::unique_ptr<HttpStream> stream1 = CreateStream(&request1);
11794 EXPECT_TRUE(stream1.get());
11795 EXPECT_TRUE(HasActiveSession(origin1_));
11796
11797 TestCompletionCallback callback2;
11798 QuicStreamRequest request2(factory_.get());
11799 EXPECT_EQ(
11800 ERR_IO_PENDING,
11801 request2.Request(
11802 destination, version_, PRIVACY_MODE_ENABLED, DEFAULT_PRIORITY,
11803 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
11804 /*cert_verify_flags=*/0, url2, net_log_, &net_error_details_,
11805 failed_on_default_network_callback_, callback2.callback()));
11806 EXPECT_EQ(OK, callback2.WaitForResult());
11807 std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
11808 EXPECT_TRUE(stream2.get());
11809
11810 // |request2| does not pool to the first session, because PrivacyMode does not
11811 // match. Instead, another session is opened to the same destination, but
11812 // with a different quic::QuicServerId.
11813 QuicChromiumClientSession::Handle* session1 =
11814 QuicHttpStreamPeer::GetSessionHandle(stream1.get());
11815 QuicChromiumClientSession::Handle* session2 =
11816 QuicHttpStreamPeer::GetSessionHandle(stream2.get());
11817 EXPECT_FALSE(session1->SharesSameSession(*session2));
11818
11819 EXPECT_EQ(quic::QuicServerId(origin1_.host(), origin1_.port(), false),
11820 session1->server_id());
11821 EXPECT_EQ(quic::QuicServerId(origin2_.host(), origin2_.port(), true),
11822 session2->server_id());
11823
11824 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
11825 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
11826 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
11827 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
11828 }
11829
11830 // QuicStreamRequest is not pooled if the disable_secure_dns field differs.
TEST_P(QuicStreamFactoryWithDestinationTest,DifferentDisableSecureDns)11831 TEST_P(QuicStreamFactoryWithDestinationTest, DifferentDisableSecureDns) {
11832 Initialize();
11833
11834 GURL url1("https://www.example.org/");
11835 GURL url2("https://mail.example.org/");
11836 origin1_ = HostPortPair::FromURL(url1);
11837 origin2_ = HostPortPair::FromURL(url2);
11838
11839 HostPortPair destination = GetDestination();
11840
11841 scoped_refptr<X509Certificate> cert(
11842 ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem"));
11843 ASSERT_TRUE(cert->VerifyNameMatch(origin1_.host()));
11844 ASSERT_TRUE(cert->VerifyNameMatch(origin2_.host()));
11845 ASSERT_FALSE(cert->VerifyNameMatch(kDifferentHostname));
11846
11847 ProofVerifyDetailsChromium verify_details1;
11848 verify_details1.cert_verify_result.verified_cert = cert;
11849 verify_details1.cert_verify_result.is_issued_by_known_root = true;
11850 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details1);
11851
11852 ProofVerifyDetailsChromium verify_details2;
11853 verify_details2.cert_verify_result.verified_cert = cert;
11854 verify_details2.cert_verify_result.is_issued_by_known_root = true;
11855 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details2);
11856
11857 MockQuicData socket_data1(version_);
11858 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
11859 if (VersionUsesHttp3(version_.transport_version))
11860 socket_data1.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
11861 socket_data1.AddSocketDataToFactory(socket_factory_.get());
11862 client_maker_.Reset();
11863 MockQuicData socket_data2(version_);
11864 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
11865 if (VersionUsesHttp3(version_.transport_version))
11866 socket_data2.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
11867 socket_data2.AddSocketDataToFactory(socket_factory_.get());
11868
11869 QuicStreamRequest request1(factory_.get());
11870 EXPECT_EQ(
11871 ERR_IO_PENDING,
11872 request1.Request(
11873 destination, version_, PRIVACY_MODE_DISABLED, DEFAULT_PRIORITY,
11874 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
11875 /*cert_verify_flags=*/0, url1, net_log_, &net_error_details_,
11876 failed_on_default_network_callback_, callback_.callback()));
11877 EXPECT_EQ(OK, callback_.WaitForResult());
11878 std::unique_ptr<HttpStream> stream1 = CreateStream(&request1);
11879 EXPECT_TRUE(stream1.get());
11880 EXPECT_TRUE(HasActiveSession(origin1_));
11881
11882 TestCompletionCallback callback2;
11883 QuicStreamRequest request2(factory_.get());
11884 EXPECT_EQ(
11885 ERR_IO_PENDING,
11886 request2.Request(
11887 destination, version_, PRIVACY_MODE_DISABLED, DEFAULT_PRIORITY,
11888 SocketTag(), NetworkIsolationKey(), true /* disable_secure_dns */,
11889 /*cert_verify_flags=*/0, url2, net_log_, &net_error_details_,
11890 failed_on_default_network_callback_, callback2.callback()));
11891 EXPECT_EQ(OK, callback2.WaitForResult());
11892 std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
11893 EXPECT_TRUE(stream2.get());
11894
11895 // |request2| does not pool to the first session, because |disable_secure_dns|
11896 // does not match.
11897 QuicChromiumClientSession::Handle* session1 =
11898 QuicHttpStreamPeer::GetSessionHandle(stream1.get());
11899 QuicChromiumClientSession::Handle* session2 =
11900 QuicHttpStreamPeer::GetSessionHandle(stream2.get());
11901 EXPECT_FALSE(session1->SharesSameSession(*session2));
11902
11903 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
11904 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
11905 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
11906 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
11907 }
11908
11909 // QuicStreamRequest is not pooled if certificate does not match its origin.
TEST_P(QuicStreamFactoryWithDestinationTest,DisjointCertificate)11910 TEST_P(QuicStreamFactoryWithDestinationTest, DisjointCertificate) {
11911 Initialize();
11912
11913 GURL url1("https://news.example.org/");
11914 GURL url2("https://mail.example.com/");
11915 origin1_ = HostPortPair::FromURL(url1);
11916 origin2_ = HostPortPair::FromURL(url2);
11917
11918 HostPortPair destination = GetDestination();
11919
11920 scoped_refptr<X509Certificate> cert1(
11921 ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem"));
11922 ASSERT_TRUE(cert1->VerifyNameMatch(origin1_.host()));
11923 ASSERT_FALSE(cert1->VerifyNameMatch(origin2_.host()));
11924 ASSERT_FALSE(cert1->VerifyNameMatch(kDifferentHostname));
11925
11926 ProofVerifyDetailsChromium verify_details1;
11927 verify_details1.cert_verify_result.verified_cert = cert1;
11928 verify_details1.cert_verify_result.is_issued_by_known_root = true;
11929 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details1);
11930
11931 scoped_refptr<X509Certificate> cert2(
11932 ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"));
11933 ASSERT_TRUE(cert2->VerifyNameMatch(origin2_.host()));
11934 ASSERT_FALSE(cert2->VerifyNameMatch(kDifferentHostname));
11935
11936 ProofVerifyDetailsChromium verify_details2;
11937 verify_details2.cert_verify_result.verified_cert = cert2;
11938 verify_details2.cert_verify_result.is_issued_by_known_root = true;
11939 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details2);
11940
11941 MockQuicData socket_data1(version_);
11942 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
11943 if (VersionUsesHttp3(version_.transport_version))
11944 socket_data1.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
11945 socket_data1.AddSocketDataToFactory(socket_factory_.get());
11946 client_maker_.Reset();
11947 MockQuicData socket_data2(version_);
11948 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
11949 if (VersionUsesHttp3(version_.transport_version))
11950 socket_data2.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
11951 socket_data2.AddSocketDataToFactory(socket_factory_.get());
11952
11953 QuicStreamRequest request1(factory_.get());
11954 EXPECT_EQ(
11955 ERR_IO_PENDING,
11956 request1.Request(
11957 destination, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
11958 NetworkIsolationKey(), false /* disable_secure_dns */,
11959 /*cert_verify_flags=*/0, url1, net_log_, &net_error_details_,
11960 failed_on_default_network_callback_, callback_.callback()));
11961 EXPECT_THAT(callback_.WaitForResult(), IsOk());
11962 std::unique_ptr<HttpStream> stream1 = CreateStream(&request1);
11963 EXPECT_TRUE(stream1.get());
11964 EXPECT_TRUE(HasActiveSession(origin1_));
11965
11966 TestCompletionCallback callback2;
11967 QuicStreamRequest request2(factory_.get());
11968 EXPECT_EQ(
11969 ERR_IO_PENDING,
11970 request2.Request(
11971 destination, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
11972 NetworkIsolationKey(), false /* disable_secure_dns */,
11973 /*cert_verify_flags=*/0, url2, net_log_, &net_error_details_,
11974 failed_on_default_network_callback_, callback2.callback()));
11975 EXPECT_THAT(callback2.WaitForResult(), IsOk());
11976 std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
11977 EXPECT_TRUE(stream2.get());
11978
11979 // |request2| does not pool to the first session, because the certificate does
11980 // not match. Instead, another session is opened to the same destination, but
11981 // with a different quic::QuicServerId.
11982 QuicChromiumClientSession::Handle* session1 =
11983 QuicHttpStreamPeer::GetSessionHandle(stream1.get());
11984 QuicChromiumClientSession::Handle* session2 =
11985 QuicHttpStreamPeer::GetSessionHandle(stream2.get());
11986 EXPECT_FALSE(session1->SharesSameSession(*session2));
11987
11988 EXPECT_EQ(quic::QuicServerId(origin1_.host(), origin1_.port(),
11989 privacy_mode_ == PRIVACY_MODE_ENABLED),
11990 session1->server_id());
11991 EXPECT_EQ(quic::QuicServerId(origin2_.host(), origin2_.port(),
11992 privacy_mode_ == PRIVACY_MODE_ENABLED),
11993 session2->server_id());
11994
11995 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
11996 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
11997 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
11998 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
11999 }
12000
12001 // This test verifies that QuicStreamFactory::ClearCachedStatesInCryptoConfig
12002 // correctly transform an origin filter to a ServerIdFilter. Whether the
12003 // deletion itself works correctly is tested in QuicCryptoClientConfigTest.
TEST_P(QuicStreamFactoryTest,ClearCachedStatesInCryptoConfig)12004 TEST_P(QuicStreamFactoryTest, ClearCachedStatesInCryptoConfig) {
12005 Initialize();
12006 // Need to hold onto this through the test, to keep the QuicCryptoClientConfig
12007 // alive.
12008 std::unique_ptr<QuicCryptoClientConfigHandle> crypto_config_handle =
12009 QuicStreamFactoryPeer::GetCryptoConfig(factory_.get(),
12010 NetworkIsolationKey());
12011
12012 struct TestCase {
12013 TestCase(const std::string& host,
12014 int port,
12015 PrivacyMode privacy_mode,
12016 quic::QuicCryptoClientConfig* crypto_config)
12017 : server_id(host, port, privacy_mode),
12018 state(crypto_config->LookupOrCreate(server_id)) {
12019 std::vector<string> certs(1);
12020 certs[0] = "cert";
12021 state->SetProof(certs, "cert_sct", "chlo_hash", "signature");
12022 state->set_source_address_token("TOKEN");
12023 state->SetProofValid();
12024
12025 EXPECT_FALSE(state->certs().empty());
12026 }
12027
12028 quic::QuicServerId server_id;
12029 quic::QuicCryptoClientConfig::CachedState* state;
12030 } test_cases[] = {TestCase("www.google.com", 443, privacy_mode_,
12031 crypto_config_handle->GetConfig()),
12032 TestCase("www.example.com", 443, privacy_mode_,
12033 crypto_config_handle->GetConfig()),
12034 TestCase("www.example.com", 4433, privacy_mode_,
12035 crypto_config_handle->GetConfig())};
12036
12037 // Clear cached states for the origin https://www.example.com:4433.
12038 GURL origin("https://www.example.com:4433");
12039 factory_->ClearCachedStatesInCryptoConfig(base::BindRepeating(
12040 static_cast<bool (*)(const GURL&, const GURL&)>(::operator==), origin));
12041 EXPECT_FALSE(test_cases[0].state->certs().empty());
12042 EXPECT_FALSE(test_cases[1].state->certs().empty());
12043 EXPECT_TRUE(test_cases[2].state->certs().empty());
12044
12045 // Clear all cached states.
12046 factory_->ClearCachedStatesInCryptoConfig(
12047 base::RepeatingCallback<bool(const GURL&)>());
12048 EXPECT_TRUE(test_cases[0].state->certs().empty());
12049 EXPECT_TRUE(test_cases[1].state->certs().empty());
12050 EXPECT_TRUE(test_cases[2].state->certs().empty());
12051 }
12052
12053 // Passes connection options and client connection options to QuicStreamFactory,
12054 // then checks that its internal quic::QuicConfig is correct.
TEST_P(QuicStreamFactoryTest,ConfigConnectionOptions)12055 TEST_P(QuicStreamFactoryTest, ConfigConnectionOptions) {
12056 quic_params_->connection_options.push_back(quic::kTIME);
12057 quic_params_->connection_options.push_back(quic::kTBBR);
12058 quic_params_->connection_options.push_back(quic::kREJ);
12059
12060 quic_params_->client_connection_options.push_back(quic::kTBBR);
12061 quic_params_->client_connection_options.push_back(quic::k1RTT);
12062
12063 Initialize();
12064
12065 const quic::QuicConfig* config =
12066 QuicStreamFactoryPeer::GetConfig(factory_.get());
12067 EXPECT_EQ(quic_params_->connection_options, config->SendConnectionOptions());
12068 EXPECT_TRUE(config->HasClientRequestedIndependentOption(
12069 quic::kTBBR, quic::Perspective::IS_CLIENT));
12070 EXPECT_TRUE(config->HasClientRequestedIndependentOption(
12071 quic::k1RTT, quic::Perspective::IS_CLIENT));
12072 }
12073
12074 // Verifies that the host resolver uses the request priority passed to
12075 // QuicStreamRequest::Request().
TEST_P(QuicStreamFactoryTest,HostResolverUsesRequestPriority)12076 TEST_P(QuicStreamFactoryTest, HostResolverUsesRequestPriority) {
12077 Initialize();
12078 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
12079 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
12080
12081 MockQuicData socket_data(version_);
12082 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
12083 if (VersionUsesHttp3(version_.transport_version))
12084 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
12085 socket_data.AddSocketDataToFactory(socket_factory_.get());
12086
12087 QuicStreamRequest request(factory_.get());
12088 EXPECT_EQ(
12089 ERR_IO_PENDING,
12090 request.Request(
12091 host_port_pair_, version_, privacy_mode_, MAXIMUM_PRIORITY,
12092 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
12093 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
12094 failed_on_default_network_callback_, callback_.callback()));
12095
12096 EXPECT_THAT(callback_.WaitForResult(), IsOk());
12097 std::unique_ptr<HttpStream> stream = CreateStream(&request);
12098 EXPECT_TRUE(stream.get());
12099
12100 EXPECT_EQ(MAXIMUM_PRIORITY, host_resolver_->last_request_priority());
12101
12102 EXPECT_TRUE(socket_data.AllReadDataConsumed());
12103 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
12104 }
12105
TEST_P(QuicStreamFactoryTest,HostResolverRequestReprioritizedOnSetPriority)12106 TEST_P(QuicStreamFactoryTest, HostResolverRequestReprioritizedOnSetPriority) {
12107 Initialize();
12108 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
12109 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
12110
12111 MockQuicData socket_data(version_);
12112 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
12113 if (VersionUsesHttp3(version_.transport_version))
12114 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
12115 socket_data.AddSocketDataToFactory(socket_factory_.get());
12116
12117 QuicStreamRequest request(factory_.get());
12118 EXPECT_EQ(
12119 ERR_IO_PENDING,
12120 request.Request(
12121 host_port_pair_, version_, privacy_mode_, MAXIMUM_PRIORITY,
12122 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
12123 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
12124 failed_on_default_network_callback_, callback_.callback()));
12125
12126 EXPECT_EQ(MAXIMUM_PRIORITY, host_resolver_->last_request_priority());
12127 EXPECT_EQ(MAXIMUM_PRIORITY, host_resolver_->request_priority(1));
12128
12129 QuicStreamRequest request2(factory_.get());
12130 EXPECT_EQ(
12131 ERR_IO_PENDING,
12132 request2.Request(
12133 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
12134 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
12135 /*cert_verify_flags=*/0, url2_, net_log_, &net_error_details_,
12136 failed_on_default_network_callback_, callback_.callback()));
12137 EXPECT_EQ(DEFAULT_PRIORITY, host_resolver_->last_request_priority());
12138 EXPECT_EQ(DEFAULT_PRIORITY, host_resolver_->request_priority(2));
12139
12140 request.SetPriority(LOWEST);
12141 EXPECT_EQ(LOWEST, host_resolver_->request_priority(1));
12142 EXPECT_EQ(DEFAULT_PRIORITY, host_resolver_->request_priority(2));
12143 }
12144
12145 // Verifies that the host resolver uses the disable secure DNS setting and
12146 // NetworkIsolationKey passed to QuicStreamRequest::Request().
TEST_P(QuicStreamFactoryTest,HostResolverUsesParams)12147 TEST_P(QuicStreamFactoryTest, HostResolverUsesParams) {
12148 const url::Origin kOrigin1 = url::Origin::Create(GURL("https://foo.test/"));
12149 const url::Origin kOrigin2 = url::Origin::Create(GURL("https://bar.test/"));
12150 const NetworkIsolationKey kNetworkIsolationKey(kOrigin1, kOrigin1);
12151 base::test::ScopedFeatureList feature_list;
12152 feature_list.InitWithFeatures(
12153 // enabled_features
12154 {features::kPartitionConnectionsByNetworkIsolationKey,
12155 features::kSplitHostCacheByNetworkIsolationKey},
12156 // disabled_features
12157 {});
12158
12159 Initialize();
12160 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
12161 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
12162
12163 MockQuicData socket_data(version_);
12164 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
12165 if (VersionUsesHttp3(version_.transport_version))
12166 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
12167 socket_data.AddSocketDataToFactory(socket_factory_.get());
12168
12169 QuicStreamRequest request(factory_.get());
12170 EXPECT_EQ(
12171 ERR_IO_PENDING,
12172 request.Request(
12173 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
12174 SocketTag(), kNetworkIsolationKey, true /* disable_secure_dns */,
12175 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
12176 failed_on_default_network_callback_, callback_.callback()));
12177
12178 EXPECT_THAT(callback_.WaitForResult(), IsOk());
12179 std::unique_ptr<HttpStream> stream = CreateStream(&request);
12180 EXPECT_TRUE(stream.get());
12181
12182 ASSERT_TRUE(host_resolver_->last_secure_dns_mode_override().has_value());
12183 EXPECT_EQ(net::SecureDnsMode::kOff,
12184 host_resolver_->last_secure_dns_mode_override().value());
12185 ASSERT_TRUE(host_resolver_->last_request_network_isolation_key().has_value());
12186 EXPECT_EQ(kNetworkIsolationKey,
12187 host_resolver_->last_request_network_isolation_key().value());
12188
12189 EXPECT_TRUE(socket_data.AllReadDataConsumed());
12190 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
12191 }
12192
12193 // Passes |quic_max_time_before_crypto_handshake| and
12194 // |quic_max_idle_time_before_crypto_handshake| to QuicStreamFactory,
12195 // checks that its internal quic::QuicConfig is correct.
TEST_P(QuicStreamFactoryTest,ConfigMaxTimeBeforeCryptoHandshake)12196 TEST_P(QuicStreamFactoryTest, ConfigMaxTimeBeforeCryptoHandshake) {
12197 quic_params_->max_time_before_crypto_handshake =
12198 base::TimeDelta::FromSeconds(11);
12199 quic_params_->max_idle_time_before_crypto_handshake =
12200 base::TimeDelta::FromSeconds(13);
12201 Initialize();
12202
12203 const quic::QuicConfig* config =
12204 QuicStreamFactoryPeer::GetConfig(factory_.get());
12205 EXPECT_EQ(quic::QuicTime::Delta::FromSeconds(11),
12206 config->max_time_before_crypto_handshake());
12207 EXPECT_EQ(quic::QuicTime::Delta::FromSeconds(13),
12208 config->max_idle_time_before_crypto_handshake());
12209 }
12210
12211 // Verify ResultAfterHostResolutionCallback behavior when host resolution
12212 // succeeds asynchronously, then crypto handshake fails synchronously.
TEST_P(QuicStreamFactoryTest,ResultAfterHostResolutionCallbackAsyncSync)12213 TEST_P(QuicStreamFactoryTest, ResultAfterHostResolutionCallbackAsyncSync) {
12214 Initialize();
12215 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
12216 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
12217
12218 host_resolver_->set_ondemand_mode(true);
12219
12220 MockQuicData socket_data(version_);
12221 socket_data.AddRead(SYNCHRONOUS, ERR_FAILED);
12222 socket_data.AddWrite(SYNCHRONOUS, ERR_FAILED);
12223 socket_data.AddSocketDataToFactory(socket_factory_.get());
12224
12225 QuicStreamRequest request(factory_.get());
12226 EXPECT_EQ(
12227 ERR_IO_PENDING,
12228 request.Request(
12229 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
12230 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
12231 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
12232 failed_on_default_network_callback_, callback_.callback()));
12233
12234 TestCompletionCallback host_resolution_callback;
12235 EXPECT_TRUE(
12236 request.WaitForHostResolution(host_resolution_callback.callback()));
12237
12238 // |host_resolver_| has not finished host resolution at this point, so
12239 // |host_resolution_callback| should not have a result.
12240 base::RunLoop().RunUntilIdle();
12241 EXPECT_FALSE(host_resolution_callback.have_result());
12242
12243 // Allow |host_resolver_| to finish host resolution.
12244 // Since the request fails immediately after host resolution (getting
12245 // ERR_FAILED from socket reads/writes), |host_resolution_callback| should be
12246 // called with ERR_QUIC_PROTOCOL_ERROR since that's the next result in
12247 // forming the connection.
12248 host_resolver_->ResolveAllPending();
12249 base::RunLoop().RunUntilIdle();
12250 EXPECT_TRUE(host_resolution_callback.have_result());
12251 EXPECT_EQ(ERR_QUIC_PROTOCOL_ERROR, host_resolution_callback.WaitForResult());
12252
12253 // Calling WaitForHostResolution() a second time should return
12254 // false since host resolution has finished already.
12255 EXPECT_FALSE(
12256 request.WaitForHostResolution(host_resolution_callback.callback()));
12257
12258 EXPECT_TRUE(callback_.have_result());
12259 EXPECT_EQ(ERR_QUIC_PROTOCOL_ERROR, callback_.WaitForResult());
12260 }
12261
12262 // Verify ResultAfterHostResolutionCallback behavior when host resolution
12263 // succeeds asynchronously, then crypto handshake fails asynchronously.
TEST_P(QuicStreamFactoryTest,ResultAfterHostResolutionCallbackAsyncAsync)12264 TEST_P(QuicStreamFactoryTest, ResultAfterHostResolutionCallbackAsyncAsync) {
12265 Initialize();
12266 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
12267 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
12268
12269 host_resolver_->set_ondemand_mode(true);
12270 crypto_client_stream_factory_.set_handshake_mode(
12271 MockCryptoClientStream::ZERO_RTT);
12272 factory_->set_is_quic_known_to_work_on_current_network(false);
12273
12274 MockQuicData socket_data(version_);
12275 socket_data.AddRead(ASYNC, ERR_IO_PENDING); // Pause
12276 socket_data.AddRead(ASYNC, ERR_FAILED);
12277 socket_data.AddWrite(ASYNC, ERR_FAILED);
12278 socket_data.AddSocketDataToFactory(socket_factory_.get());
12279
12280 QuicStreamRequest request(factory_.get());
12281 EXPECT_EQ(
12282 ERR_IO_PENDING,
12283 request.Request(
12284 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
12285 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
12286 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
12287 failed_on_default_network_callback_, callback_.callback()));
12288
12289 TestCompletionCallback host_resolution_callback;
12290 EXPECT_TRUE(
12291 request.WaitForHostResolution(host_resolution_callback.callback()));
12292
12293 // |host_resolver_| has not finished host resolution at this point, so
12294 // |host_resolution_callback| should not have a result.
12295 base::RunLoop().RunUntilIdle();
12296 EXPECT_FALSE(host_resolution_callback.have_result());
12297
12298 // Allow |host_resolver_| to finish host resolution. Since crypto handshake
12299 // will hang after host resolution, |host_resolution_callback| should run with
12300 // ERR_IO_PENDING since that's the next result in forming the connection.
12301 host_resolver_->ResolveAllPending();
12302 base::RunLoop().RunUntilIdle();
12303 EXPECT_TRUE(host_resolution_callback.have_result());
12304 EXPECT_EQ(ERR_IO_PENDING, host_resolution_callback.WaitForResult());
12305
12306 // Calling WaitForHostResolution() a second time should return
12307 // false since host resolution has finished already.
12308 EXPECT_FALSE(
12309 request.WaitForHostResolution(host_resolution_callback.callback()));
12310
12311 EXPECT_FALSE(callback_.have_result());
12312 socket_data.GetSequencedSocketData()->Resume();
12313 base::RunLoop().RunUntilIdle();
12314 EXPECT_TRUE(callback_.have_result());
12315 EXPECT_EQ(ERR_QUIC_PROTOCOL_ERROR, callback_.WaitForResult());
12316 }
12317
12318 // Verify ResultAfterHostResolutionCallback behavior when host resolution
12319 // succeeds synchronously, then crypto handshake fails synchronously.
TEST_P(QuicStreamFactoryTest,ResultAfterHostResolutionCallbackSyncSync)12320 TEST_P(QuicStreamFactoryTest, ResultAfterHostResolutionCallbackSyncSync) {
12321 Initialize();
12322 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
12323 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
12324
12325 host_resolver_->set_synchronous_mode(true);
12326
12327 MockQuicData socket_data(version_);
12328 socket_data.AddRead(SYNCHRONOUS, ERR_FAILED);
12329 socket_data.AddWrite(SYNCHRONOUS, ERR_FAILED);
12330 socket_data.AddSocketDataToFactory(socket_factory_.get());
12331
12332 QuicStreamRequest request(factory_.get());
12333 EXPECT_EQ(
12334 ERR_QUIC_PROTOCOL_ERROR,
12335 request.Request(
12336 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
12337 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
12338 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
12339 failed_on_default_network_callback_, callback_.callback()));
12340
12341 // WaitForHostResolution() should return false since host
12342 // resolution has finished already.
12343 TestCompletionCallback host_resolution_callback;
12344 EXPECT_FALSE(
12345 request.WaitForHostResolution(host_resolution_callback.callback()));
12346 base::RunLoop().RunUntilIdle();
12347 EXPECT_FALSE(host_resolution_callback.have_result());
12348 EXPECT_FALSE(callback_.have_result());
12349 }
12350
12351 // Verify ResultAfterHostResolutionCallback behavior when host resolution
12352 // succeeds synchronously, then crypto handshake fails asynchronously.
TEST_P(QuicStreamFactoryTest,ResultAfterHostResolutionCallbackSyncAsync)12353 TEST_P(QuicStreamFactoryTest, ResultAfterHostResolutionCallbackSyncAsync) {
12354 Initialize();
12355 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
12356 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
12357
12358 // Host resolution will succeed synchronously, but Request() as a whole
12359 // will fail asynchronously.
12360 host_resolver_->set_synchronous_mode(true);
12361 crypto_client_stream_factory_.set_handshake_mode(
12362 MockCryptoClientStream::ZERO_RTT);
12363 factory_->set_is_quic_known_to_work_on_current_network(false);
12364
12365 MockQuicData socket_data(version_);
12366 socket_data.AddRead(ASYNC, ERR_IO_PENDING); // Pause
12367 socket_data.AddRead(ASYNC, ERR_FAILED);
12368 socket_data.AddWrite(ASYNC, ERR_FAILED);
12369 socket_data.AddSocketDataToFactory(socket_factory_.get());
12370
12371 QuicStreamRequest request(factory_.get());
12372 EXPECT_EQ(
12373 ERR_IO_PENDING,
12374 request.Request(
12375 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
12376 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
12377 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
12378 failed_on_default_network_callback_, callback_.callback()));
12379
12380 // WaitForHostResolution() should return false since host
12381 // resolution has finished already.
12382 TestCompletionCallback host_resolution_callback;
12383 EXPECT_FALSE(
12384 request.WaitForHostResolution(host_resolution_callback.callback()));
12385 base::RunLoop().RunUntilIdle();
12386 EXPECT_FALSE(host_resolution_callback.have_result());
12387
12388 EXPECT_FALSE(callback_.have_result());
12389 socket_data.GetSequencedSocketData()->Resume();
12390 base::RunLoop().RunUntilIdle();
12391 EXPECT_TRUE(callback_.have_result());
12392 EXPECT_EQ(ERR_QUIC_PROTOCOL_ERROR, callback_.WaitForResult());
12393 }
12394
12395 // Verify ResultAfterHostResolutionCallback behavior when host resolution fails
12396 // synchronously.
TEST_P(QuicStreamFactoryTest,ResultAfterHostResolutionCallbackFailSync)12397 TEST_P(QuicStreamFactoryTest, ResultAfterHostResolutionCallbackFailSync) {
12398 Initialize();
12399 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
12400 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
12401
12402 // Host resolution will fail synchronously.
12403 host_resolver_->rules()->AddSimulatedFailure(host_port_pair_.host());
12404 host_resolver_->set_synchronous_mode(true);
12405
12406 QuicStreamRequest request(factory_.get());
12407 EXPECT_EQ(
12408 ERR_NAME_NOT_RESOLVED,
12409 request.Request(
12410 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
12411 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
12412 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
12413 failed_on_default_network_callback_, callback_.callback()));
12414
12415 // WaitForHostResolution() should return false since host
12416 // resolution has failed already.
12417 TestCompletionCallback host_resolution_callback;
12418 EXPECT_FALSE(
12419 request.WaitForHostResolution(host_resolution_callback.callback()));
12420 base::RunLoop().RunUntilIdle();
12421 EXPECT_FALSE(host_resolution_callback.have_result());
12422 }
12423
12424 // Verify ResultAfterHostResolutionCallback behavior when host resolution fails
12425 // asynchronously.
TEST_P(QuicStreamFactoryTest,ResultAfterHostResolutionCallbackFailAsync)12426 TEST_P(QuicStreamFactoryTest, ResultAfterHostResolutionCallbackFailAsync) {
12427 Initialize();
12428 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
12429 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
12430
12431 host_resolver_->rules()->AddSimulatedFailure(host_port_pair_.host());
12432
12433 QuicStreamRequest request(factory_.get());
12434 EXPECT_EQ(
12435 ERR_IO_PENDING,
12436 request.Request(
12437 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
12438 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
12439 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
12440 failed_on_default_network_callback_, callback_.callback()));
12441
12442 TestCompletionCallback host_resolution_callback;
12443 EXPECT_TRUE(
12444 request.WaitForHostResolution(host_resolution_callback.callback()));
12445
12446 // Allow |host_resolver_| to fail host resolution. |host_resolution_callback|
12447 // Should run with ERR_NAME_NOT_RESOLVED since that's the error host
12448 // resolution failed with.
12449 base::RunLoop().RunUntilIdle();
12450 EXPECT_TRUE(host_resolution_callback.have_result());
12451 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, host_resolution_callback.WaitForResult());
12452
12453 EXPECT_TRUE(callback_.have_result());
12454 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, callback_.WaitForResult());
12455 }
12456
12457 // With dns race experiment turned on, and DNS resolve succeeds synchronously,
12458 // the final connection is established through the resolved DNS. No racing
12459 // connection.
TEST_P(QuicStreamFactoryTest,ResultAfterDNSRaceAndHostResolutionSync)12460 TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceAndHostResolutionSync) {
12461 quic_params_->race_stale_dns_on_connection = true;
12462 host_resolver_ = std::make_unique<MockCachingHostResolver>();
12463 Initialize();
12464 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
12465 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
12466
12467 // Set an address in resolver for synchronous return.
12468 host_resolver_->set_synchronous_mode(true);
12469 host_resolver_->rules()->AddIPLiteralRule(host_port_pair_.host(),
12470 kNonCachedIPAddress, "");
12471
12472 // Set up a different address in stale resolver cache.
12473 HostCache::Key key(host_port_pair_.host(), DnsQueryType::UNSPECIFIED, 0,
12474 HostResolverSource::ANY, NetworkIsolationKey());
12475 HostCache::Entry entry(OK,
12476 AddressList::CreateFromIPAddress(kCachedIPAddress, 0),
12477 HostCache::Entry::SOURCE_DNS);
12478 base::TimeDelta zero;
12479 HostCache* cache = host_resolver_->GetHostCache();
12480 cache->Set(key, entry, base::TimeTicks::Now(), zero);
12481 // Expire the cache
12482 cache->Invalidate();
12483
12484 MockQuicData quic_data(version_);
12485 quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
12486 if (VersionUsesHttp3(version_.transport_version))
12487 quic_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
12488 quic_data.AddSocketDataToFactory(socket_factory_.get());
12489
12490 QuicStreamRequest request(factory_.get());
12491 EXPECT_THAT(
12492 request.Request(
12493 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
12494 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
12495 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
12496 failed_on_default_network_callback_, callback_.callback()),
12497 IsOk());
12498 std::unique_ptr<HttpStream> stream = CreateStream(&request);
12499 EXPECT_TRUE(stream.get());
12500 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
12501 EXPECT_EQ(session->peer_address().host().ToString(), kNonCachedIPAddress);
12502
12503 EXPECT_TRUE(quic_data.AllReadDataConsumed());
12504 EXPECT_TRUE(quic_data.AllWriteDataConsumed());
12505 }
12506
12507 // With dns race experiment on, DNS resolve returns async, no matching cache in
12508 // host resolver, connection should be successful and through resolved DNS. No
12509 // racing connection.
TEST_P(QuicStreamFactoryTest,ResultAfterDNSRaceAndHostResolutionAsync)12510 TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceAndHostResolutionAsync) {
12511 host_resolver_ = std::make_unique<MockCachingHostResolver>();
12512 Initialize();
12513 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
12514 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
12515
12516 // Set an address in resolver for asynchronous return.
12517 host_resolver_->set_ondemand_mode(true);
12518 host_resolver_->rules()->AddIPLiteralRule(host_port_pair_.host(),
12519 kNonCachedIPAddress, "");
12520
12521 MockQuicData quic_data(version_);
12522 quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
12523 if (VersionUsesHttp3(version_.transport_version))
12524 quic_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
12525 quic_data.AddSocketDataToFactory(socket_factory_.get());
12526
12527 QuicStreamRequest request(factory_.get());
12528 EXPECT_EQ(
12529 ERR_IO_PENDING,
12530 request.Request(
12531 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
12532 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
12533 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
12534 failed_on_default_network_callback_, callback_.callback()));
12535 TestCompletionCallback host_resolution_callback;
12536 EXPECT_TRUE(
12537 request.WaitForHostResolution(host_resolution_callback.callback()));
12538 base::RunLoop().RunUntilIdle();
12539 EXPECT_FALSE(host_resolution_callback.have_result());
12540
12541 // Cause the host resolution to return.
12542 host_resolver_->ResolveAllPending();
12543 EXPECT_THAT(host_resolution_callback.WaitForResult(), IsOk());
12544 EXPECT_THAT(callback_.WaitForResult(), IsOk());
12545
12546 std::unique_ptr<HttpStream> stream = CreateStream(&request);
12547 EXPECT_TRUE(stream.get());
12548 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
12549
12550 EXPECT_EQ(session->peer_address().host().ToString(), kNonCachedIPAddress);
12551
12552 EXPECT_TRUE(quic_data.AllReadDataConsumed());
12553 EXPECT_TRUE(quic_data.AllWriteDataConsumed());
12554 }
12555
12556 // With dns race experiment on, DNS resolve returns async, stale dns used,
12557 // connects synchrounously, and then the resolved DNS matches.
TEST_P(QuicStreamFactoryTest,ResultAfterDNSRaceHostResolveAsyncStaleMatch)12558 TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceHostResolveAsyncStaleMatch) {
12559 quic_params_->race_stale_dns_on_connection = true;
12560 host_resolver_ = std::make_unique<MockCachingHostResolver>();
12561 Initialize();
12562 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
12563 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
12564
12565 // Set an address in resolver for asynchronous return.
12566 host_resolver_->set_ondemand_mode(true);
12567 host_resolver_->rules()->AddIPLiteralRule(host_port_pair_.host(),
12568 kCachedIPAddress.ToString(), "");
12569
12570 // Set up the same address in the stale resolver cache.
12571 HostCache::Key key(host_port_pair_.host(), DnsQueryType::UNSPECIFIED, 0,
12572 HostResolverSource::ANY, NetworkIsolationKey());
12573 HostCache::Entry entry(OK,
12574 AddressList::CreateFromIPAddress(kCachedIPAddress, 0),
12575 HostCache::Entry::SOURCE_DNS);
12576 base::TimeDelta zero;
12577 HostCache* cache = host_resolver_->GetHostCache();
12578 cache->Set(key, entry, base::TimeTicks::Now(), zero);
12579 // Expire the cache
12580 cache->Invalidate();
12581
12582 MockQuicData quic_data(version_);
12583 quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
12584 if (VersionUsesHttp3(version_.transport_version))
12585 quic_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
12586 quic_data.AddSocketDataToFactory(socket_factory_.get());
12587
12588 QuicStreamRequest request(factory_.get());
12589 EXPECT_EQ(
12590 ERR_IO_PENDING,
12591 request.Request(
12592 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
12593 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
12594 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
12595 failed_on_default_network_callback_, callback_.callback()));
12596
12597 // Check that the racing job is running.
12598 EXPECT_TRUE(HasLiveSession(host_port_pair_));
12599 EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_));
12600
12601 // Resolve dns and return.
12602 host_resolver_->ResolveAllPending();
12603 EXPECT_THAT(callback_.WaitForResult(), IsOk());
12604 std::unique_ptr<HttpStream> stream = CreateStream(&request);
12605 EXPECT_TRUE(stream.get());
12606
12607 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
12608
12609 EXPECT_EQ(session->peer_address().host().ToString(),
12610 kCachedIPAddress.ToString());
12611
12612 EXPECT_TRUE(quic_data.AllReadDataConsumed());
12613 EXPECT_TRUE(quic_data.AllWriteDataConsumed());
12614 }
12615
12616 // With dns race experiment on, dns resolve async, stale dns used, connect
12617 // async, and then the result matches.
TEST_P(QuicStreamFactoryTest,ResultAfterDNSRaceHostResolveAsyncConnectAsyncStaleMatch)12618 TEST_P(QuicStreamFactoryTest,
12619 ResultAfterDNSRaceHostResolveAsyncConnectAsyncStaleMatch) {
12620 quic_params_->race_stale_dns_on_connection = true;
12621 host_resolver_ = std::make_unique<MockCachingHostResolver>();
12622 Initialize();
12623 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
12624 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
12625
12626 // Set an address in resolver for asynchronous return.
12627 host_resolver_->set_ondemand_mode(true);
12628 factory_->set_is_quic_known_to_work_on_current_network(false);
12629 crypto_client_stream_factory_.set_handshake_mode(
12630 MockCryptoClientStream::ZERO_RTT);
12631 host_resolver_->rules()->AddIPLiteralRule(host_port_pair_.host(),
12632 kCachedIPAddress.ToString(), "");
12633
12634 // Set up the same address in the stale resolver cache.
12635 HostCache::Key key(host_port_pair_.host(), DnsQueryType::UNSPECIFIED, 0,
12636 HostResolverSource::ANY, NetworkIsolationKey());
12637 HostCache::Entry entry(OK,
12638 AddressList::CreateFromIPAddress(kCachedIPAddress, 0),
12639 HostCache::Entry::SOURCE_DNS);
12640 base::TimeDelta zero;
12641 HostCache* cache = host_resolver_->GetHostCache();
12642 cache->Set(key, entry, base::TimeTicks::Now(), zero);
12643 // Expire the cache
12644 cache->Invalidate();
12645
12646 MockQuicData quic_data(version_);
12647 quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
12648 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
12649 if (VersionUsesHttp3(version_.transport_version))
12650 quic_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
12651 quic_data.AddSocketDataToFactory(socket_factory_.get());
12652
12653 QuicStreamRequest request(factory_.get());
12654 EXPECT_EQ(
12655 ERR_IO_PENDING,
12656 request.Request(
12657 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
12658 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
12659 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
12660 failed_on_default_network_callback_, callback_.callback()));
12661
12662 // Send Crypto handshake so connect will call back.
12663 crypto_client_stream_factory_.last_stream()
12664 ->NotifySessionOneRttKeyAvailable();
12665 base::RunLoop().RunUntilIdle();
12666
12667 // Check that the racing job is running.
12668 EXPECT_TRUE(HasLiveSession(host_port_pair_));
12669 EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_));
12670
12671 // Resolve dns and call back, make sure job finishes.
12672 host_resolver_->ResolveAllPending();
12673 EXPECT_THAT(callback_.WaitForResult(), IsOk());
12674
12675 std::unique_ptr<HttpStream> stream = CreateStream(&request);
12676 EXPECT_TRUE(stream.get());
12677
12678 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
12679
12680 EXPECT_EQ(session->peer_address().host().ToString(),
12681 kCachedIPAddress.ToString());
12682
12683 EXPECT_TRUE(quic_data.AllReadDataConsumed());
12684 EXPECT_TRUE(quic_data.AllWriteDataConsumed());
12685 }
12686
12687 // With dns race experiment on, dns resolve async, stale dns used, dns resolve
12688 // return, then connection finishes and matches with the result.
TEST_P(QuicStreamFactoryTest,ResultAfterDNSRaceHostResolveAsyncStaleMatchConnectAsync)12689 TEST_P(QuicStreamFactoryTest,
12690 ResultAfterDNSRaceHostResolveAsyncStaleMatchConnectAsync) {
12691 quic_params_->race_stale_dns_on_connection = true;
12692 host_resolver_ = std::make_unique<MockCachingHostResolver>();
12693 Initialize();
12694 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
12695 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
12696
12697 // Set an address in resolver for asynchronous return.
12698 host_resolver_->set_ondemand_mode(true);
12699 factory_->set_is_quic_known_to_work_on_current_network(false);
12700 crypto_client_stream_factory_.set_handshake_mode(
12701 MockCryptoClientStream::ZERO_RTT);
12702 host_resolver_->rules()->AddIPLiteralRule(host_port_pair_.host(),
12703 kCachedIPAddress.ToString(), "");
12704
12705 // Set up the same address in the stale resolver cache.
12706 HostCache::Key key(host_port_pair_.host(), DnsQueryType::UNSPECIFIED, 0,
12707 HostResolverSource::ANY, NetworkIsolationKey());
12708 HostCache::Entry entry(OK,
12709 AddressList::CreateFromIPAddress(kCachedIPAddress, 0),
12710 HostCache::Entry::SOURCE_DNS);
12711 base::TimeDelta zero;
12712 HostCache* cache = host_resolver_->GetHostCache();
12713 cache->Set(key, entry, base::TimeTicks::Now(), zero);
12714 // Expire the cache
12715 cache->Invalidate();
12716
12717 MockQuicData quic_data(version_);
12718 quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
12719 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
12720 if (VersionUsesHttp3(version_.transport_version))
12721 quic_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
12722 quic_data.AddSocketDataToFactory(socket_factory_.get());
12723
12724 QuicStreamRequest request(factory_.get());
12725 EXPECT_EQ(
12726 ERR_IO_PENDING,
12727 request.Request(
12728 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
12729 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
12730 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
12731 failed_on_default_network_callback_, callback_.callback()));
12732
12733 // Finish dns async, check we still need to wait for stale connection async.
12734 host_resolver_->ResolveAllPending();
12735 base::RunLoop().RunUntilIdle();
12736 EXPECT_FALSE(callback_.have_result());
12737
12738 // Finish stale connection async, and the stale connection should pass dns
12739 // validation.
12740 crypto_client_stream_factory_.last_stream()
12741 ->NotifySessionOneRttKeyAvailable();
12742 EXPECT_THAT(callback_.WaitForResult(), IsOk());
12743 std::unique_ptr<HttpStream> stream = CreateStream(&request);
12744 EXPECT_TRUE(stream.get());
12745
12746 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
12747 EXPECT_EQ(session->peer_address().host().ToString(),
12748 kCachedIPAddress.ToString());
12749
12750 EXPECT_TRUE(quic_data.AllReadDataConsumed());
12751 EXPECT_TRUE(quic_data.AllWriteDataConsumed());
12752 }
12753
12754 // With dns race experiment on, dns resolve async, stale used and connects
12755 // sync, but dns no match
TEST_P(QuicStreamFactoryTest,ResultAfterDNSRaceHostResolveAsyncStaleSyncNoMatch)12756 TEST_P(QuicStreamFactoryTest,
12757 ResultAfterDNSRaceHostResolveAsyncStaleSyncNoMatch) {
12758 quic_params_->race_stale_dns_on_connection = true;
12759 host_resolver_ = std::make_unique<MockCachingHostResolver>();
12760 Initialize();
12761 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
12762 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
12763
12764 // Set an address in resolver for asynchronous return.
12765 host_resolver_->set_ondemand_mode(true);
12766 host_resolver_->rules()->AddIPLiteralRule(host_port_pair_.host(),
12767 kNonCachedIPAddress, "");
12768
12769 // Set up a different address in the stale resolver cache.
12770 HostCache::Key key(host_port_pair_.host(), DnsQueryType::UNSPECIFIED, 0,
12771 HostResolverSource::ANY, NetworkIsolationKey());
12772 HostCache::Entry entry(OK,
12773 AddressList::CreateFromIPAddress(kCachedIPAddress, 0),
12774 HostCache::Entry::SOURCE_DNS);
12775 base::TimeDelta zero;
12776 HostCache* cache = host_resolver_->GetHostCache();
12777 cache->Set(key, entry, base::TimeTicks::Now(), zero);
12778 // Expire the cache
12779 cache->Invalidate();
12780
12781 // Socket for the stale connection which will invoke connection closure.
12782 MockQuicData quic_data(version_);
12783 quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
12784 int packet_num = 1;
12785 if (VersionUsesHttp3(version_.transport_version)) {
12786 quic_data.AddWrite(SYNCHRONOUS,
12787 ConstructInitialSettingsPacket(packet_num++));
12788 }
12789 quic_data.AddWrite(SYNCHRONOUS,
12790 client_maker_.MakeConnectionClosePacket(
12791 packet_num++, true,
12792 quic::QUIC_STALE_CONNECTION_CANCELLED, "net error"));
12793 quic_data.AddSocketDataToFactory(socket_factory_.get());
12794
12795 // Socket for the new connection.
12796 client_maker_.Reset();
12797 MockQuicData quic_data2(version_);
12798 quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
12799 if (VersionUsesHttp3(version_.transport_version))
12800 quic_data2.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
12801 quic_data2.AddSocketDataToFactory(socket_factory_.get());
12802
12803 QuicStreamRequest request(factory_.get());
12804 EXPECT_EQ(
12805 ERR_IO_PENDING,
12806 request.Request(
12807 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
12808 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
12809 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
12810 failed_on_default_network_callback_, callback_.callback()));
12811
12812 // Check the stale connection is running.
12813 EXPECT_TRUE(HasLiveSession(host_port_pair_));
12814 EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_));
12815
12816 // Finish dns resolution and check the job has finished.
12817 host_resolver_->ResolveAllPending();
12818 EXPECT_THAT(callback_.WaitForResult(), IsOk());
12819
12820 std::unique_ptr<HttpStream> stream = CreateStream(&request);
12821 EXPECT_TRUE(stream.get());
12822
12823 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
12824
12825 EXPECT_EQ(session->peer_address().host().ToString(), kNonCachedIPAddress);
12826
12827 EXPECT_TRUE(quic_data.AllReadDataConsumed());
12828 EXPECT_TRUE(quic_data.AllWriteDataConsumed());
12829 EXPECT_TRUE(quic_data2.AllReadDataConsumed());
12830 EXPECT_TRUE(quic_data2.AllWriteDataConsumed());
12831 }
12832
12833 // With dns race experiment on, dns resolve async, stale used and connects
12834 // async, finishes before dns, but no match
TEST_P(QuicStreamFactoryTest,ResultAfterDNSRaceStaleAsyncResolveAsyncNoMatch)12835 TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceStaleAsyncResolveAsyncNoMatch) {
12836 quic_params_->race_stale_dns_on_connection = true;
12837 host_resolver_ = std::make_unique<MockCachingHostResolver>();
12838 Initialize();
12839 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
12840 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
12841
12842 // Set an address in resolver for asynchronous return.
12843 host_resolver_->set_ondemand_mode(true);
12844 factory_->set_is_quic_known_to_work_on_current_network(false);
12845 crypto_client_stream_factory_.set_handshake_mode(
12846 MockCryptoClientStream::ZERO_RTT);
12847 host_resolver_->rules()->AddIPLiteralRule(host_port_pair_.host(),
12848 kNonCachedIPAddress, "");
12849
12850 // Set up a different address in the stale resolver cache.
12851 HostCache::Key key(host_port_pair_.host(), DnsQueryType::UNSPECIFIED, 0,
12852 HostResolverSource::ANY, NetworkIsolationKey());
12853 HostCache::Entry entry(OK,
12854 AddressList::CreateFromIPAddress(kCachedIPAddress, 0),
12855 HostCache::Entry::SOURCE_DNS);
12856 base::TimeDelta zero;
12857 HostCache* cache = host_resolver_->GetHostCache();
12858 cache->Set(key, entry, base::TimeTicks::Now(), zero);
12859 // Expire the cache
12860 cache->Invalidate();
12861
12862 MockQuicData quic_data(version_);
12863 quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
12864 int packet_num = 1;
12865 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
12866 if (VersionUsesHttp3(version_.transport_version)) {
12867 quic_data.AddWrite(SYNCHRONOUS,
12868 ConstructInitialSettingsPacket(packet_num++));
12869 }
12870 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
12871 quic_data.AddWrite(SYNCHRONOUS,
12872 client_maker_.MakeConnectionClosePacket(
12873 packet_num++, true,
12874 quic::QUIC_STALE_CONNECTION_CANCELLED, "net error"));
12875 quic_data.AddSocketDataToFactory(socket_factory_.get());
12876
12877 client_maker_.Reset();
12878 MockQuicData quic_data2(version_);
12879 quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
12880 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
12881 if (VersionUsesHttp3(version_.transport_version)) {
12882 quic_data2.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
12883 }
12884 quic_data2.AddSocketDataToFactory(socket_factory_.get());
12885
12886 QuicStreamRequest request(factory_.get());
12887 EXPECT_EQ(
12888 ERR_IO_PENDING,
12889 request.Request(
12890 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
12891 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
12892 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
12893 failed_on_default_network_callback_, callback_.callback()));
12894
12895 // Finish the stale connection.
12896 crypto_client_stream_factory_.last_stream()
12897 ->NotifySessionOneRttKeyAvailable();
12898 base::RunLoop().RunUntilIdle();
12899 EXPECT_TRUE(HasLiveSession(host_port_pair_));
12900 EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_));
12901
12902 // Finish host resolution and check the job is done.
12903 host_resolver_->ResolveAllPending();
12904 EXPECT_THAT(callback_.WaitForResult(), IsOk());
12905
12906 std::unique_ptr<HttpStream> stream = CreateStream(&request);
12907 EXPECT_TRUE(stream.get());
12908
12909 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
12910 EXPECT_EQ(session->peer_address().host().ToString(), kNonCachedIPAddress);
12911
12912 EXPECT_TRUE(quic_data.AllReadDataConsumed());
12913 EXPECT_TRUE(quic_data.AllWriteDataConsumed());
12914 EXPECT_TRUE(quic_data2.AllReadDataConsumed());
12915 EXPECT_TRUE(quic_data2.AllWriteDataConsumed());
12916 }
12917
12918 // With dns race experiment on, dns resolve async, stale used and connects
12919 // async, dns finishes first, but no match
TEST_P(QuicStreamFactoryTest,ResultAfterDNSRaceResolveAsyncStaleAsyncNoMatch)12920 TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceResolveAsyncStaleAsyncNoMatch) {
12921 quic_params_->race_stale_dns_on_connection = true;
12922 host_resolver_ = std::make_unique<MockCachingHostResolver>();
12923 Initialize();
12924 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
12925 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
12926
12927 // Set an address in resolver for asynchronous return.
12928 host_resolver_->set_ondemand_mode(true);
12929 factory_->set_is_quic_known_to_work_on_current_network(false);
12930 crypto_client_stream_factory_.set_handshake_mode(
12931 MockCryptoClientStream::ZERO_RTT);
12932 host_resolver_->rules()->AddIPLiteralRule(host_port_pair_.host(),
12933 kNonCachedIPAddress, "");
12934
12935 // Set up a different address in the stale resolver cache.
12936 HostCache::Key key(host_port_pair_.host(), DnsQueryType::UNSPECIFIED, 0,
12937 HostResolverSource::ANY, NetworkIsolationKey());
12938 HostCache::Entry entry(OK,
12939 AddressList::CreateFromIPAddress(kCachedIPAddress, 0),
12940 HostCache::Entry::SOURCE_DNS);
12941 base::TimeDelta zero;
12942 HostCache* cache = host_resolver_->GetHostCache();
12943 cache->Set(key, entry, base::TimeTicks::Now(), zero);
12944 // Expire the cache
12945 cache->Invalidate();
12946
12947 MockQuicData quic_data(version_);
12948 quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
12949 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
12950 int packet_number = 1;
12951 if (VersionUsesHttp3(version_.transport_version))
12952 quic_data.AddWrite(SYNCHRONOUS,
12953 ConstructInitialSettingsPacket(packet_number++));
12954 quic_data.AddWrite(SYNCHRONOUS,
12955 client_maker_.MakeConnectionClosePacket(
12956 packet_number++, true,
12957 quic::QUIC_STALE_CONNECTION_CANCELLED, "net error"));
12958 quic_data.AddSocketDataToFactory(socket_factory_.get());
12959
12960 client_maker_.Reset();
12961 MockQuicData quic_data2(version_);
12962 quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
12963 if (VersionUsesHttp3(version_.transport_version))
12964 quic_data2.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
12965 quic_data2.AddSocketDataToFactory(socket_factory_.get());
12966
12967 QuicStreamRequest request(factory_.get());
12968 EXPECT_EQ(
12969 ERR_IO_PENDING,
12970 request.Request(
12971 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
12972 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
12973 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
12974 failed_on_default_network_callback_, callback_.callback()));
12975 // Finish dns resolution, but need to wait for stale connection.
12976 host_resolver_->ResolveAllPending();
12977 base::RunLoop().RunUntilIdle();
12978 crypto_client_stream_factory_.last_stream()
12979 ->NotifySessionOneRttKeyAvailable();
12980 EXPECT_THAT(callback_.WaitForResult(), IsOk());
12981
12982 std::unique_ptr<HttpStream> stream = CreateStream(&request);
12983 EXPECT_TRUE(stream.get());
12984
12985 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
12986 EXPECT_EQ(session->peer_address().host().ToString(), kNonCachedIPAddress);
12987
12988 EXPECT_TRUE(quic_data.AllReadDataConsumed());
12989 EXPECT_TRUE(quic_data.AllWriteDataConsumed());
12990 EXPECT_TRUE(quic_data2.AllReadDataConsumed());
12991 EXPECT_TRUE(quic_data2.AllWriteDataConsumed());
12992 }
12993
12994 // With dns race experiment on, dns resolve returns error sync, same behavior
12995 // as experiment is not on
TEST_P(QuicStreamFactoryTest,ResultAfterDNSRaceHostResolveError)12996 TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceHostResolveError) {
12997 quic_params_->race_stale_dns_on_connection = true;
12998 host_resolver_ = std::make_unique<MockCachingHostResolver>();
12999 Initialize();
13000 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
13001 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
13002
13003 // Set synchronous failure in resolver.
13004 host_resolver_->set_synchronous_mode(true);
13005 host_resolver_->rules()->AddSimulatedFailure(host_port_pair_.host());
13006
13007 MockQuicData quic_data(version_);
13008 quic_data.AddSocketDataToFactory(socket_factory_.get());
13009 QuicStreamRequest request(factory_.get());
13010
13011 EXPECT_EQ(
13012 ERR_NAME_NOT_RESOLVED,
13013 request.Request(
13014 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
13015 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
13016 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
13017 failed_on_default_network_callback_, callback_.callback()));
13018 }
13019
13020 // With dns race experiment on, no cache available, dns resolve returns error
13021 // async
TEST_P(QuicStreamFactoryTest,ResultAfterDNSRaceHostResolveAsyncError)13022 TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceHostResolveAsyncError) {
13023 quic_params_->race_stale_dns_on_connection = true;
13024 host_resolver_ = std::make_unique<MockCachingHostResolver>();
13025 Initialize();
13026 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
13027 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
13028
13029 // Set asynchronous failure in resolver.
13030 host_resolver_->set_ondemand_mode(true);
13031 host_resolver_->rules()->AddSimulatedFailure(host_port_pair_.host());
13032
13033 MockQuicData quic_data(version_);
13034 quic_data.AddSocketDataToFactory(socket_factory_.get());
13035 QuicStreamRequest request(factory_.get());
13036
13037 EXPECT_EQ(
13038 ERR_IO_PENDING,
13039 request.Request(
13040 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
13041 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
13042 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
13043 failed_on_default_network_callback_, callback_.callback()));
13044
13045 // Resolve and expect result that shows the resolution error.
13046 host_resolver_->ResolveAllPending();
13047 EXPECT_THAT(callback_.WaitForResult(), IsError(ERR_NAME_NOT_RESOLVED));
13048 }
13049
13050 // With dns race experiment on, dns resolve async, staled used and connects
13051 // sync, dns returns error and no connection is established.
TEST_P(QuicStreamFactoryTest,ResultAfterDNSRaceStaleSyncHostResolveError)13052 TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceStaleSyncHostResolveError) {
13053 quic_params_->race_stale_dns_on_connection = true;
13054 host_resolver_ = std::make_unique<MockCachingHostResolver>();
13055 Initialize();
13056 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
13057 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
13058
13059 // Set asynchronous failure in resolver.
13060 host_resolver_->set_ondemand_mode(true);
13061 host_resolver_->rules()->AddSimulatedFailure(host_port_pair_.host());
13062
13063 // Set up an address in the stale cache.
13064 HostCache::Key key(host_port_pair_.host(), DnsQueryType::UNSPECIFIED, 0,
13065 HostResolverSource::ANY, NetworkIsolationKey());
13066 HostCache::Entry entry(OK,
13067 AddressList::CreateFromIPAddress(kCachedIPAddress, 0),
13068 HostCache::Entry::SOURCE_DNS);
13069 base::TimeDelta zero;
13070 HostCache* cache = host_resolver_->GetHostCache();
13071 cache->Set(key, entry, base::TimeTicks::Now(), zero);
13072 // Expire the cache
13073 cache->Invalidate();
13074
13075 // Socket for the stale connection which is supposed to disconnect.
13076 MockQuicData quic_data(version_);
13077 quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
13078 int packet_num = 1;
13079 if (VersionUsesHttp3(version_.transport_version)) {
13080 quic_data.AddWrite(SYNCHRONOUS,
13081 ConstructInitialSettingsPacket(packet_num++));
13082 }
13083 quic_data.AddWrite(SYNCHRONOUS,
13084 client_maker_.MakeConnectionClosePacket(
13085 packet_num++, true,
13086 quic::QUIC_STALE_CONNECTION_CANCELLED, "net error"));
13087 quic_data.AddSocketDataToFactory(socket_factory_.get());
13088
13089 QuicStreamRequest request(factory_.get());
13090 EXPECT_EQ(
13091 ERR_IO_PENDING,
13092 request.Request(
13093 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
13094 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
13095 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
13096 failed_on_default_network_callback_, callback_.callback()));
13097
13098 // Check that the stale connection is running.
13099 EXPECT_TRUE(HasLiveSession(host_port_pair_));
13100 EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_));
13101
13102 // Finish host resolution.
13103 host_resolver_->ResolveAllPending();
13104 EXPECT_THAT(callback_.WaitForResult(), IsError(ERR_NAME_NOT_RESOLVED));
13105
13106 EXPECT_TRUE(quic_data.AllReadDataConsumed());
13107 EXPECT_TRUE(quic_data.AllWriteDataConsumed());
13108 }
13109
13110 // With dns race experiment on, dns resolve async, stale used and connection
13111 // return error, then dns matches.
13112 // This serves as a regression test for crbug.com/956374.
TEST_P(QuicStreamFactoryTest,ResultAfterDNSRaceStaleErrorDNSMatches)13113 TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceStaleErrorDNSMatches) {
13114 quic_params_->race_stale_dns_on_connection = true;
13115 host_resolver_ = std::make_unique<MockCachingHostResolver>();
13116 Initialize();
13117 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
13118 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
13119
13120 // Set an address in host resolver for asynchronous return.
13121 host_resolver_->set_ondemand_mode(true);
13122 host_resolver_->rules()->AddIPLiteralRule(host_port_pair_.host(),
13123 kCachedIPAddress.ToString(), "");
13124
13125 // Set up the same address in the stale resolver cache.
13126 HostCache::Key key(host_port_pair_.host(), DnsQueryType::UNSPECIFIED, 0,
13127 HostResolverSource::ANY, NetworkIsolationKey());
13128 HostCache::Entry entry(OK,
13129 AddressList::CreateFromIPAddress(kCachedIPAddress, 0),
13130 HostCache::Entry::SOURCE_DNS);
13131 base::TimeDelta zero;
13132 HostCache* cache = host_resolver_->GetHostCache();
13133 cache->Set(key, entry, base::TimeTicks::Now(), zero);
13134 // Expire the cache
13135 cache->Invalidate();
13136
13137 // Simulate synchronous connect failure.
13138 MockQuicData quic_data(version_);
13139 quic_data.AddConnect(SYNCHRONOUS, ERR_ADDRESS_IN_USE);
13140 quic_data.AddSocketDataToFactory(socket_factory_.get());
13141
13142 MockQuicData quic_data2(version_);
13143 quic_data2.AddConnect(SYNCHRONOUS, ERR_ADDRESS_IN_USE);
13144 quic_data2.AddSocketDataToFactory(socket_factory_.get());
13145
13146 QuicStreamRequest request(factory_.get());
13147 EXPECT_EQ(
13148 ERR_IO_PENDING,
13149 request.Request(
13150 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
13151 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
13152 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
13153 failed_on_default_network_callback_, callback_.callback()));
13154 EXPECT_FALSE(HasLiveSession(host_port_pair_));
13155 EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_));
13156
13157 host_resolver_->ResolveAllPending();
13158 EXPECT_THAT(callback_.WaitForResult(), IsError(ERR_ADDRESS_IN_USE));
13159 }
13160
13161 // With dns race experiment on, dns resolve async, stale used and connection
13162 // returns error, dns no match, new connection is established
TEST_P(QuicStreamFactoryTest,ResultAfterDNSRaceStaleErrorDNSNoMatch)13163 TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceStaleErrorDNSNoMatch) {
13164 quic_params_->race_stale_dns_on_connection = true;
13165 host_resolver_ = std::make_unique<MockCachingHostResolver>();
13166 Initialize();
13167 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
13168 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
13169
13170 // Set an address in host resolver.
13171 host_resolver_->set_ondemand_mode(true);
13172 host_resolver_->rules()->AddIPLiteralRule(host_port_pair_.host(),
13173 kNonCachedIPAddress, "");
13174
13175 // Set up a different address in stale resolver cache.
13176 HostCache::Key key(host_port_pair_.host(), DnsQueryType::UNSPECIFIED, 0,
13177 HostResolverSource::ANY, NetworkIsolationKey());
13178 HostCache::Entry entry(OK,
13179 AddressList::CreateFromIPAddress(kCachedIPAddress, 0),
13180 HostCache::Entry::SOURCE_DNS);
13181 base::TimeDelta zero;
13182 HostCache* cache = host_resolver_->GetHostCache();
13183 cache->Set(key, entry, base::TimeTicks::Now(), zero);
13184 // Expire the cache
13185 cache->Invalidate();
13186
13187 // Add failure for the stale connection.
13188 MockQuicData quic_data(version_);
13189 quic_data.AddConnect(SYNCHRONOUS, ERR_ADDRESS_IN_USE);
13190 quic_data.AddSocketDataToFactory(socket_factory_.get());
13191
13192 client_maker_.Reset();
13193 MockQuicData quic_data2(version_);
13194 quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
13195 if (VersionUsesHttp3(version_.transport_version))
13196 quic_data2.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
13197 quic_data2.AddSocketDataToFactory(socket_factory_.get());
13198
13199 QuicStreamRequest request(factory_.get());
13200 EXPECT_EQ(
13201 ERR_IO_PENDING,
13202 request.Request(
13203 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
13204 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
13205 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
13206 failed_on_default_network_callback_, callback_.callback()));
13207
13208 // Check that the stale connection fails.
13209 EXPECT_FALSE(HasLiveSession(host_port_pair_));
13210 EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_));
13211
13212 // Finish host resolution and check the job finishes ok.
13213 host_resolver_->ResolveAllPending();
13214 EXPECT_THAT(callback_.WaitForResult(), IsOk());
13215
13216 std::unique_ptr<HttpStream> stream = CreateStream(&request);
13217 EXPECT_TRUE(stream.get());
13218
13219 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
13220
13221 EXPECT_EQ(session->peer_address().host().ToString(), kNonCachedIPAddress);
13222
13223 EXPECT_TRUE(quic_data2.AllReadDataConsumed());
13224 EXPECT_TRUE(quic_data2.AllWriteDataConsumed());
13225 }
13226
13227 // With dns race experiment on, dns resolve async, stale used and connection
13228 // returns error, dns no match, new connection error
TEST_P(QuicStreamFactoryTest,ResultAfterDNSRaceStaleErrorDNSNoMatchError)13229 TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceStaleErrorDNSNoMatchError) {
13230 quic_params_->race_stale_dns_on_connection = true;
13231 host_resolver_ = std::make_unique<MockCachingHostResolver>();
13232 Initialize();
13233 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
13234 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
13235
13236 // Set an address in host resolver asynchronously.
13237 host_resolver_->set_ondemand_mode(true);
13238 host_resolver_->rules()->AddIPLiteralRule(host_port_pair_.host(),
13239 kNonCachedIPAddress, "");
13240
13241 // Set up a different address in the stale cache.
13242 HostCache::Key key(host_port_pair_.host(), DnsQueryType::UNSPECIFIED, 0,
13243 HostResolverSource::ANY, NetworkIsolationKey());
13244 HostCache::Entry entry(OK,
13245 AddressList::CreateFromIPAddress(kCachedIPAddress, 0),
13246 HostCache::Entry::SOURCE_DNS);
13247 base::TimeDelta zero;
13248 HostCache* cache = host_resolver_->GetHostCache();
13249 cache->Set(key, entry, base::TimeTicks::Now(), zero);
13250 // Expire the cache
13251 cache->Invalidate();
13252
13253 // Add failure for stale connection.
13254 MockQuicData quic_data(version_);
13255 quic_data.AddConnect(SYNCHRONOUS, ERR_ADDRESS_IN_USE);
13256 quic_data.AddSocketDataToFactory(socket_factory_.get());
13257
13258 // Add failure for resolved dns connection.
13259 MockQuicData quic_data2(version_);
13260 quic_data2.AddConnect(SYNCHRONOUS, ERR_ADDRESS_IN_USE);
13261 quic_data2.AddSocketDataToFactory(socket_factory_.get());
13262
13263 QuicStreamRequest request(factory_.get());
13264 EXPECT_EQ(
13265 ERR_IO_PENDING,
13266 request.Request(
13267 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
13268 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
13269 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
13270 failed_on_default_network_callback_, callback_.callback()));
13271
13272 // Check the stale connection fails.
13273 EXPECT_FALSE(HasLiveSession(host_port_pair_));
13274 EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_));
13275
13276 // Check the resolved dns connection fails.
13277 host_resolver_->ResolveAllPending();
13278 EXPECT_THAT(callback_.WaitForResult(), IsError(ERR_ADDRESS_IN_USE));
13279 }
13280
13281 // With dns race experiment on, dns resolve async and stale connect async, dns
13282 // resolve returns error and then preconnect finishes
TEST_P(QuicStreamFactoryTest,ResultAfterDNSRaceResolveAsyncErrorStaleAsync)13283 TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceResolveAsyncErrorStaleAsync) {
13284 quic_params_->race_stale_dns_on_connection = true;
13285 host_resolver_ = std::make_unique<MockCachingHostResolver>();
13286 Initialize();
13287 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
13288 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
13289
13290 // Add asynchronous failure in host resolver.
13291 host_resolver_->set_ondemand_mode(true);
13292 host_resolver_->rules()->AddSimulatedFailure(host_port_pair_.host());
13293 factory_->set_is_quic_known_to_work_on_current_network(false);
13294
13295 // Set up an address in stale resolver cache.
13296 HostCache::Key key(host_port_pair_.host(), DnsQueryType::UNSPECIFIED, 0,
13297 HostResolverSource::ANY, NetworkIsolationKey());
13298 HostCache::Entry entry(OK,
13299 AddressList::CreateFromIPAddress(kCachedIPAddress, 0),
13300 HostCache::Entry::SOURCE_DNS);
13301 base::TimeDelta zero;
13302 HostCache* cache = host_resolver_->GetHostCache();
13303 cache->Set(key, entry, base::TimeTicks::Now(), zero);
13304 // Expire the cache
13305 cache->Invalidate();
13306
13307 // Socket data for stale connection which is supposed to disconnect.
13308 MockQuicData quic_data(version_);
13309 quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
13310 int packet_number = 1;
13311 if (VersionUsesHttp3(version_.transport_version)) {
13312 quic_data.AddWrite(SYNCHRONOUS,
13313 ConstructInitialSettingsPacket(packet_number++));
13314 }
13315 quic_data.AddWrite(SYNCHRONOUS,
13316 client_maker_.MakeConnectionClosePacket(
13317 packet_number++, true,
13318 quic::QUIC_STALE_CONNECTION_CANCELLED, "net error"));
13319 quic_data.AddSocketDataToFactory(socket_factory_.get());
13320
13321 QuicStreamRequest request(factory_.get());
13322 EXPECT_EQ(
13323 ERR_IO_PENDING,
13324 request.Request(
13325 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
13326 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
13327 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
13328 failed_on_default_network_callback_, callback_.callback()));
13329
13330 // host resolution returned but stale connection hasn't finished yet.
13331 host_resolver_->ResolveAllPending();
13332 EXPECT_THAT(callback_.WaitForResult(), IsError(ERR_NAME_NOT_RESOLVED));
13333
13334 EXPECT_TRUE(quic_data.AllReadDataConsumed());
13335 EXPECT_TRUE(quic_data.AllWriteDataConsumed());
13336 }
13337
13338 // With dns race experiment on, dns resolve async and stale connect async, dns
13339 // resolve returns error and then preconnect fails.
TEST_P(QuicStreamFactoryTest,ResultAfterDNSRaceResolveAsyncErrorStaleAsyncError)13340 TEST_P(QuicStreamFactoryTest,
13341 ResultAfterDNSRaceResolveAsyncErrorStaleAsyncError) {
13342 quic_params_->race_stale_dns_on_connection = true;
13343 host_resolver_ = std::make_unique<MockCachingHostResolver>();
13344 Initialize();
13345 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
13346 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
13347
13348 // Add asynchronous failure to host resolver.
13349 host_resolver_->set_ondemand_mode(true);
13350 factory_->set_is_quic_known_to_work_on_current_network(false);
13351 host_resolver_->rules()->AddSimulatedFailure(host_port_pair_.host());
13352
13353 // Set up an address in stale resolver cache.
13354 HostCache::Key key(host_port_pair_.host(), DnsQueryType::UNSPECIFIED, 0,
13355 HostResolverSource::ANY, NetworkIsolationKey());
13356 HostCache::Entry entry(OK,
13357 AddressList::CreateFromIPAddress(kCachedIPAddress, 0),
13358 HostCache::Entry::SOURCE_DNS);
13359 base::TimeDelta zero;
13360 HostCache* cache = host_resolver_->GetHostCache();
13361 cache->Set(key, entry, base::TimeTicks::Now(), zero);
13362 // Expire the cache
13363 cache->Invalidate();
13364
13365 MockQuicData quic_data(version_);
13366 quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
13367 int packet_number = 1;
13368 if (VersionUsesHttp3(version_.transport_version)) {
13369 quic_data.AddWrite(SYNCHRONOUS,
13370 ConstructInitialSettingsPacket(packet_number++));
13371 }
13372 quic_data.AddWrite(SYNCHRONOUS,
13373 client_maker_.MakeConnectionClosePacket(
13374 packet_number++, true,
13375 quic::QUIC_STALE_CONNECTION_CANCELLED, "net error"));
13376 quic_data.AddSocketDataToFactory(socket_factory_.get());
13377
13378 QuicStreamRequest request(factory_.get());
13379 EXPECT_EQ(
13380 ERR_IO_PENDING,
13381 request.Request(
13382 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
13383 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
13384 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
13385 failed_on_default_network_callback_, callback_.callback()));
13386
13387 // Host Resolution returns failure but stale connection hasn't finished.
13388 host_resolver_->ResolveAllPending();
13389
13390 // Check that the final error is on resolution failure.
13391 EXPECT_THAT(callback_.WaitForResult(), IsError(ERR_NAME_NOT_RESOLVED));
13392
13393 EXPECT_TRUE(quic_data.AllReadDataConsumed());
13394 }
13395
13396 // With dns race experiment on, test that host resolution callback behaves
13397 // normal as experiment is not on
TEST_P(QuicStreamFactoryTest,ResultAfterDNSRaceHostResolveAsync)13398 TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceHostResolveAsync) {
13399 quic_params_->race_stale_dns_on_connection = true;
13400 host_resolver_ = std::make_unique<MockCachingHostResolver>();
13401 Initialize();
13402 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
13403 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
13404
13405 host_resolver_->set_ondemand_mode(true);
13406 host_resolver_->rules()->AddIPLiteralRule(host_port_pair_.host(),
13407 kNonCachedIPAddress, "");
13408
13409 MockQuicData quic_data(version_);
13410 quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
13411 if (VersionUsesHttp3(version_.transport_version))
13412 quic_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
13413 quic_data.AddSocketDataToFactory(socket_factory_.get());
13414
13415 QuicStreamRequest request(factory_.get());
13416 EXPECT_EQ(
13417 ERR_IO_PENDING,
13418 request.Request(
13419 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
13420 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
13421 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
13422 failed_on_default_network_callback_, callback_.callback()));
13423
13424 // Check that expect_on_host_resolution_ is properlly set.
13425 TestCompletionCallback host_resolution_callback;
13426 EXPECT_TRUE(
13427 request.WaitForHostResolution(host_resolution_callback.callback()));
13428 base::RunLoop().RunUntilIdle();
13429 EXPECT_FALSE(host_resolution_callback.have_result());
13430
13431 host_resolver_->ResolveAllPending();
13432 EXPECT_THAT(host_resolution_callback.WaitForResult(), IsOk());
13433
13434 // Check that expect_on_host_resolution_ is flipped back.
13435 EXPECT_FALSE(
13436 request.WaitForHostResolution(host_resolution_callback.callback()));
13437
13438 EXPECT_TRUE(quic_data.AllReadDataConsumed());
13439 EXPECT_TRUE(quic_data.AllWriteDataConsumed());
13440 }
13441
13442 // With stale dns and migration before handshake experiment on, migration failed
13443 // after handshake confirmed, and then fresh resolve returns.
TEST_P(QuicStreamFactoryTest,StaleNetworkFailedAfterHandshake)13444 TEST_P(QuicStreamFactoryTest, StaleNetworkFailedAfterHandshake) {
13445 quic_params_->race_stale_dns_on_connection = true;
13446 host_resolver_ = std::make_unique<MockCachingHostResolver>();
13447
13448 InitializeConnectionMigrationV2Test(
13449 {kDefaultNetworkForTests, kNewNetworkForTests});
13450 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
13451 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
13452
13453 // Set an address in resolver for asynchronous return.
13454 host_resolver_->set_ondemand_mode(true);
13455 host_resolver_->rules()->AddIPLiteralRule(host_port_pair_.host(),
13456 kNonCachedIPAddress, "");
13457
13458 // Set up the same address in the stale resolver cache.
13459 HostCache::Key key(host_port_pair_.host(), DnsQueryType::UNSPECIFIED, 0,
13460 HostResolverSource::ANY, NetworkIsolationKey());
13461 HostCache::Entry entry(OK,
13462 AddressList::CreateFromIPAddress(kCachedIPAddress, 0),
13463 HostCache::Entry::SOURCE_DNS);
13464 base::TimeDelta zero;
13465 HostCache* cache = host_resolver_->GetHostCache();
13466 cache->Set(key, entry, base::TimeTicks::Now(), zero);
13467 // Expire the cache
13468 cache->Invalidate();
13469
13470 MockQuicData quic_data(version_);
13471 quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
13472 if (VersionUsesHttp3(version_.transport_version))
13473 quic_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
13474 quic_data.AddSocketDataToFactory(socket_factory_.get());
13475
13476 // Socket for the new connection.
13477 client_maker_.Reset();
13478 MockQuicData quic_data2(version_);
13479 quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
13480 if (VersionUsesHttp3(version_.transport_version))
13481 quic_data2.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
13482 quic_data2.AddSocketDataToFactory(socket_factory_.get());
13483
13484 QuicStreamRequest request(factory_.get());
13485 EXPECT_EQ(
13486 ERR_IO_PENDING,
13487 request.Request(
13488 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
13489 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
13490 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
13491 failed_on_default_network_callback_, callback_.callback()));
13492
13493 // Check that the racing job is running.
13494 EXPECT_TRUE(HasLiveSession(host_port_pair_));
13495 EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_));
13496
13497 // By disconnecting the network, the stale session will be killed.
13498 scoped_mock_network_change_notifier_->mock_network_change_notifier()
13499 ->NotifyNetworkDisconnected(kDefaultNetworkForTests);
13500
13501 host_resolver_->ResolveAllPending();
13502 EXPECT_THAT(callback_.WaitForResult(), IsOk());
13503
13504 std::unique_ptr<HttpStream> stream = CreateStream(&request);
13505 EXPECT_TRUE(stream.get());
13506
13507 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
13508
13509 EXPECT_EQ(session->peer_address().host().ToString(), kNonCachedIPAddress);
13510
13511 EXPECT_TRUE(quic_data.AllReadDataConsumed());
13512 EXPECT_TRUE(quic_data.AllWriteDataConsumed());
13513 EXPECT_TRUE(quic_data2.AllReadDataConsumed());
13514 EXPECT_TRUE(quic_data2.AllWriteDataConsumed());
13515 }
13516
13517 // With stale dns experiment on, the stale session is killed while waiting for
13518 // handshake
TEST_P(QuicStreamFactoryTest,StaleNetworkFailedBeforeHandshake)13519 TEST_P(QuicStreamFactoryTest, StaleNetworkFailedBeforeHandshake) {
13520 quic_params_->race_stale_dns_on_connection = true;
13521 host_resolver_ = std::make_unique<MockCachingHostResolver>();
13522 InitializeConnectionMigrationV2Test(
13523 {kDefaultNetworkForTests, kNewNetworkForTests});
13524 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
13525 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
13526
13527 // Set an address in resolver for asynchronous return.
13528 host_resolver_->set_ondemand_mode(true);
13529 factory_->set_is_quic_known_to_work_on_current_network(false);
13530 crypto_client_stream_factory_.set_handshake_mode(
13531 MockCryptoClientStream::ZERO_RTT);
13532 host_resolver_->rules()->AddIPLiteralRule(host_port_pair_.host(),
13533 kNonCachedIPAddress, "");
13534
13535 // Set up a different address in the stale resolvercache.
13536 HostCache::Key key(host_port_pair_.host(), DnsQueryType::UNSPECIFIED, 0,
13537 HostResolverSource::ANY, NetworkIsolationKey());
13538 HostCache::Entry entry(OK,
13539 AddressList::CreateFromIPAddress(kCachedIPAddress, 0),
13540 HostCache::Entry::SOURCE_DNS);
13541 base::TimeDelta zero;
13542 HostCache* cache = host_resolver_->GetHostCache();
13543 cache->Set(key, entry, base::TimeTicks::Now(), zero);
13544 // Expire the cache
13545 cache->Invalidate();
13546
13547 MockQuicData quic_data(version_);
13548 quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
13549 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
13550 if (VersionUsesHttp3(version_.transport_version))
13551 quic_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
13552 quic_data.AddSocketDataToFactory(socket_factory_.get());
13553
13554 client_maker_.Reset();
13555 MockQuicData quic_data2(version_);
13556 quic_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
13557 if (VersionUsesHttp3(version_.transport_version))
13558 quic_data2.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
13559 quic_data2.AddSocketDataToFactory(socket_factory_.get());
13560
13561 QuicStreamRequest request(factory_.get());
13562 EXPECT_EQ(
13563 ERR_IO_PENDING,
13564 request.Request(
13565 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
13566 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
13567 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
13568 failed_on_default_network_callback_, callback_.callback()));
13569
13570 // Check that the racing job is running.
13571 EXPECT_TRUE(HasLiveSession(host_port_pair_));
13572 EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_));
13573
13574 // By disconnecting the network, the stale session will be killed.
13575 scoped_mock_network_change_notifier_->mock_network_change_notifier()
13576 ->NotifyNetworkDisconnected(kDefaultNetworkForTests);
13577
13578 host_resolver_->ResolveAllPending();
13579 base::RunLoop().RunUntilIdle();
13580 // Make sure the fresh session is established.
13581 crypto_client_stream_factory_.last_stream()
13582 ->NotifySessionOneRttKeyAvailable();
13583 EXPECT_THAT(callback_.WaitForResult(), IsOk());
13584
13585 std::unique_ptr<HttpStream> stream = CreateStream(&request);
13586 EXPECT_TRUE(stream.get());
13587
13588 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
13589 EXPECT_EQ(session->peer_address().host().ToString(), kNonCachedIPAddress);
13590
13591 EXPECT_TRUE(quic_data.AllReadDataConsumed());
13592 EXPECT_TRUE(quic_data.AllWriteDataConsumed());
13593 EXPECT_TRUE(quic_data2.AllReadDataConsumed());
13594 EXPECT_TRUE(quic_data2.AllWriteDataConsumed());
13595 }
13596
TEST_P(QuicStreamFactoryTest,ConfigInitialRttForHandshake)13597 TEST_P(QuicStreamFactoryTest, ConfigInitialRttForHandshake) {
13598 if (version_.UsesTls()) {
13599 // IETF QUIC uses a different handshake timeout management system.
13600 return;
13601 }
13602 constexpr base::TimeDelta kInitialRtt =
13603 base::TimeDelta::FromMilliseconds(400);
13604 quic_params_->initial_rtt_for_handshake = kInitialRtt;
13605 crypto_client_stream_factory_.set_handshake_mode(
13606 MockCryptoClientStream::COLD_START_WITH_CHLO_SENT);
13607 Initialize();
13608 factory_->set_is_quic_known_to_work_on_current_network(false);
13609 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
13610 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
13611
13612 // Using a testing task runner so that we can control time.
13613 auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
13614
13615 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
13616 QuicStreamFactoryPeer::SetAlarmFactory(
13617 factory_.get(), std::make_unique<QuicChromiumAlarmFactory>(
13618 task_runner.get(), context_.clock()));
13619
13620 MockQuicData socket_data(version_);
13621 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
13622 socket_data.AddWrite(ASYNC, client_maker_.MakeDummyCHLOPacket(1));
13623 socket_data.AddWrite(ASYNC, client_maker_.MakeDummyCHLOPacket(2));
13624 client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
13625 if (VersionUsesHttp3(version_.transport_version)) {
13626 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket(3));
13627 }
13628
13629 socket_data.AddSocketDataToFactory(socket_factory_.get());
13630
13631 QuicStreamRequest request(factory_.get());
13632 EXPECT_EQ(
13633 ERR_IO_PENDING,
13634 request.Request(
13635 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
13636 SocketTag(), NetworkIsolationKey(), false /* disable_secure_dns */,
13637 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
13638 failed_on_default_network_callback_, callback_.callback()));
13639 base::RunLoop().RunUntilIdle();
13640
13641 EXPECT_FALSE(HasActiveSession(host_port_pair_));
13642 EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_));
13643
13644 // The pending task is scheduled for handshake timeout retransmission,
13645 // which is 2 * 400ms with crypto frames and 1.5 * 400ms otherwise.
13646 base::TimeDelta handshake_timeout =
13647 QuicVersionUsesCryptoFrames(version_.transport_version)
13648 ? 2 * kInitialRtt
13649 : 1.5 * kInitialRtt;
13650 EXPECT_EQ(handshake_timeout, task_runner->NextPendingTaskDelay());
13651
13652 // The alarm factory dependes on |clock_|, so clock is advanced to trigger
13653 // retransmission alarm.
13654 context_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(
13655 handshake_timeout.InMilliseconds()));
13656 task_runner->FastForwardBy(handshake_timeout);
13657
13658 crypto_client_stream_factory_.last_stream()
13659 ->NotifySessionOneRttKeyAvailable();
13660
13661 EXPECT_THAT(callback_.WaitForResult(), IsOk());
13662
13663 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
13664 EXPECT_EQ(400000u, session->config()->GetInitialRoundTripTimeUsToSend());
13665 EXPECT_TRUE(socket_data.AllReadDataConsumed());
13666 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
13667 }
13668
13669 // Test that QuicStreamRequests with similar and different tags results in
13670 // reused and unique QUIC streams using appropriately tagged sockets.
TEST_P(QuicStreamFactoryTest,Tag)13671 TEST_P(QuicStreamFactoryTest, Tag) {
13672 MockTaggingClientSocketFactory* socket_factory =
13673 new MockTaggingClientSocketFactory();
13674 socket_factory_.reset(socket_factory);
13675 Initialize();
13676 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
13677 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
13678
13679 // Prepare to establish two QUIC sessions.
13680 MockQuicData socket_data(version_);
13681 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
13682 if (VersionUsesHttp3(version_.transport_version))
13683 socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
13684 socket_data.AddSocketDataToFactory(socket_factory_.get());
13685 client_maker_.Reset();
13686 MockQuicData socket_data2(version_);
13687 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
13688 if (VersionUsesHttp3(version_.transport_version))
13689 socket_data2.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
13690 socket_data2.AddSocketDataToFactory(socket_factory_.get());
13691
13692 #if defined(OS_ANDROID)
13693 SocketTag tag1(SocketTag::UNSET_UID, 0x12345678);
13694 SocketTag tag2(getuid(), 0x87654321);
13695 #else
13696 // On non-Android platforms we can only use the default constructor.
13697 SocketTag tag1, tag2;
13698 #endif
13699
13700 // Request a stream with |tag1|.
13701 QuicStreamRequest request1(factory_.get());
13702 int rv = request1.Request(
13703 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY, tag1,
13704 NetworkIsolationKey(), false /* disable_secure_dns */,
13705 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
13706 failed_on_default_network_callback_, callback_.callback());
13707 EXPECT_THAT(callback_.GetResult(rv), IsOk());
13708 EXPECT_EQ(socket_factory->GetLastProducedUDPSocket()->tag(), tag1);
13709 EXPECT_TRUE(socket_factory->GetLastProducedUDPSocket()
13710 ->tagged_before_data_transferred());
13711 std::unique_ptr<QuicChromiumClientSession::Handle> stream1 =
13712 request1.ReleaseSessionHandle();
13713 EXPECT_TRUE(stream1);
13714 EXPECT_TRUE(stream1->IsConnected());
13715
13716 // Request a stream with |tag1| and verify underlying session is reused.
13717 QuicStreamRequest request2(factory_.get());
13718 rv = request2.Request(
13719 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY, tag1,
13720 NetworkIsolationKey(), false /* disable_secure_dns */,
13721 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
13722 failed_on_default_network_callback_, callback_.callback());
13723 EXPECT_THAT(callback_.GetResult(rv), IsOk());
13724 std::unique_ptr<QuicChromiumClientSession::Handle> stream2 =
13725 request2.ReleaseSessionHandle();
13726 EXPECT_TRUE(stream2);
13727 EXPECT_TRUE(stream2->IsConnected());
13728 EXPECT_TRUE(stream2->SharesSameSession(*stream1));
13729
13730 // Request a stream with |tag2| and verify a new session is created.
13731 QuicStreamRequest request3(factory_.get());
13732 rv = request3.Request(
13733 host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY, tag2,
13734 NetworkIsolationKey(), false /* disable_secure_dns */,
13735 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
13736 failed_on_default_network_callback_, callback_.callback());
13737 EXPECT_THAT(callback_.GetResult(rv), IsOk());
13738 EXPECT_EQ(socket_factory->GetLastProducedUDPSocket()->tag(), tag2);
13739 EXPECT_TRUE(socket_factory->GetLastProducedUDPSocket()
13740 ->tagged_before_data_transferred());
13741 std::unique_ptr<QuicChromiumClientSession::Handle> stream3 =
13742 request3.ReleaseSessionHandle();
13743 EXPECT_TRUE(stream3);
13744 EXPECT_TRUE(stream3->IsConnected());
13745 #if defined(OS_ANDROID)
13746 EXPECT_FALSE(stream3->SharesSameSession(*stream1));
13747 #else
13748 // Same tag should reuse session.
13749 EXPECT_TRUE(stream3->SharesSameSession(*stream1));
13750 #endif
13751 }
13752
13753 } // namespace test
13754 } // namespace net
13755