OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/quic/chromium/quic_stream_factory.h" | 5 #include "net/quic/chromium/quic_stream_factory.h" |
6 | 6 |
7 #include <memory> | 7 #include <memory> |
8 #include <ostream> | 8 #include <ostream> |
9 #include <utility> | 9 #include <utility> |
10 | 10 |
(...skipping 83 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
94 const int kDefaultServerPort = 443; | 94 const int kDefaultServerPort = 443; |
95 const char kDefaultUrl[] = "https://www.example.org/"; | 95 const char kDefaultUrl[] = "https://www.example.org/"; |
96 const char kServer2Url[] = "https://mail.example.org/"; | 96 const char kServer2Url[] = "https://mail.example.org/"; |
97 const char kServer3Url[] = "https://docs.example.org/"; | 97 const char kServer3Url[] = "https://docs.example.org/"; |
98 const char kServer4Url[] = "https://images.example.org/"; | 98 const char kServer4Url[] = "https://images.example.org/"; |
99 | 99 |
100 // Run QuicStreamFactoryTest instances with all value combinations of version | 100 // Run QuicStreamFactoryTest instances with all value combinations of version |
101 // and enable_connection_racting. | 101 // and enable_connection_racting. |
102 struct TestParams { | 102 struct TestParams { |
103 friend std::ostream& operator<<(std::ostream& os, const TestParams& p) { | 103 friend std::ostream& operator<<(std::ostream& os, const TestParams& p) { |
104 os << "{ version: " << QuicVersionToString(p.version) << " }"; | 104 os << "{ version: " << QuicVersionToString(p.version) |
| 105 << ", enable_connection_racing: " |
| 106 << (p.enable_connection_racing ? "true" : "false") << " }"; |
105 return os; | 107 return os; |
106 } | 108 } |
107 | 109 |
108 QuicVersion version; | 110 QuicVersion version; |
| 111 bool enable_connection_racing; |
109 }; | 112 }; |
110 | 113 |
111 std::vector<TestParams> GetTestParams() { | 114 std::vector<TestParams> GetTestParams() { |
112 std::vector<TestParams> params; | 115 std::vector<TestParams> params; |
113 QuicVersionVector all_supported_versions = AllSupportedVersions(); | 116 QuicVersionVector all_supported_versions = AllSupportedVersions(); |
114 for (const auto& version : all_supported_versions) | 117 for (const QuicVersion version : all_supported_versions) { |
115 params.push_back(TestParams{version}); | 118 params.push_back(TestParams{version, false}); |
| 119 params.push_back(TestParams{version, true}); |
| 120 } |
116 return params; | 121 return params; |
117 } | 122 } |
118 | 123 |
119 // Run QuicStreamFactoryWithDestinationTest instances with all value | 124 // Run QuicStreamFactoryWithDestinationTest instances with all value |
120 // combinations of version, enable_connection_racting, and destination_type. | 125 // combinations of version, enable_connection_racting, and destination_type. |
121 struct PoolingTestParams { | 126 struct PoolingTestParams { |
122 friend std::ostream& operator<<(std::ostream& os, | 127 friend std::ostream& operator<<(std::ostream& os, |
123 const PoolingTestParams& p) { | 128 const PoolingTestParams& p) { |
124 os << "{ version: " << QuicVersionToString(p.version) | 129 os << "{ version: " << QuicVersionToString(p.version) |
| 130 << ", enable_connection_racing: " |
| 131 << (p.enable_connection_racing ? "true" : "false") |
125 << ", destination_type: "; | 132 << ", destination_type: "; |
126 switch (p.destination_type) { | 133 switch (p.destination_type) { |
127 case SAME_AS_FIRST: | 134 case SAME_AS_FIRST: |
128 os << "SAME_AS_FIRST"; | 135 os << "SAME_AS_FIRST"; |
129 break; | 136 break; |
130 case SAME_AS_SECOND: | 137 case SAME_AS_SECOND: |
131 os << "SAME_AS_SECOND"; | 138 os << "SAME_AS_SECOND"; |
132 break; | 139 break; |
133 case DIFFERENT: | 140 case DIFFERENT: |
134 os << "DIFFERENT"; | 141 os << "DIFFERENT"; |
135 break; | 142 break; |
136 } | 143 } |
137 os << " }"; | 144 os << " }"; |
138 return os; | 145 return os; |
139 } | 146 } |
140 | 147 |
141 QuicVersion version; | 148 QuicVersion version; |
| 149 bool enable_connection_racing; |
142 DestinationType destination_type; | 150 DestinationType destination_type; |
143 }; | 151 }; |
144 | 152 |
145 std::vector<PoolingTestParams> GetPoolingTestParams() { | 153 std::vector<PoolingTestParams> GetPoolingTestParams() { |
146 std::vector<PoolingTestParams> params; | 154 std::vector<PoolingTestParams> params; |
147 QuicVersionVector all_supported_versions = AllSupportedVersions(); | 155 QuicVersionVector all_supported_versions = AllSupportedVersions(); |
148 for (const QuicVersion version : all_supported_versions) { | 156 for (const QuicVersion version : all_supported_versions) { |
149 params.push_back(PoolingTestParams{version, SAME_AS_FIRST}); | 157 params.push_back(PoolingTestParams{version, false, SAME_AS_FIRST}); |
150 params.push_back(PoolingTestParams{version, SAME_AS_SECOND}); | 158 params.push_back(PoolingTestParams{version, false, SAME_AS_SECOND}); |
151 params.push_back(PoolingTestParams{version, DIFFERENT}); | 159 params.push_back(PoolingTestParams{version, false, DIFFERENT}); |
| 160 params.push_back(PoolingTestParams{version, true, SAME_AS_FIRST}); |
| 161 params.push_back(PoolingTestParams{version, true, SAME_AS_SECOND}); |
| 162 params.push_back(PoolingTestParams{version, true, DIFFERENT}); |
152 } | 163 } |
153 return params; | 164 return params; |
154 } | 165 } |
155 | 166 |
156 } // namespace | 167 } // namespace |
157 | 168 |
158 class QuicHttpStreamPeer { | 169 class QuicHttpStreamPeer { |
159 public: | 170 public: |
160 static QuicChromiumClientSession* GetSession(QuicHttpStream* stream) { | 171 static QuicChromiumClientSession* GetSession(QuicHttpStream* stream) { |
161 return stream->session_.get(); | 172 return stream->session_.get(); |
162 } | 173 } |
163 }; | 174 }; |
164 | 175 |
| 176 class MockQuicServerInfo : public QuicServerInfo { |
| 177 public: |
| 178 explicit MockQuicServerInfo(const QuicServerId& server_id) |
| 179 : QuicServerInfo(server_id) {} |
| 180 ~MockQuicServerInfo() override {} |
| 181 |
| 182 void Start() override {} |
| 183 |
| 184 int WaitForDataReady(const CompletionCallback& callback) override { |
| 185 return ERR_IO_PENDING; |
| 186 } |
| 187 |
| 188 void ResetWaitForDataReadyCallback() override {} |
| 189 |
| 190 void CancelWaitForDataReadyCallback() override {} |
| 191 |
| 192 bool IsDataReady() override { return false; } |
| 193 |
| 194 bool IsReadyToPersist() override { return false; } |
| 195 |
| 196 void Persist() override {} |
| 197 |
| 198 void OnExternalCacheHit() override {} |
| 199 |
| 200 size_t EstimateMemoryUsage() const override { |
| 201 NOTREACHED(); |
| 202 return 0; |
| 203 } |
| 204 }; |
| 205 |
| 206 class MockQuicServerInfoFactory : public QuicServerInfoFactory { |
| 207 public: |
| 208 MockQuicServerInfoFactory() {} |
| 209 ~MockQuicServerInfoFactory() override {} |
| 210 |
| 211 std::unique_ptr<QuicServerInfo> GetForServer( |
| 212 const QuicServerId& server_id) override { |
| 213 return base::MakeUnique<MockQuicServerInfo>(server_id); |
| 214 } |
| 215 }; |
| 216 |
165 class QuicStreamFactoryTestBase { | 217 class QuicStreamFactoryTestBase { |
166 protected: | 218 protected: |
167 explicit QuicStreamFactoryTestBase(QuicVersion version) | 219 QuicStreamFactoryTestBase(QuicVersion version, bool enable_connection_racing) |
168 : ssl_config_service_(new MockSSLConfigService), | 220 : ssl_config_service_(new MockSSLConfigService), |
169 random_generator_(0), | 221 random_generator_(0), |
170 runner_(new TestTaskRunner(&clock_)), | 222 runner_(new TestTaskRunner(&clock_)), |
171 version_(version), | 223 version_(version), |
172 client_maker_(version_, | 224 client_maker_(version_, |
173 0, | 225 0, |
174 &clock_, | 226 &clock_, |
175 kDefaultServerHostName, | 227 kDefaultServerHostName, |
176 Perspective::IS_CLIENT), | 228 Perspective::IS_CLIENT), |
177 server_maker_(version_, | 229 server_maker_(version_, |
178 0, | 230 0, |
179 &clock_, | 231 &clock_, |
180 kDefaultServerHostName, | 232 kDefaultServerHostName, |
181 Perspective::IS_SERVER), | 233 Perspective::IS_SERVER), |
182 cert_verifier_(CertVerifier::CreateDefault()), | 234 cert_verifier_(CertVerifier::CreateDefault()), |
183 channel_id_service_( | 235 channel_id_service_( |
184 new ChannelIDService(new DefaultChannelIDStore(nullptr))), | 236 new ChannelIDService(new DefaultChannelIDStore(nullptr))), |
185 cert_transparency_verifier_(new MultiLogCTVerifier()), | 237 cert_transparency_verifier_(new MultiLogCTVerifier()), |
186 scoped_mock_network_change_notifier_(nullptr), | 238 scoped_mock_network_change_notifier_(nullptr), |
187 factory_(nullptr), | 239 factory_(nullptr), |
188 host_port_pair_(kDefaultServerHostName, kDefaultServerPort), | 240 host_port_pair_(kDefaultServerHostName, kDefaultServerPort), |
189 url_(kDefaultUrl), | 241 url_(kDefaultUrl), |
190 url2_(kServer2Url), | 242 url2_(kServer2Url), |
191 url3_(kServer3Url), | 243 url3_(kServer3Url), |
192 url4_(kServer4Url), | 244 url4_(kServer4Url), |
193 privacy_mode_(PRIVACY_MODE_DISABLED), | 245 privacy_mode_(PRIVACY_MODE_DISABLED), |
| 246 load_server_info_timeout_srtt_multiplier_(0.0f), |
| 247 enable_connection_racing_(enable_connection_racing), |
194 enable_non_blocking_io_(true), | 248 enable_non_blocking_io_(true), |
| 249 disable_disk_cache_(false), |
195 close_sessions_on_ip_change_(false), | 250 close_sessions_on_ip_change_(false), |
196 idle_connection_timeout_seconds_(kIdleConnectionTimeoutSeconds), | 251 idle_connection_timeout_seconds_(kIdleConnectionTimeoutSeconds), |
197 reduced_ping_timeout_seconds_(kPingTimeoutSecs), | 252 reduced_ping_timeout_seconds_(kPingTimeoutSecs), |
198 packet_reader_yield_after_duration_milliseconds_( | 253 packet_reader_yield_after_duration_milliseconds_( |
199 kQuicYieldAfterDurationMilliseconds), | 254 kQuicYieldAfterDurationMilliseconds), |
200 migrate_sessions_on_network_change_(false), | 255 migrate_sessions_on_network_change_(false), |
201 migrate_sessions_early_(false), | 256 migrate_sessions_early_(false), |
202 allow_server_migration_(false), | 257 allow_server_migration_(false), |
203 force_hol_blocking_(false), | 258 force_hol_blocking_(false), |
204 race_cert_verification_(false), | 259 race_cert_verification_(false), |
205 estimate_initial_rtt_(false) { | 260 estimate_initial_rtt_(false) { |
206 clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1)); | 261 clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1)); |
207 } | 262 } |
208 | 263 |
209 void Initialize() { | 264 void Initialize() { |
210 DCHECK(!factory_); | 265 DCHECK(!factory_); |
211 factory_.reset(new QuicStreamFactory( | 266 factory_.reset(new QuicStreamFactory( |
212 net_log_.net_log(), &host_resolver_, ssl_config_service_.get(), | 267 net_log_.net_log(), &host_resolver_, ssl_config_service_.get(), |
213 &socket_factory_, &http_server_properties_, &test_proxy_delegate_, | 268 &socket_factory_, &http_server_properties_, &test_proxy_delegate_, |
214 cert_verifier_.get(), &ct_policy_enforcer_, channel_id_service_.get(), | 269 cert_verifier_.get(), &ct_policy_enforcer_, channel_id_service_.get(), |
215 &transport_security_state_, cert_transparency_verifier_.get(), | 270 &transport_security_state_, cert_transparency_verifier_.get(), |
216 /*SocketPerformanceWatcherFactory*/ nullptr, | 271 /*SocketPerformanceWatcherFactory*/ nullptr, |
217 &crypto_client_stream_factory_, &random_generator_, &clock_, | 272 &crypto_client_stream_factory_, &random_generator_, &clock_, |
218 kDefaultMaxPacketSize, string(), SupportedVersions(version_), | 273 kDefaultMaxPacketSize, string(), SupportedVersions(version_), |
219 enable_non_blocking_io_, store_server_configs_in_properties_, | 274 load_server_info_timeout_srtt_multiplier_, enable_connection_racing_, |
| 275 enable_non_blocking_io_, disable_disk_cache_, |
| 276 /*max_server_configs_stored_in_properties*/ 0, |
220 close_sessions_on_ip_change_, | 277 close_sessions_on_ip_change_, |
221 /*mark_quic_broken_when_network_blackholes*/ false, | 278 /*mark_quic_broken_when_network_blackholes*/ false, |
222 idle_connection_timeout_seconds_, reduced_ping_timeout_seconds_, | 279 idle_connection_timeout_seconds_, reduced_ping_timeout_seconds_, |
223 packet_reader_yield_after_duration_milliseconds_, | 280 packet_reader_yield_after_duration_milliseconds_, |
224 migrate_sessions_on_network_change_, migrate_sessions_early_, | 281 migrate_sessions_on_network_change_, migrate_sessions_early_, |
225 allow_server_migration_, force_hol_blocking_, race_cert_verification_, | 282 allow_server_migration_, force_hol_blocking_, race_cert_verification_, |
226 /*do_not_fragment*/ true, estimate_initial_rtt_, QuicTagVector(), | 283 /*do_not_fragment*/ true, estimate_initial_rtt_, QuicTagVector(), |
227 /*enable_token_binding*/ false)); | 284 /*enable_token_binding*/ false)); |
228 factory_->set_require_confirmation(false); | 285 factory_->set_require_confirmation(false); |
| 286 EXPECT_FALSE(factory_->has_quic_server_info_factory()); |
| 287 factory_->set_quic_server_info_factory(new MockQuicServerInfoFactory()); |
| 288 EXPECT_TRUE(factory_->has_quic_server_info_factory()); |
229 } | 289 } |
230 | 290 |
231 void InitializeConnectionMigrationTest( | 291 void InitializeConnectionMigrationTest( |
232 NetworkChangeNotifier::NetworkList connected_networks) { | 292 NetworkChangeNotifier::NetworkList connected_networks) { |
233 scoped_mock_network_change_notifier_.reset( | 293 scoped_mock_network_change_notifier_.reset( |
234 new ScopedMockNetworkChangeNotifier()); | 294 new ScopedMockNetworkChangeNotifier()); |
235 MockNetworkChangeNotifier* mock_ncn = | 295 MockNetworkChangeNotifier* mock_ncn = |
236 scoped_mock_network_change_notifier_->mock_network_change_notifier(); | 296 scoped_mock_network_change_notifier_->mock_network_change_notifier(); |
237 mock_ncn->ForceNetworkHandlesSupported(); | 297 mock_ncn->ForceNetworkHandlesSupported(); |
238 mock_ncn->SetConnectedNetworksList(connected_networks); | 298 mock_ncn->SetConnectedNetworksList(connected_networks); |
(...skipping 235 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
474 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); | 534 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); |
475 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); | 535 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); |
476 } | 536 } |
477 | 537 |
478 // Verifies that the QUIC stream factory is initialized correctly. | 538 // Verifies that the QUIC stream factory is initialized correctly. |
479 // If |proxy_delegate_provides_quic_supported_proxy| is true, then | 539 // If |proxy_delegate_provides_quic_supported_proxy| is true, then |
480 // ProxyDelegate provides a proxy that supports QUIC at startup. Otherwise, | 540 // ProxyDelegate provides a proxy that supports QUIC at startup. Otherwise, |
481 // a non proxy server that support alternative services is added to the | 541 // a non proxy server that support alternative services is added to the |
482 // HttpServerProperties map. | 542 // HttpServerProperties map. |
483 void VerifyInitialization(bool proxy_delegate_provides_quic_supported_proxy) { | 543 void VerifyInitialization(bool proxy_delegate_provides_quic_supported_proxy) { |
484 store_server_configs_in_properties_ = true; | |
485 idle_connection_timeout_seconds_ = 500; | 544 idle_connection_timeout_seconds_ = 500; |
486 Initialize(); | 545 Initialize(); |
487 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 546 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
488 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 547 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
489 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | |
490 crypto_client_stream_factory_.set_handshake_mode( | |
491 MockCryptoClientStream::ZERO_RTT); | |
492 const QuicConfig* config = QuicStreamFactoryPeer::GetConfig(factory_.get()); | 548 const QuicConfig* config = QuicStreamFactoryPeer::GetConfig(factory_.get()); |
493 EXPECT_EQ(500, config->IdleNetworkTimeout().ToSeconds()); | 549 EXPECT_EQ(500, config->IdleNetworkTimeout().ToSeconds()); |
494 | 550 |
495 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), runner_.get()); | 551 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), runner_.get()); |
496 | 552 |
497 const AlternativeService alternative_service1( | 553 const AlternativeService alternative_service1( |
498 kProtoQUIC, host_port_pair_.host(), host_port_pair_.port()); | 554 kProtoQUIC, host_port_pair_.host(), host_port_pair_.port()); |
499 AlternativeServiceInfoVector alternative_service_info_vector; | 555 AlternativeServiceInfoVector alternative_service_info_vector; |
500 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); | 556 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
501 alternative_service_info_vector.push_back( | 557 alternative_service_info_vector.push_back( |
(...skipping 19 matching lines...) Expand all Loading... |
521 net::ProxyServer::SCHEME_QUIC, | 577 net::ProxyServer::SCHEME_QUIC, |
522 net::HostPortPair(kServer2HostName, kDefaultServerPort))); | 578 net::HostPortPair(kServer2HostName, kDefaultServerPort))); |
523 // Verify that the properties of only the first QUIC server are stored in | 579 // Verify that the properties of only the first QUIC server are stored in |
524 // the HTTP properties map. | 580 // the HTTP properties map. |
525 EXPECT_EQ(1U, http_server_properties_.alternative_service_map().size()); | 581 EXPECT_EQ(1U, http_server_properties_.alternative_service_map().size()); |
526 } | 582 } |
527 | 583 |
528 http_server_properties_.SetMaxServerConfigsStoredInProperties( | 584 http_server_properties_.SetMaxServerConfigsStoredInProperties( |
529 kMaxQuicServersToPersist); | 585 kMaxQuicServersToPersist); |
530 | 586 |
531 QuicServerId quic_server_id(kDefaultServerHostName, 443, | 587 QuicServerId quic_server_id(kDefaultServerHostName, 80, |
532 PRIVACY_MODE_DISABLED); | 588 PRIVACY_MODE_DISABLED); |
533 std::unique_ptr<QuicServerInfo> quic_server_info = | 589 QuicServerInfoFactory* quic_server_info_factory = |
534 base::MakeUnique<PropertiesBasedQuicServerInfo>( | 590 new PropertiesBasedQuicServerInfoFactory(&http_server_properties_); |
535 quic_server_id, &http_server_properties_); | 591 factory_->set_quic_server_info_factory(quic_server_info_factory); |
| 592 |
| 593 std::unique_ptr<QuicServerInfo> quic_server_info( |
| 594 quic_server_info_factory->GetForServer(quic_server_id)); |
536 | 595 |
537 // Update quic_server_info's server_config and persist it. | 596 // Update quic_server_info's server_config and persist it. |
538 QuicServerInfo::State* state = quic_server_info->mutable_state(); | 597 QuicServerInfo::State* state = quic_server_info->mutable_state(); |
539 // Minimum SCFG that passes config validation checks. | 598 // Minimum SCFG that passes config validation checks. |
540 const char scfg[] = {// SCFG | 599 const char scfg[] = {// SCFG |
541 0x53, 0x43, 0x46, 0x47, | 600 0x53, 0x43, 0x46, 0x47, |
542 // num entries | 601 // num entries |
543 0x01, 0x00, | 602 0x01, 0x00, |
544 // padding | 603 // padding |
545 0x00, 0x00, | 604 0x00, 0x00, |
(...skipping 15 matching lines...) Expand all Loading... |
561 certs.push_back(test_cert); | 620 certs.push_back(test_cert); |
562 state->server_config = server_config; | 621 state->server_config = server_config; |
563 state->source_address_token = source_address_token; | 622 state->source_address_token = source_address_token; |
564 state->cert_sct = cert_sct; | 623 state->cert_sct = cert_sct; |
565 state->chlo_hash = chlo_hash; | 624 state->chlo_hash = chlo_hash; |
566 state->server_config_sig = signature; | 625 state->server_config_sig = signature; |
567 state->certs = certs; | 626 state->certs = certs; |
568 | 627 |
569 quic_server_info->Persist(); | 628 quic_server_info->Persist(); |
570 | 629 |
571 QuicServerId quic_server_id2(kServer2HostName, 443, PRIVACY_MODE_DISABLED); | 630 QuicServerId quic_server_id2(kServer2HostName, 80, PRIVACY_MODE_DISABLED); |
572 std::unique_ptr<QuicServerInfo> quic_server_info2 = | 631 std::unique_ptr<QuicServerInfo> quic_server_info2( |
573 base::MakeUnique<PropertiesBasedQuicServerInfo>( | 632 quic_server_info_factory->GetForServer(quic_server_id2)); |
574 quic_server_id2, &http_server_properties_); | 633 |
575 // Update quic_server_info2's server_config and persist it. | 634 // Update quic_server_info2's server_config and persist it. |
576 QuicServerInfo::State* state2 = quic_server_info2->mutable_state(); | 635 QuicServerInfo::State* state2 = quic_server_info2->mutable_state(); |
577 | 636 |
578 // Minimum SCFG that passes config validation checks. | 637 // Minimum SCFG that passes config validation checks. |
579 const char scfg2[] = {// SCFG | 638 const char scfg2[] = {// SCFG |
580 0x53, 0x43, 0x46, 0x47, | 639 0x53, 0x43, 0x46, 0x47, |
581 // num entries | 640 // num entries |
582 0x01, 0x00, | 641 0x01, 0x00, |
583 // padding | 642 // padding |
584 0x00, 0x00, | 643 0x00, 0x00, |
(...skipping 16 matching lines...) Expand all Loading... |
601 certs2.push_back(test_cert2); | 660 certs2.push_back(test_cert2); |
602 state2->server_config = server_config2; | 661 state2->server_config = server_config2; |
603 state2->source_address_token = source_address_token2; | 662 state2->source_address_token = source_address_token2; |
604 state2->cert_sct = cert_sct2; | 663 state2->cert_sct = cert_sct2; |
605 state2->chlo_hash = chlo_hash2; | 664 state2->chlo_hash = chlo_hash2; |
606 state2->server_config_sig = signature2; | 665 state2->server_config_sig = signature2; |
607 state2->certs = certs2; | 666 state2->certs = certs2; |
608 | 667 |
609 quic_server_info2->Persist(); | 668 quic_server_info2->Persist(); |
610 | 669 |
| 670 QuicStreamFactoryPeer::MaybeInitialize(factory_.get()); |
| 671 EXPECT_TRUE(QuicStreamFactoryPeer::HasInitializedData(factory_.get())); |
| 672 |
611 // Verify the MRU order is maintained. | 673 // Verify the MRU order is maintained. |
612 const QuicServerInfoMap& quic_server_info_map = | 674 const QuicServerInfoMap& quic_server_info_map = |
613 http_server_properties_.quic_server_info_map(); | 675 http_server_properties_.quic_server_info_map(); |
614 EXPECT_EQ(2u, quic_server_info_map.size()); | 676 EXPECT_EQ(2u, quic_server_info_map.size()); |
615 QuicServerInfoMap::const_iterator quic_server_info_map_it = | 677 QuicServerInfoMap::const_iterator quic_server_info_map_it = |
616 quic_server_info_map.begin(); | 678 quic_server_info_map.begin(); |
617 EXPECT_EQ(quic_server_info_map_it->first, quic_server_id2); | 679 EXPECT_EQ(quic_server_info_map_it->first, quic_server_id2); |
618 ++quic_server_info_map_it; | 680 ++quic_server_info_map_it; |
619 EXPECT_EQ(quic_server_info_map_it->first, quic_server_id); | 681 EXPECT_EQ(quic_server_info_map_it->first, quic_server_id); |
620 | 682 |
621 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), | 683 EXPECT_TRUE(QuicStreamFactoryPeer::SupportsQuicAtStartUp(factory_.get(), |
622 "192.168.0.1", ""); | 684 host_port_pair_)); |
623 | |
624 // Create a session and verify that the cached state is loaded. | |
625 MockQuicData socket_data; | |
626 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | |
627 socket_data.AddSocketDataToFactory(&socket_factory_); | |
628 | |
629 QuicStreamRequest request(factory_.get(), &http_server_properties_); | |
630 EXPECT_EQ(ERR_IO_PENDING, | |
631 request.Request(quic_server_id.host_port_pair(), privacy_mode_, | |
632 /*cert_verify_flags=*/0, url_, "GET", net_log_, | |
633 callback_.callback())); | |
634 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | |
635 | |
636 EXPECT_FALSE(QuicStreamFactoryPeer::CryptoConfigCacheIsEmpty( | 685 EXPECT_FALSE(QuicStreamFactoryPeer::CryptoConfigCacheIsEmpty( |
637 factory_.get(), quic_server_id)); | 686 factory_.get(), quic_server_id)); |
638 QuicCryptoClientConfig* crypto_config = | 687 QuicCryptoClientConfig* crypto_config = |
639 QuicStreamFactoryPeer::GetCryptoConfig(factory_.get()); | 688 QuicStreamFactoryPeer::GetCryptoConfig(factory_.get()); |
640 QuicCryptoClientConfig::CachedState* cached = | 689 QuicCryptoClientConfig::CachedState* cached = |
641 crypto_config->LookupOrCreate(quic_server_id); | 690 crypto_config->LookupOrCreate(quic_server_id); |
642 EXPECT_FALSE(cached->server_config().empty()); | 691 EXPECT_FALSE(cached->server_config().empty()); |
643 EXPECT_TRUE(cached->GetServerConfig()); | 692 EXPECT_TRUE(cached->GetServerConfig()); |
644 EXPECT_EQ(server_config, cached->server_config()); | 693 EXPECT_EQ(server_config, cached->server_config()); |
645 EXPECT_EQ(source_address_token, cached->source_address_token()); | 694 EXPECT_EQ(source_address_token, cached->source_address_token()); |
646 EXPECT_EQ(cert_sct, cached->cert_sct()); | 695 EXPECT_EQ(cert_sct, cached->cert_sct()); |
647 EXPECT_EQ(chlo_hash, cached->chlo_hash()); | 696 EXPECT_EQ(chlo_hash, cached->chlo_hash()); |
648 EXPECT_EQ(signature, cached->signature()); | 697 EXPECT_EQ(signature, cached->signature()); |
649 ASSERT_EQ(1U, cached->certs().size()); | 698 ASSERT_EQ(1U, cached->certs().size()); |
650 EXPECT_EQ(test_cert, cached->certs()[0]); | 699 EXPECT_EQ(test_cert, cached->certs()[0]); |
651 | 700 |
652 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 701 EXPECT_TRUE(QuicStreamFactoryPeer::SupportsQuicAtStartUp(factory_.get(), |
653 | 702 host_port_pair2)); |
654 // Create a session and verify that the cached state is loaded. | |
655 MockQuicData socket_data2; | |
656 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | |
657 socket_data2.AddSocketDataToFactory(&socket_factory_); | |
658 | |
659 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), | |
660 "192.168.0.2", ""); | |
661 | |
662 QuicStreamRequest request2(factory_.get(), &http_server_properties_); | |
663 EXPECT_EQ(ERR_IO_PENDING, | |
664 request2.Request(quic_server_id2.host_port_pair(), privacy_mode_, | |
665 /*cert_verify_flags=*/0, | |
666 GURL("https://mail.example.org/"), "GET", | |
667 net_log_, callback_.callback())); | |
668 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | |
669 | |
670 EXPECT_FALSE(QuicStreamFactoryPeer::CryptoConfigCacheIsEmpty( | 703 EXPECT_FALSE(QuicStreamFactoryPeer::CryptoConfigCacheIsEmpty( |
671 factory_.get(), quic_server_id2)); | 704 factory_.get(), quic_server_id2)); |
672 QuicCryptoClientConfig::CachedState* cached2 = | 705 QuicCryptoClientConfig::CachedState* cached2 = |
673 crypto_config->LookupOrCreate(quic_server_id2); | 706 crypto_config->LookupOrCreate(quic_server_id2); |
674 EXPECT_FALSE(cached2->server_config().empty()); | 707 EXPECT_FALSE(cached2->server_config().empty()); |
675 EXPECT_TRUE(cached2->GetServerConfig()); | 708 EXPECT_TRUE(cached2->GetServerConfig()); |
676 EXPECT_EQ(server_config2, cached2->server_config()); | 709 EXPECT_EQ(server_config2, cached2->server_config()); |
677 EXPECT_EQ(source_address_token2, cached2->source_address_token()); | 710 EXPECT_EQ(source_address_token2, cached2->source_address_token()); |
678 EXPECT_EQ(cert_sct2, cached2->cert_sct()); | 711 EXPECT_EQ(cert_sct2, cached2->cert_sct()); |
679 EXPECT_EQ(chlo_hash2, cached2->chlo_hash()); | 712 EXPECT_EQ(chlo_hash2, cached2->chlo_hash()); |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
729 GURL url_; | 762 GURL url_; |
730 GURL url2_; | 763 GURL url2_; |
731 GURL url3_; | 764 GURL url3_; |
732 GURL url4_; | 765 GURL url4_; |
733 | 766 |
734 PrivacyMode privacy_mode_; | 767 PrivacyMode privacy_mode_; |
735 NetLogWithSource net_log_; | 768 NetLogWithSource net_log_; |
736 TestCompletionCallback callback_; | 769 TestCompletionCallback callback_; |
737 | 770 |
738 // Variables to configure QuicStreamFactory. | 771 // Variables to configure QuicStreamFactory. |
| 772 double load_server_info_timeout_srtt_multiplier_; |
| 773 bool enable_connection_racing_; |
739 bool enable_non_blocking_io_; | 774 bool enable_non_blocking_io_; |
740 bool store_server_configs_in_properties_; | 775 bool disable_disk_cache_; |
741 bool close_sessions_on_ip_change_; | 776 bool close_sessions_on_ip_change_; |
742 int idle_connection_timeout_seconds_; | 777 int idle_connection_timeout_seconds_; |
743 int reduced_ping_timeout_seconds_; | 778 int reduced_ping_timeout_seconds_; |
744 int packet_reader_yield_after_duration_milliseconds_; | 779 int packet_reader_yield_after_duration_milliseconds_; |
745 bool migrate_sessions_on_network_change_; | 780 bool migrate_sessions_on_network_change_; |
746 bool migrate_sessions_early_; | 781 bool migrate_sessions_early_; |
747 bool allow_server_migration_; | 782 bool allow_server_migration_; |
748 bool force_hol_blocking_; | 783 bool force_hol_blocking_; |
749 bool race_cert_verification_; | 784 bool race_cert_verification_; |
750 bool estimate_initial_rtt_; | 785 bool estimate_initial_rtt_; |
751 }; | 786 }; |
752 | 787 |
753 class QuicStreamFactoryTest : public QuicStreamFactoryTestBase, | 788 class QuicStreamFactoryTest : public QuicStreamFactoryTestBase, |
754 public ::testing::TestWithParam<TestParams> { | 789 public ::testing::TestWithParam<TestParams> { |
755 protected: | 790 protected: |
756 QuicStreamFactoryTest() : QuicStreamFactoryTestBase(GetParam().version) {} | 791 QuicStreamFactoryTest() |
| 792 : QuicStreamFactoryTestBase(GetParam().version, |
| 793 GetParam().enable_connection_racing) {} |
757 }; | 794 }; |
758 | 795 |
759 INSTANTIATE_TEST_CASE_P(Version, | 796 INSTANTIATE_TEST_CASE_P(Version, |
760 QuicStreamFactoryTest, | 797 QuicStreamFactoryTest, |
761 ::testing::ValuesIn(GetTestParams())); | 798 ::testing::ValuesIn(GetTestParams())); |
762 | 799 |
763 TEST_P(QuicStreamFactoryTest, Create) { | 800 TEST_P(QuicStreamFactoryTest, Create) { |
764 Initialize(); | 801 Initialize(); |
765 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 802 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
766 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 803 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
(...skipping 3606 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4373 HostPortPair host_port_pair2(r4_host_name, 80); | 4410 HostPortPair host_port_pair2(r4_host_name, 80); |
4374 QuicServerId server_id2(host_port_pair2, privacy_mode_); | 4411 QuicServerId server_id2(host_port_pair2, privacy_mode_); |
4375 QuicCryptoClientConfig::CachedState* cached2 = | 4412 QuicCryptoClientConfig::CachedState* cached2 = |
4376 crypto_config->LookupOrCreate(server_id2); | 4413 crypto_config->LookupOrCreate(server_id2); |
4377 EXPECT_NE(cached1->source_address_token(), cached2->source_address_token()); | 4414 EXPECT_NE(cached1->source_address_token(), cached2->source_address_token()); |
4378 EXPECT_TRUE(cached2->source_address_token().empty()); | 4415 EXPECT_TRUE(cached2->source_address_token().empty()); |
4379 EXPECT_FALSE(cached2->proof_valid()); | 4416 EXPECT_FALSE(cached2->proof_valid()); |
4380 } | 4417 } |
4381 } | 4418 } |
4382 | 4419 |
4383 TEST_P(QuicStreamFactoryTest, EnableNotLoadFromDiskCache) { | 4420 TEST_P(QuicStreamFactoryTest, RacingConnections) { |
| 4421 disable_disk_cache_ = false; |
4384 Initialize(); | 4422 Initialize(); |
4385 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 4423 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
4386 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 4424 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
4387 | 4425 |
| 4426 if (!enable_connection_racing_) |
| 4427 return; |
| 4428 |
4388 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), runner_.get()); | 4429 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), runner_.get()); |
4389 | 4430 |
4390 MockQuicData socket_data; | 4431 MockQuicData socket_data; |
4391 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 4432 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
4392 socket_data.AddSocketDataToFactory(&socket_factory_); | 4433 socket_data.AddSocketDataToFactory(&socket_factory_); |
4393 | 4434 |
| 4435 MockQuicData socket_data2; |
| 4436 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
| 4437 socket_data2.AddSocketDataToFactory(&socket_factory_); |
| 4438 |
| 4439 const AlternativeService alternative_service1( |
| 4440 kProtoQUIC, host_port_pair_.host(), host_port_pair_.port()); |
| 4441 AlternativeServiceInfoVector alternative_service_info_vector; |
| 4442 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
| 4443 alternative_service_info_vector.push_back( |
| 4444 AlternativeServiceInfo(alternative_service1, expiration)); |
| 4445 |
| 4446 http_server_properties_.SetAlternativeServices( |
| 4447 url::SchemeHostPort(url_), alternative_service_info_vector); |
| 4448 |
4394 crypto_client_stream_factory_.set_handshake_mode( | 4449 crypto_client_stream_factory_.set_handshake_mode( |
4395 MockCryptoClientStream::ZERO_RTT); | 4450 MockCryptoClientStream::ZERO_RTT); |
4396 host_resolver_.set_synchronous_mode(true); | 4451 host_resolver_.set_synchronous_mode(true); |
4397 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), | 4452 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), |
4398 "192.168.0.1", ""); | 4453 "192.168.0.1", ""); |
4399 | 4454 |
4400 QuicStreamRequest request(factory_.get(), &http_server_properties_); | 4455 QuicStreamRequest request(factory_.get(), &http_server_properties_); |
| 4456 QuicServerId server_id(host_port_pair_, privacy_mode_); |
| 4457 EXPECT_EQ(ERR_IO_PENDING, |
| 4458 request.Request(host_port_pair_, privacy_mode_, |
| 4459 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
| 4460 callback_.callback())); |
| 4461 EXPECT_EQ(2u, QuicStreamFactoryPeer::GetNumberOfActiveJobs(factory_.get(), |
| 4462 server_id)); |
| 4463 |
| 4464 runner_->RunNextTask(); |
| 4465 |
| 4466 std::unique_ptr<QuicHttpStream> stream = request.CreateStream(); |
| 4467 EXPECT_TRUE(stream.get()); |
| 4468 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
| 4469 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
| 4470 EXPECT_EQ(0u, QuicStreamFactoryPeer::GetNumberOfActiveJobs(factory_.get(), |
| 4471 server_id)); |
| 4472 } |
| 4473 |
| 4474 TEST_P(QuicStreamFactoryTest, EnableNotLoadFromDiskCache) { |
| 4475 disable_disk_cache_ = true; |
| 4476 Initialize(); |
| 4477 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
| 4478 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
| 4479 |
| 4480 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), runner_.get()); |
| 4481 |
| 4482 MockQuicData socket_data; |
| 4483 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
| 4484 socket_data.AddSocketDataToFactory(&socket_factory_); |
| 4485 |
| 4486 crypto_client_stream_factory_.set_handshake_mode( |
| 4487 MockCryptoClientStream::ZERO_RTT); |
| 4488 host_resolver_.set_synchronous_mode(true); |
| 4489 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), |
| 4490 "192.168.0.1", ""); |
| 4491 |
| 4492 QuicStreamRequest request(factory_.get(), &http_server_properties_); |
4401 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_, | 4493 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_, |
4402 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4494 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4403 callback_.callback())); | 4495 callback_.callback())); |
4404 | 4496 |
4405 // If we are waiting for disk cache, we would have posted a task. Verify that | 4497 // If we are waiting for disk cache, we would have posted a task. Verify that |
4406 // the CancelWaitForDataReady task hasn't been posted. | 4498 // the CancelWaitForDataReady task hasn't been posted. |
4407 ASSERT_EQ(0u, runner_->GetPostedTasks().size()); | 4499 ASSERT_EQ(0u, runner_->GetPostedTasks().size()); |
4408 | 4500 |
4409 std::unique_ptr<QuicHttpStream> stream = request.CreateStream(); | 4501 std::unique_ptr<QuicHttpStream> stream = request.CreateStream(); |
4410 EXPECT_TRUE(stream.get()); | 4502 EXPECT_TRUE(stream.get()); |
4411 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 4503 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
4412 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 4504 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
4413 } | 4505 } |
4414 | 4506 |
4415 TEST_P(QuicStreamFactoryTest, ReducePingTimeoutOnConnectionTimeOutOpenStreams) { | 4507 TEST_P(QuicStreamFactoryTest, ReducePingTimeoutOnConnectionTimeOutOpenStreams) { |
4416 reduced_ping_timeout_seconds_ = 10; | 4508 reduced_ping_timeout_seconds_ = 10; |
| 4509 disable_disk_cache_ = true; |
4417 Initialize(); | 4510 Initialize(); |
4418 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 4511 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
4419 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 4512 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
4420 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 4513 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
4421 | 4514 |
4422 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), runner_.get()); | 4515 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), runner_.get()); |
4423 | 4516 |
4424 MockQuicData socket_data; | 4517 MockQuicData socket_data; |
4425 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 4518 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
4426 socket_data.AddWrite( | 4519 socket_data.AddWrite( |
(...skipping 71 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4498 // QuicStreamFactory::OnSessionClosed() runs. | 4591 // QuicStreamFactory::OnSessionClosed() runs. |
4499 base::RunLoop run_loop2; | 4592 base::RunLoop run_loop2; |
4500 run_loop2.RunUntilIdle(); | 4593 run_loop2.RunUntilIdle(); |
4501 | 4594 |
4502 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 4595 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
4503 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 4596 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
4504 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); | 4597 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); |
4505 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); | 4598 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); |
4506 } | 4599 } |
4507 | 4600 |
| 4601 TEST_P(QuicStreamFactoryTest, DelayTcpRace) { |
| 4602 Initialize(); |
| 4603 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
| 4604 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
| 4605 MockQuicData socket_data; |
| 4606 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
| 4607 socket_data.AddWrite( |
| 4608 ConstructSettingsPacket(1, SETTINGS_MAX_HEADER_LIST_SIZE, |
| 4609 kDefaultMaxUncompressedHeaderSize, nullptr)); |
| 4610 socket_data.AddSocketDataToFactory(&socket_factory_); |
| 4611 |
| 4612 ServerNetworkStats stats1; |
| 4613 stats1.srtt = base::TimeDelta::FromMicroseconds(10); |
| 4614 http_server_properties_.SetServerNetworkStats(url::SchemeHostPort(url_), |
| 4615 stats1); |
| 4616 |
| 4617 crypto_client_stream_factory_.set_handshake_mode( |
| 4618 MockCryptoClientStream::COLD_START); |
| 4619 host_resolver_.set_synchronous_mode(true); |
| 4620 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), |
| 4621 "192.168.0.1", ""); |
| 4622 |
| 4623 QuicStreamRequest request(factory_.get(), &http_server_properties_); |
| 4624 EXPECT_EQ(ERR_IO_PENDING, |
| 4625 request.Request(host_port_pair_, privacy_mode_, |
| 4626 /*cert_verify_flags=*/0, url_, "POST", net_log_, |
| 4627 callback_.callback())); |
| 4628 |
| 4629 // Verify delay is one RTT and that server supports QUIC. |
| 4630 EXPECT_EQ(base::TimeDelta::FromMicroseconds(15), |
| 4631 request.GetTimeDelayForWaitingJob()); |
| 4632 |
| 4633 // Confirm the handshake and verify that the stream is created. |
| 4634 crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
| 4635 QuicSession::HANDSHAKE_CONFIRMED); |
| 4636 |
| 4637 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
| 4638 |
| 4639 std::unique_ptr<QuicHttpStream> stream = request.CreateStream(); |
| 4640 EXPECT_TRUE(stream.get()); |
| 4641 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
| 4642 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
| 4643 } |
| 4644 |
4508 // Verifies that the QUIC stream factory is initialized correctly. | 4645 // Verifies that the QUIC stream factory is initialized correctly. |
4509 TEST_P(QuicStreamFactoryTest, MaybeInitialize) { | 4646 TEST_P(QuicStreamFactoryTest, MaybeInitialize) { |
4510 VerifyInitialization(false); | 4647 VerifyInitialization(false); |
4511 } | 4648 } |
4512 | 4649 |
4513 // Verifies that the alternative proxy server provided by the proxy delegate | 4650 // Verifies that the alternative proxy server provided by the proxy delegate |
4514 // is added to the list of supported QUIC proxy servers, and the QUIC stream | 4651 // is added to the list of supported QUIC proxy servers, and the QUIC stream |
4515 // factory is initialized correctly. | 4652 // factory is initialized correctly. |
4516 TEST_P(QuicStreamFactoryTest, MaybeInitializeAlternativeProxyServer) { | 4653 TEST_P(QuicStreamFactoryTest, MaybeInitializeAlternativeProxyServer) { |
4517 VerifyInitialization(true); | 4654 VerifyInitialization(true); |
(...skipping 331 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4849 } else { | 4986 } else { |
4850 EXPECT_FALSE(session->force_hol_blocking()); | 4987 EXPECT_FALSE(session->force_hol_blocking()); |
4851 } | 4988 } |
4852 } | 4989 } |
4853 | 4990 |
4854 class QuicStreamFactoryWithDestinationTest | 4991 class QuicStreamFactoryWithDestinationTest |
4855 : public QuicStreamFactoryTestBase, | 4992 : public QuicStreamFactoryTestBase, |
4856 public ::testing::TestWithParam<PoolingTestParams> { | 4993 public ::testing::TestWithParam<PoolingTestParams> { |
4857 protected: | 4994 protected: |
4858 QuicStreamFactoryWithDestinationTest() | 4995 QuicStreamFactoryWithDestinationTest() |
4859 : QuicStreamFactoryTestBase(GetParam().version), | 4996 : QuicStreamFactoryTestBase(GetParam().version, |
| 4997 GetParam().enable_connection_racing), |
4860 destination_type_(GetParam().destination_type), | 4998 destination_type_(GetParam().destination_type), |
4861 hanging_read_(SYNCHRONOUS, ERR_IO_PENDING, 0) {} | 4999 hanging_read_(SYNCHRONOUS, ERR_IO_PENDING, 0) {} |
4862 | 5000 |
4863 HostPortPair GetDestination() { | 5001 HostPortPair GetDestination() { |
4864 switch (destination_type_) { | 5002 switch (destination_type_) { |
4865 case SAME_AS_FIRST: | 5003 case SAME_AS_FIRST: |
4866 return origin1_; | 5004 return origin1_; |
4867 case SAME_AS_SECOND: | 5005 case SAME_AS_SECOND: |
4868 return origin2_; | 5006 return origin2_; |
4869 case DIFFERENT: | 5007 case DIFFERENT: |
(...skipping 342 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5212 // Clear all cached states. | 5350 // Clear all cached states. |
5213 factory_->ClearCachedStatesInCryptoConfig( | 5351 factory_->ClearCachedStatesInCryptoConfig( |
5214 base::Callback<bool(const GURL&)>()); | 5352 base::Callback<bool(const GURL&)>()); |
5215 EXPECT_TRUE(test_cases[0].state->certs().empty()); | 5353 EXPECT_TRUE(test_cases[0].state->certs().empty()); |
5216 EXPECT_TRUE(test_cases[1].state->certs().empty()); | 5354 EXPECT_TRUE(test_cases[1].state->certs().empty()); |
5217 EXPECT_TRUE(test_cases[2].state->certs().empty()); | 5355 EXPECT_TRUE(test_cases[2].state->certs().empty()); |
5218 } | 5356 } |
5219 | 5357 |
5220 } // namespace test | 5358 } // namespace test |
5221 } // namespace net | 5359 } // namespace net |
OLD | NEW |