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