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 186 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
197 idle_connection_timeout_seconds_(kIdleConnectionTimeoutSeconds), | 197 idle_connection_timeout_seconds_(kIdleConnectionTimeoutSeconds), |
198 reduced_ping_timeout_seconds_(kPingTimeoutSecs), | 198 reduced_ping_timeout_seconds_(kPingTimeoutSecs), |
199 packet_reader_yield_after_duration_milliseconds_( | 199 packet_reader_yield_after_duration_milliseconds_( |
200 kQuicYieldAfterDurationMilliseconds), | 200 kQuicYieldAfterDurationMilliseconds), |
201 migrate_sessions_on_network_change_(false), | 201 migrate_sessions_on_network_change_(false), |
202 migrate_sessions_early_(false), | 202 migrate_sessions_early_(false), |
203 allow_server_migration_(false), | 203 allow_server_migration_(false), |
204 force_hol_blocking_(false), | 204 force_hol_blocking_(false), |
205 race_cert_verification_(false), | 205 race_cert_verification_(false), |
206 estimate_initial_rtt_(false) { | 206 estimate_initial_rtt_(false) { |
207 supported_versions_.push_back(version_); | |
208 advertised_versions_.push_back(version_); | |
207 clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1)); | 209 clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1)); |
208 } | 210 } |
209 | 211 |
210 void Initialize() { | 212 void Initialize() { |
211 DCHECK(!factory_); | 213 DCHECK(!factory_); |
212 factory_.reset(new QuicStreamFactory( | 214 factory_.reset(new QuicStreamFactory( |
213 net_log_.net_log(), &host_resolver_, ssl_config_service_.get(), | 215 net_log_.net_log(), &host_resolver_, ssl_config_service_.get(), |
214 &socket_factory_, &http_server_properties_, cert_verifier_.get(), | 216 &socket_factory_, &http_server_properties_, cert_verifier_.get(), |
215 &ct_policy_enforcer_, channel_id_service_.get(), | 217 &ct_policy_enforcer_, channel_id_service_.get(), |
216 &transport_security_state_, cert_transparency_verifier_.get(), | 218 &transport_security_state_, cert_transparency_verifier_.get(), |
217 /*SocketPerformanceWatcherFactory*/ nullptr, | 219 /*SocketPerformanceWatcherFactory*/ nullptr, |
218 &crypto_client_stream_factory_, &random_generator_, &clock_, | 220 &crypto_client_stream_factory_, &random_generator_, &clock_, |
219 kDefaultMaxPacketSize, string(), SupportedVersions(version_), | 221 kDefaultMaxPacketSize, string(), supported_versions_, |
220 store_server_configs_in_properties_, close_sessions_on_ip_change_, | 222 store_server_configs_in_properties_, close_sessions_on_ip_change_, |
221 /*mark_quic_broken_when_network_blackholes*/ false, | 223 /*mark_quic_broken_when_network_blackholes*/ false, |
222 idle_connection_timeout_seconds_, reduced_ping_timeout_seconds_, | 224 idle_connection_timeout_seconds_, reduced_ping_timeout_seconds_, |
223 packet_reader_yield_after_duration_milliseconds_, | 225 packet_reader_yield_after_duration_milliseconds_, |
224 migrate_sessions_on_network_change_, migrate_sessions_early_, | 226 migrate_sessions_on_network_change_, migrate_sessions_early_, |
225 allow_server_migration_, force_hol_blocking_, race_cert_verification_, | 227 allow_server_migration_, force_hol_blocking_, race_cert_verification_, |
226 /*do_not_fragment*/ true, estimate_initial_rtt_, QuicTagVector(), | 228 /*do_not_fragment*/ true, estimate_initial_rtt_, QuicTagVector(), |
227 /*enable_token_binding*/ false)); | 229 /*enable_token_binding*/ false)); |
228 factory_->set_require_confirmation(false); | 230 factory_->set_require_confirmation(false); |
229 } | 231 } |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
278 size_t socket_count = socket_factory_.udp_client_socket_ports().size(); | 280 size_t socket_count = socket_factory_.udp_client_socket_ports().size(); |
279 | 281 |
280 MockQuicData socket_data; | 282 MockQuicData socket_data; |
281 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 283 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
282 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 284 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
283 socket_data.AddSocketDataToFactory(&socket_factory_); | 285 socket_data.AddSocketDataToFactory(&socket_factory_); |
284 | 286 |
285 QuicStreamRequest request(factory_.get()); | 287 QuicStreamRequest request(factory_.get()); |
286 GURL url("https://" + destination.host() + "/"); | 288 GURL url("https://" + destination.host() + "/"); |
287 EXPECT_EQ(ERR_IO_PENDING, | 289 EXPECT_EQ(ERR_IO_PENDING, |
288 request.Request(destination, privacy_mode_, | 290 request.Request(destination, advertised_versions_, privacy_mode_, |
289 /*cert_verify_flags=*/0, url, "GET", net_log_, | 291 /*cert_verify_flags=*/0, url, "GET", net_log_, |
290 callback_.callback())); | 292 callback_.callback())); |
291 | 293 |
292 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 294 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
293 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 295 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
294 EXPECT_TRUE(stream.get()); | 296 EXPECT_TRUE(stream.get()); |
295 stream.reset(); | 297 stream.reset(); |
296 | 298 |
297 QuicChromiumClientSession* session = GetActiveSession(destination); | 299 QuicChromiumClientSession* session = GetActiveSession(destination); |
298 | 300 |
(...skipping 123 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
422 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 424 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
423 socket_data2.AddWrite(ConstructInitialSettingsPacket()); | 425 socket_data2.AddWrite(ConstructInitialSettingsPacket()); |
424 socket_data2.AddWrite( | 426 socket_data2.AddWrite( |
425 client_maker_.MakePingPacket(2, /*include_version=*/true)); | 427 client_maker_.MakePingPacket(2, /*include_version=*/true)); |
426 socket_data2.AddWrite(client_maker_.MakeRstPacket( | 428 socket_data2.AddWrite(client_maker_.MakeRstPacket( |
427 3, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); | 429 3, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); |
428 socket_data2.AddSocketDataToFactory(&socket_factory_); | 430 socket_data2.AddSocketDataToFactory(&socket_factory_); |
429 | 431 |
430 // Create request and QuicHttpStream. | 432 // Create request and QuicHttpStream. |
431 QuicStreamRequest request(factory_.get()); | 433 QuicStreamRequest request(factory_.get()); |
432 EXPECT_EQ(ERR_IO_PENDING, | 434 EXPECT_EQ( |
433 request.Request(host_port_pair_, privacy_mode_, | 435 ERR_IO_PENDING, |
434 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 436 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
435 callback_.callback())); | 437 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
438 callback_.callback())); | |
436 EXPECT_EQ(OK, callback_.WaitForResult()); | 439 EXPECT_EQ(OK, callback_.WaitForResult()); |
437 | 440 |
438 // Run QuicChromiumClientSession::WriteToNewSocket() | 441 // Run QuicChromiumClientSession::WriteToNewSocket() |
439 // posted by QuicChromiumClientSession::MigrateToSocket(). | 442 // posted by QuicChromiumClientSession::MigrateToSocket(). |
440 base::RunLoop().RunUntilIdle(); | 443 base::RunLoop().RunUntilIdle(); |
441 | 444 |
442 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 445 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
443 EXPECT_TRUE(stream.get()); | 446 EXPECT_TRUE(stream.get()); |
444 | 447 |
445 // Cause QUIC stream to be created. | 448 // Cause QUIC stream to be created. |
(...skipping 157 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
603 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), | 606 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), |
604 "192.168.0.1", ""); | 607 "192.168.0.1", ""); |
605 | 608 |
606 // Create a session and verify that the cached state is loaded. | 609 // Create a session and verify that the cached state is loaded. |
607 MockQuicData socket_data; | 610 MockQuicData socket_data; |
608 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 611 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
609 socket_data.AddSocketDataToFactory(&socket_factory_); | 612 socket_data.AddSocketDataToFactory(&socket_factory_); |
610 | 613 |
611 QuicStreamRequest request(factory_.get()); | 614 QuicStreamRequest request(factory_.get()); |
612 EXPECT_EQ(ERR_IO_PENDING, | 615 EXPECT_EQ(ERR_IO_PENDING, |
613 request.Request(quic_server_id.host_port_pair(), privacy_mode_, | 616 request.Request(quic_server_id.host_port_pair(), |
617 advertised_versions_, privacy_mode_, | |
614 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 618 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
615 callback_.callback())); | 619 callback_.callback())); |
616 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 620 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
617 | 621 |
618 EXPECT_FALSE(QuicStreamFactoryPeer::CryptoConfigCacheIsEmpty( | 622 EXPECT_FALSE(QuicStreamFactoryPeer::CryptoConfigCacheIsEmpty( |
619 factory_.get(), quic_server_id)); | 623 factory_.get(), quic_server_id)); |
620 QuicCryptoClientConfig* crypto_config = | 624 QuicCryptoClientConfig* crypto_config = |
621 QuicStreamFactoryPeer::GetCryptoConfig(factory_.get()); | 625 QuicStreamFactoryPeer::GetCryptoConfig(factory_.get()); |
622 QuicCryptoClientConfig::CachedState* cached = | 626 QuicCryptoClientConfig::CachedState* cached = |
623 crypto_config->LookupOrCreate(quic_server_id); | 627 crypto_config->LookupOrCreate(quic_server_id); |
(...skipping 12 matching lines...) Expand all Loading... | |
636 // Create a session and verify that the cached state is loaded. | 640 // Create a session and verify that the cached state is loaded. |
637 MockQuicData socket_data2; | 641 MockQuicData socket_data2; |
638 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 642 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
639 socket_data2.AddSocketDataToFactory(&socket_factory_); | 643 socket_data2.AddSocketDataToFactory(&socket_factory_); |
640 | 644 |
641 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), | 645 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), |
642 "192.168.0.2", ""); | 646 "192.168.0.2", ""); |
643 | 647 |
644 QuicStreamRequest request2(factory_.get()); | 648 QuicStreamRequest request2(factory_.get()); |
645 EXPECT_EQ(ERR_IO_PENDING, | 649 EXPECT_EQ(ERR_IO_PENDING, |
646 request2.Request(quic_server_id2.host_port_pair(), privacy_mode_, | 650 request2.Request(quic_server_id2.host_port_pair(), |
651 advertised_versions_, privacy_mode_, | |
647 /*cert_verify_flags=*/0, | 652 /*cert_verify_flags=*/0, |
648 GURL("https://mail.example.org/"), "GET", | 653 GURL("https://mail.example.org/"), "GET", |
649 net_log_, callback_.callback())); | 654 net_log_, callback_.callback())); |
650 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 655 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
651 | 656 |
652 EXPECT_FALSE(QuicStreamFactoryPeer::CryptoConfigCacheIsEmpty( | 657 EXPECT_FALSE(QuicStreamFactoryPeer::CryptoConfigCacheIsEmpty( |
653 factory_.get(), quic_server_id2)); | 658 factory_.get(), quic_server_id2)); |
654 QuicCryptoClientConfig::CachedState* cached2 = | 659 QuicCryptoClientConfig::CachedState* cached2 = |
655 crypto_config->LookupOrCreate(quic_server_id2); | 660 crypto_config->LookupOrCreate(quic_server_id2); |
656 EXPECT_FALSE(cached2->server_config().empty()); | 661 EXPECT_FALSE(cached2->server_config().empty()); |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
696 bool disconnected); | 701 bool disconnected); |
697 | 702 |
698 MockHostResolver host_resolver_; | 703 MockHostResolver host_resolver_; |
699 scoped_refptr<SSLConfigService> ssl_config_service_; | 704 scoped_refptr<SSLConfigService> ssl_config_service_; |
700 MockClientSocketFactory socket_factory_; | 705 MockClientSocketFactory socket_factory_; |
701 MockCryptoClientStreamFactory crypto_client_stream_factory_; | 706 MockCryptoClientStreamFactory crypto_client_stream_factory_; |
702 MockRandom random_generator_; | 707 MockRandom random_generator_; |
703 MockClock clock_; | 708 MockClock clock_; |
704 scoped_refptr<TestTaskRunner> runner_; | 709 scoped_refptr<TestTaskRunner> runner_; |
705 QuicVersion version_; | 710 QuicVersion version_; |
711 QuicVersionVector supported_versions_; | |
712 QuicVersionVector advertised_versions_; | |
706 QuicTestPacketMaker client_maker_; | 713 QuicTestPacketMaker client_maker_; |
707 QuicTestPacketMaker server_maker_; | 714 QuicTestPacketMaker server_maker_; |
708 HttpServerPropertiesImpl http_server_properties_; | 715 HttpServerPropertiesImpl http_server_properties_; |
709 std::unique_ptr<CertVerifier> cert_verifier_; | 716 std::unique_ptr<CertVerifier> cert_verifier_; |
710 std::unique_ptr<ChannelIDService> channel_id_service_; | 717 std::unique_ptr<ChannelIDService> channel_id_service_; |
711 TransportSecurityState transport_security_state_; | 718 TransportSecurityState transport_security_state_; |
712 std::unique_ptr<CTVerifier> cert_transparency_verifier_; | 719 std::unique_ptr<CTVerifier> cert_transparency_verifier_; |
713 CTPolicyEnforcer ct_policy_enforcer_; | 720 CTPolicyEnforcer ct_policy_enforcer_; |
714 std::unique_ptr<ScopedMockNetworkChangeNotifier> | 721 std::unique_ptr<ScopedMockNetworkChangeNotifier> |
715 scoped_mock_network_change_notifier_; | 722 scoped_mock_network_change_notifier_; |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
752 Initialize(); | 759 Initialize(); |
753 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 760 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
754 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 761 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
755 | 762 |
756 MockQuicData socket_data; | 763 MockQuicData socket_data; |
757 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 764 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
758 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 765 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
759 socket_data.AddSocketDataToFactory(&socket_factory_); | 766 socket_data.AddSocketDataToFactory(&socket_factory_); |
760 | 767 |
761 QuicStreamRequest request(factory_.get()); | 768 QuicStreamRequest request(factory_.get()); |
762 EXPECT_EQ(ERR_IO_PENDING, | 769 EXPECT_EQ( |
763 request.Request(host_port_pair_, privacy_mode_, | 770 ERR_IO_PENDING, |
764 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 771 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
765 callback_.callback())); | 772 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
773 callback_.callback())); | |
766 | 774 |
767 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 775 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
768 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 776 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
769 EXPECT_TRUE(stream.get()); | 777 EXPECT_TRUE(stream.get()); |
770 | 778 |
771 QuicStreamRequest request2(factory_.get()); | 779 QuicStreamRequest request2(factory_.get()); |
772 EXPECT_EQ(OK, request2.Request(host_port_pair_, privacy_mode_, | 780 EXPECT_EQ( |
773 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 781 OK, request2.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
774 callback_.callback())); | 782 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
783 callback_.callback())); | |
775 // Will reset stream 3. | 784 // Will reset stream 3. |
776 stream = request2.CreateStream(); | 785 stream = request2.CreateStream(); |
777 | 786 |
778 EXPECT_TRUE(stream.get()); | 787 EXPECT_TRUE(stream.get()); |
779 | 788 |
780 // TODO(rtenneti): We should probably have a tests that HTTP and HTTPS result | 789 // TODO(rtenneti): We should probably have a tests that HTTP and HTTPS result |
781 // in streams on different sessions. | 790 // in streams on different sessions. |
782 QuicStreamRequest request3(factory_.get()); | 791 QuicStreamRequest request3(factory_.get()); |
783 EXPECT_EQ(OK, request3.Request(host_port_pair_, privacy_mode_, | 792 EXPECT_EQ( |
784 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 793 OK, request3.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
785 callback_.callback())); | 794 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
795 callback_.callback())); | |
786 stream = request3.CreateStream(); // Will reset stream 5. | 796 stream = request3.CreateStream(); // Will reset stream 5. |
787 stream.reset(); // Will reset stream 7. | 797 stream.reset(); // Will reset stream 7. |
788 | 798 |
789 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 799 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
790 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 800 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
791 } | 801 } |
792 | 802 |
793 TEST_P(QuicStreamFactoryTest, CreateZeroRtt) { | 803 TEST_P(QuicStreamFactoryTest, CreateZeroRtt) { |
794 Initialize(); | 804 Initialize(); |
795 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 805 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
796 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 806 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
797 | 807 |
798 MockQuicData socket_data; | 808 MockQuicData socket_data; |
799 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 809 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
800 socket_data.AddSocketDataToFactory(&socket_factory_); | 810 socket_data.AddSocketDataToFactory(&socket_factory_); |
801 | 811 |
802 crypto_client_stream_factory_.set_handshake_mode( | 812 crypto_client_stream_factory_.set_handshake_mode( |
803 MockCryptoClientStream::ZERO_RTT); | 813 MockCryptoClientStream::ZERO_RTT); |
804 host_resolver_.set_synchronous_mode(true); | 814 host_resolver_.set_synchronous_mode(true); |
805 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), | 815 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), |
806 "192.168.0.1", ""); | 816 "192.168.0.1", ""); |
807 | 817 |
808 QuicStreamRequest request(factory_.get()); | 818 QuicStreamRequest request(factory_.get()); |
809 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_, | 819 EXPECT_EQ( |
810 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 820 OK, request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
811 callback_.callback())); | 821 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
822 callback_.callback())); | |
812 | 823 |
813 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 824 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
814 EXPECT_TRUE(stream.get()); | 825 EXPECT_TRUE(stream.get()); |
815 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 826 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
816 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 827 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
817 } | 828 } |
818 | 829 |
819 TEST_P(QuicStreamFactoryTest, CreateZeroRttPost) { | 830 TEST_P(QuicStreamFactoryTest, CreateZeroRttPost) { |
820 Initialize(); | 831 Initialize(); |
821 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 832 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
822 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 833 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
823 | 834 |
824 MockQuicData socket_data; | 835 MockQuicData socket_data; |
825 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 836 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
826 socket_data.AddSocketDataToFactory(&socket_factory_); | 837 socket_data.AddSocketDataToFactory(&socket_factory_); |
827 | 838 |
828 crypto_client_stream_factory_.set_handshake_mode( | 839 crypto_client_stream_factory_.set_handshake_mode( |
829 MockCryptoClientStream::ZERO_RTT); | 840 MockCryptoClientStream::ZERO_RTT); |
830 host_resolver_.set_synchronous_mode(true); | 841 host_resolver_.set_synchronous_mode(true); |
831 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), | 842 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), |
832 "192.168.0.1", ""); | 843 "192.168.0.1", ""); |
833 | 844 |
834 QuicStreamRequest request(factory_.get()); | 845 QuicStreamRequest request(factory_.get()); |
835 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_, | 846 EXPECT_EQ( |
836 /*cert_verify_flags=*/0, url_, "POST", net_log_, | 847 OK, request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
837 callback_.callback())); | 848 /*cert_verify_flags=*/0, url_, "POST", net_log_, |
849 callback_.callback())); | |
838 | 850 |
839 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 851 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
840 EXPECT_TRUE(stream.get()); | 852 EXPECT_TRUE(stream.get()); |
841 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 853 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
842 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 854 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
843 } | 855 } |
844 | 856 |
845 TEST_P(QuicStreamFactoryTest, DefaultInitialRtt) { | 857 TEST_P(QuicStreamFactoryTest, CreateWithNoAdvertisedVersion) { |
858 // Set the net stack to support two QUIC versions. | |
859 if (version_ != QUIC_VERSION_40) { | |
860 supported_versions_.push_back(QUIC_VERSION_40); | |
861 } else { | |
862 supported_versions_.push_back(QUIC_VERSION_38); | |
863 } | |
846 Initialize(); | 864 Initialize(); |
847 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 865 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
848 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 866 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
849 | 867 |
850 MockQuicData socket_data; | 868 MockQuicData socket_data; |
851 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 869 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
852 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 870 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
853 socket_data.AddSocketDataToFactory(&socket_factory_); | 871 socket_data.AddSocketDataToFactory(&socket_factory_); |
854 | 872 |
855 QuicStreamRequest request(factory_.get()); | 873 QuicStreamRequest request(factory_.get()); |
874 // There is no advertised QUIC version. QuicStreamFactory::Request will use | |
875 // the preferred QUIC version that is suppported by the net stack, | |
876 // i.e., |version_|. | |
856 EXPECT_EQ(ERR_IO_PENDING, | 877 EXPECT_EQ(ERR_IO_PENDING, |
857 request.Request(host_port_pair_, privacy_mode_, | 878 request.Request(host_port_pair_, QuicVersionVector(), privacy_mode_, |
858 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 879 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
859 callback_.callback())); | 880 callback_.callback())); |
860 | 881 |
861 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 882 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
862 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 883 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
863 EXPECT_TRUE(stream.get()); | 884 EXPECT_TRUE(stream.get()); |
864 | 885 |
865 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); | 886 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); |
887 EXPECT_EQ(version_, session->GetQuicVersion()); | |
888 EXPECT_EQ(100000u, session->connection()->GetStats().srtt_us); | |
889 ASSERT_FALSE(session->config()->HasInitialRoundTripTimeUsToSend()); | |
890 } | |
891 | |
892 TEST_P(QuicStreamFactoryTest, CreateWithNoMutuallySupportedVersions) { | |
893 // Set the net stack to support two QUIC versions. | |
894 if (version_ != QUIC_VERSION_40) { | |
895 supported_versions_.push_back(QUIC_VERSION_40); | |
896 } else { | |
897 supported_versions_.push_back(QUIC_VERSION_38); | |
898 } | |
899 // Set the advertised versions to be different from all the versions that | |
900 // this net stack supports. QuicStreamFactory::Request should use the | |
901 // preferred QUIC version supported by the net stack. | |
902 advertised_versions_.clear(); | |
903 advertised_versions_.push_back(QUIC_VERSION_UNSUPPORTED); | |
904 | |
905 Initialize(); | |
906 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | |
907 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | |
908 | |
909 MockQuicData socket_data; | |
910 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | |
911 socket_data.AddWrite(ConstructInitialSettingsPacket()); | |
912 socket_data.AddSocketDataToFactory(&socket_factory_); | |
913 | |
914 QuicStreamRequest request(factory_.get()); | |
915 EXPECT_EQ( | |
916 ERR_IO_PENDING, | |
917 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, | |
918 /*cert_verify_flags=*/0, url_, "GET", net_log_, | |
919 callback_.callback())); | |
920 | |
921 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | |
922 std::unique_ptr<HttpStream> stream = request.CreateStream(); | |
923 EXPECT_TRUE(stream.get()); | |
924 | |
925 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); | |
926 EXPECT_EQ(version_, session->GetQuicVersion()); | |
927 EXPECT_EQ(100000u, session->connection()->GetStats().srtt_us); | |
928 ASSERT_FALSE(session->config()->HasInitialRoundTripTimeUsToSend()); | |
929 } | |
930 | |
931 TEST_P(QuicStreamFactoryTest, CreateWithMutuallySupportedVersions) { | |
932 // Set the net stack to support two QUIC versions: |version_| is the | |
933 // non-preferred version. | |
934 supported_versions_.clear(); | |
935 if (version_ != QUIC_VERSION_40) { | |
936 supported_versions_.push_back(QUIC_VERSION_40); | |
937 } else { | |
938 supported_versions_.push_back(QUIC_VERSION_38); | |
939 } | |
940 supported_versions_.push_back(version_); | |
941 | |
942 Initialize(); | |
943 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | |
944 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | |
945 | |
946 MockQuicData socket_data; | |
947 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | |
948 socket_data.AddWrite(ConstructInitialSettingsPacket()); | |
949 socket_data.AddSocketDataToFactory(&socket_factory_); | |
950 | |
951 QuicStreamRequest request(factory_.get()); | |
952 // The version advertised {version_} is not preferred by the net stack but | |
953 // supportd. QuicStreamFactory::Request should select the mutually supported | |
Bence
2017/06/28 19:08:58
s/supportd/supported/
Zhongyi Shi
2017/07/05 23:08:59
Acknowledged.
| |
954 // version. | |
955 EXPECT_EQ( | |
956 ERR_IO_PENDING, | |
957 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, | |
958 /*cert_verify_flags=*/0, url_, "GET", net_log_, | |
959 callback_.callback())); | |
960 | |
961 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | |
962 std::unique_ptr<HttpStream> stream = request.CreateStream(); | |
963 EXPECT_TRUE(stream.get()); | |
964 | |
965 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); | |
966 EXPECT_EQ(version_, session->GetQuicVersion()); | |
967 EXPECT_EQ(100000u, session->connection()->GetStats().srtt_us); | |
968 ASSERT_FALSE(session->config()->HasInitialRoundTripTimeUsToSend()); | |
969 } | |
970 | |
971 TEST_P(QuicStreamFactoryTest, DefaultInitialRtt) { | |
972 Initialize(); | |
973 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | |
974 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | |
975 | |
976 MockQuicData socket_data; | |
977 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | |
978 socket_data.AddWrite(ConstructInitialSettingsPacket()); | |
979 socket_data.AddSocketDataToFactory(&socket_factory_); | |
980 | |
981 QuicStreamRequest request(factory_.get()); | |
982 EXPECT_EQ( | |
983 ERR_IO_PENDING, | |
984 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, | |
985 /*cert_verify_flags=*/0, url_, "GET", net_log_, | |
986 callback_.callback())); | |
987 | |
988 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | |
989 std::unique_ptr<HttpStream> stream = request.CreateStream(); | |
990 EXPECT_TRUE(stream.get()); | |
991 | |
992 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); | |
866 EXPECT_EQ(100000u, session->connection()->GetStats().srtt_us); | 993 EXPECT_EQ(100000u, session->connection()->GetStats().srtt_us); |
867 ASSERT_FALSE(session->config()->HasInitialRoundTripTimeUsToSend()); | 994 ASSERT_FALSE(session->config()->HasInitialRoundTripTimeUsToSend()); |
868 } | 995 } |
869 | 996 |
870 TEST_P(QuicStreamFactoryTest, CachedInitialRtt) { | 997 TEST_P(QuicStreamFactoryTest, CachedInitialRtt) { |
871 ServerNetworkStats stats; | 998 ServerNetworkStats stats; |
872 stats.srtt = base::TimeDelta::FromMilliseconds(10); | 999 stats.srtt = base::TimeDelta::FromMilliseconds(10); |
873 http_server_properties_.SetServerNetworkStats(url::SchemeHostPort(url_), | 1000 http_server_properties_.SetServerNetworkStats(url::SchemeHostPort(url_), |
874 stats); | 1001 stats); |
875 estimate_initial_rtt_ = true; | 1002 estimate_initial_rtt_ = true; |
876 | 1003 |
877 Initialize(); | 1004 Initialize(); |
878 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 1005 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
879 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 1006 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
880 | 1007 |
881 MockQuicData socket_data; | 1008 MockQuicData socket_data; |
882 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 1009 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
883 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 1010 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
884 socket_data.AddSocketDataToFactory(&socket_factory_); | 1011 socket_data.AddSocketDataToFactory(&socket_factory_); |
885 | 1012 |
886 QuicStreamRequest request(factory_.get()); | 1013 QuicStreamRequest request(factory_.get()); |
887 EXPECT_EQ(ERR_IO_PENDING, | 1014 EXPECT_EQ( |
888 request.Request(host_port_pair_, privacy_mode_, | 1015 ERR_IO_PENDING, |
889 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1016 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
890 callback_.callback())); | 1017 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1018 callback_.callback())); | |
891 | 1019 |
892 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 1020 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
893 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 1021 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
894 EXPECT_TRUE(stream.get()); | 1022 EXPECT_TRUE(stream.get()); |
895 | 1023 |
896 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); | 1024 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); |
897 EXPECT_EQ(10000u, session->connection()->GetStats().srtt_us); | 1025 EXPECT_EQ(10000u, session->connection()->GetStats().srtt_us); |
898 ASSERT_TRUE(session->config()->HasInitialRoundTripTimeUsToSend()); | 1026 ASSERT_TRUE(session->config()->HasInitialRoundTripTimeUsToSend()); |
899 EXPECT_EQ(10000u, session->config()->GetInitialRoundTripTimeUsToSend()); | 1027 EXPECT_EQ(10000u, session->config()->GetInitialRoundTripTimeUsToSend()); |
900 } | 1028 } |
901 | 1029 |
902 TEST_P(QuicStreamFactoryTest, 2gInitialRtt) { | 1030 TEST_P(QuicStreamFactoryTest, 2gInitialRtt) { |
903 ScopedMockNetworkChangeNotifier notifier; | 1031 ScopedMockNetworkChangeNotifier notifier; |
904 notifier.mock_network_change_notifier()->SetConnectionType( | 1032 notifier.mock_network_change_notifier()->SetConnectionType( |
905 NetworkChangeNotifier::CONNECTION_2G); | 1033 NetworkChangeNotifier::CONNECTION_2G); |
906 estimate_initial_rtt_ = true; | 1034 estimate_initial_rtt_ = true; |
907 | 1035 |
908 Initialize(); | 1036 Initialize(); |
909 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 1037 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
910 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 1038 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
911 | 1039 |
912 MockQuicData socket_data; | 1040 MockQuicData socket_data; |
913 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 1041 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
914 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 1042 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
915 socket_data.AddSocketDataToFactory(&socket_factory_); | 1043 socket_data.AddSocketDataToFactory(&socket_factory_); |
916 | 1044 |
917 QuicStreamRequest request(factory_.get()); | 1045 QuicStreamRequest request(factory_.get()); |
918 EXPECT_EQ(ERR_IO_PENDING, | 1046 EXPECT_EQ( |
919 request.Request(host_port_pair_, privacy_mode_, | 1047 ERR_IO_PENDING, |
920 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1048 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
921 callback_.callback())); | 1049 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1050 callback_.callback())); | |
922 | 1051 |
923 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 1052 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
924 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 1053 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
925 EXPECT_TRUE(stream.get()); | 1054 EXPECT_TRUE(stream.get()); |
926 | 1055 |
927 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); | 1056 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); |
928 EXPECT_EQ(1200000u, session->connection()->GetStats().srtt_us); | 1057 EXPECT_EQ(1200000u, session->connection()->GetStats().srtt_us); |
929 ASSERT_TRUE(session->config()->HasInitialRoundTripTimeUsToSend()); | 1058 ASSERT_TRUE(session->config()->HasInitialRoundTripTimeUsToSend()); |
930 EXPECT_EQ(1200000u, session->config()->GetInitialRoundTripTimeUsToSend()); | 1059 EXPECT_EQ(1200000u, session->config()->GetInitialRoundTripTimeUsToSend()); |
931 } | 1060 } |
932 | 1061 |
933 TEST_P(QuicStreamFactoryTest, 3gInitialRtt) { | 1062 TEST_P(QuicStreamFactoryTest, 3gInitialRtt) { |
934 ScopedMockNetworkChangeNotifier notifier; | 1063 ScopedMockNetworkChangeNotifier notifier; |
935 notifier.mock_network_change_notifier()->SetConnectionType( | 1064 notifier.mock_network_change_notifier()->SetConnectionType( |
936 NetworkChangeNotifier::CONNECTION_3G); | 1065 NetworkChangeNotifier::CONNECTION_3G); |
937 estimate_initial_rtt_ = true; | 1066 estimate_initial_rtt_ = true; |
938 | 1067 |
939 Initialize(); | 1068 Initialize(); |
940 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 1069 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
941 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 1070 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
942 | 1071 |
943 MockQuicData socket_data; | 1072 MockQuicData socket_data; |
944 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 1073 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
945 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 1074 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
946 socket_data.AddSocketDataToFactory(&socket_factory_); | 1075 socket_data.AddSocketDataToFactory(&socket_factory_); |
947 | 1076 |
948 QuicStreamRequest request(factory_.get()); | 1077 QuicStreamRequest request(factory_.get()); |
949 EXPECT_EQ(ERR_IO_PENDING, | 1078 EXPECT_EQ( |
950 request.Request(host_port_pair_, privacy_mode_, | 1079 ERR_IO_PENDING, |
951 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1080 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
952 callback_.callback())); | 1081 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1082 callback_.callback())); | |
953 | 1083 |
954 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 1084 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
955 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 1085 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
956 EXPECT_TRUE(stream.get()); | 1086 EXPECT_TRUE(stream.get()); |
957 | 1087 |
958 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); | 1088 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); |
959 EXPECT_EQ(400000u, session->connection()->GetStats().srtt_us); | 1089 EXPECT_EQ(400000u, session->connection()->GetStats().srtt_us); |
960 ASSERT_TRUE(session->config()->HasInitialRoundTripTimeUsToSend()); | 1090 ASSERT_TRUE(session->config()->HasInitialRoundTripTimeUsToSend()); |
961 EXPECT_EQ(400000u, session->config()->GetInitialRoundTripTimeUsToSend()); | 1091 EXPECT_EQ(400000u, session->config()->GetInitialRoundTripTimeUsToSend()); |
962 } | 1092 } |
963 | 1093 |
964 TEST_P(QuicStreamFactoryTest, GoAway) { | 1094 TEST_P(QuicStreamFactoryTest, GoAway) { |
965 Initialize(); | 1095 Initialize(); |
966 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 1096 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
967 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 1097 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
968 | 1098 |
969 MockQuicData socket_data; | 1099 MockQuicData socket_data; |
970 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 1100 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
971 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 1101 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
972 socket_data.AddSocketDataToFactory(&socket_factory_); | 1102 socket_data.AddSocketDataToFactory(&socket_factory_); |
973 | 1103 |
974 QuicStreamRequest request(factory_.get()); | 1104 QuicStreamRequest request(factory_.get()); |
975 EXPECT_EQ(ERR_IO_PENDING, | 1105 EXPECT_EQ( |
976 request.Request(host_port_pair_, privacy_mode_, | 1106 ERR_IO_PENDING, |
977 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1107 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
978 callback_.callback())); | 1108 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1109 callback_.callback())); | |
979 | 1110 |
980 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 1111 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
981 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 1112 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
982 EXPECT_TRUE(stream.get()); | 1113 EXPECT_TRUE(stream.get()); |
983 | 1114 |
984 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); | 1115 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); |
985 | 1116 |
986 session->OnGoAway(QuicGoAwayFrame()); | 1117 session->OnGoAway(QuicGoAwayFrame()); |
987 | 1118 |
988 EXPECT_FALSE(HasActiveSession(host_port_pair_)); | 1119 EXPECT_FALSE(HasActiveSession(host_port_pair_)); |
989 | 1120 |
990 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 1121 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
991 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 1122 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
992 } | 1123 } |
993 | 1124 |
994 TEST_P(QuicStreamFactoryTest, GoAwayForConnectionMigrationWithPortOnly) { | 1125 TEST_P(QuicStreamFactoryTest, GoAwayForConnectionMigrationWithPortOnly) { |
995 Initialize(); | 1126 Initialize(); |
996 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 1127 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
997 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 1128 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
998 | 1129 |
999 MockQuicData socket_data; | 1130 MockQuicData socket_data; |
1000 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 1131 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
1001 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 1132 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
1002 socket_data.AddSocketDataToFactory(&socket_factory_); | 1133 socket_data.AddSocketDataToFactory(&socket_factory_); |
1003 | 1134 |
1004 QuicStreamRequest request(factory_.get()); | 1135 QuicStreamRequest request(factory_.get()); |
1005 EXPECT_EQ(ERR_IO_PENDING, | 1136 EXPECT_EQ( |
1006 request.Request(host_port_pair_, privacy_mode_, | 1137 ERR_IO_PENDING, |
1007 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1138 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
1008 callback_.callback())); | 1139 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1140 callback_.callback())); | |
1009 | 1141 |
1010 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 1142 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
1011 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 1143 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
1012 EXPECT_TRUE(stream.get()); | 1144 EXPECT_TRUE(stream.get()); |
1013 | 1145 |
1014 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); | 1146 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); |
1015 | 1147 |
1016 session->OnGoAway( | 1148 session->OnGoAway( |
1017 QuicGoAwayFrame(QUIC_ERROR_MIGRATING_PORT, 0, | 1149 QuicGoAwayFrame(QUIC_ERROR_MIGRATING_PORT, 0, |
1018 "peer connection migration due to port change only")); | 1150 "peer connection migration due to port change only")); |
(...skipping 21 matching lines...) Expand all Loading... | |
1040 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 1172 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
1041 socket_data.AddSocketDataToFactory(&socket_factory_); | 1173 socket_data.AddSocketDataToFactory(&socket_factory_); |
1042 | 1174 |
1043 HostPortPair server2(kServer2HostName, kDefaultServerPort); | 1175 HostPortPair server2(kServer2HostName, kDefaultServerPort); |
1044 host_resolver_.set_synchronous_mode(true); | 1176 host_resolver_.set_synchronous_mode(true); |
1045 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), | 1177 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), |
1046 "192.168.0.1", ""); | 1178 "192.168.0.1", ""); |
1047 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); | 1179 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); |
1048 | 1180 |
1049 QuicStreamRequest request(factory_.get()); | 1181 QuicStreamRequest request(factory_.get()); |
1050 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_, | 1182 EXPECT_EQ( |
1051 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1183 OK, request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
1052 callback_.callback())); | 1184 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1185 callback_.callback())); | |
1053 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 1186 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
1054 EXPECT_TRUE(stream.get()); | 1187 EXPECT_TRUE(stream.get()); |
1055 | 1188 |
1056 TestCompletionCallback callback; | 1189 TestCompletionCallback callback; |
1057 QuicStreamRequest request2(factory_.get()); | 1190 QuicStreamRequest request2(factory_.get()); |
1058 EXPECT_EQ(OK, request2.Request(server2, privacy_mode_, | 1191 EXPECT_EQ(OK, request2.Request(server2, advertised_versions_, privacy_mode_, |
1059 /*cert_verify_flags=*/0, url2_, "GET", | 1192 /*cert_verify_flags=*/0, url2_, "GET", |
1060 net_log_, callback.callback())); | 1193 net_log_, callback.callback())); |
1061 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 1194 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
1062 EXPECT_TRUE(stream2.get()); | 1195 EXPECT_TRUE(stream2.get()); |
1063 | 1196 |
1064 EXPECT_EQ(GetActiveSession(host_port_pair_), GetActiveSession(server2)); | 1197 EXPECT_EQ(GetActiveSession(host_port_pair_), GetActiveSession(server2)); |
1065 | 1198 |
1066 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 1199 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
1067 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 1200 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
1068 } | 1201 } |
(...skipping 29 matching lines...) Expand all Loading... | |
1098 | 1231 |
1099 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 1232 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
1100 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 1233 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
1101 QuicConfig config2; | 1234 QuicConfig config2; |
1102 crypto_client_stream_factory_.SetConfig(config2); | 1235 crypto_client_stream_factory_.SetConfig(config2); |
1103 | 1236 |
1104 // Create new request to cause new session creation. | 1237 // Create new request to cause new session creation. |
1105 TestCompletionCallback callback; | 1238 TestCompletionCallback callback; |
1106 QuicStreamRequest request2(factory_.get()); | 1239 QuicStreamRequest request2(factory_.get()); |
1107 EXPECT_EQ(ERR_IO_PENDING, | 1240 EXPECT_EQ(ERR_IO_PENDING, |
1108 request2.Request(server2, privacy_mode_, | 1241 request2.Request(server2, advertised_versions_, privacy_mode_, |
1109 /*cert_verify_flags=*/0, url2_, "GET", net_log_, | 1242 /*cert_verify_flags=*/0, url2_, "GET", net_log_, |
1110 callback.callback())); | 1243 callback.callback())); |
1111 EXPECT_EQ(OK, callback.WaitForResult()); | 1244 EXPECT_EQ(OK, callback.WaitForResult()); |
1112 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 1245 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
1113 EXPECT_TRUE(stream2.get()); | 1246 EXPECT_TRUE(stream2.get()); |
1114 | 1247 |
1115 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 1248 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
1116 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 1249 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
1117 // EXPECT_EQ(GetActiveSession(host_port_pair_), GetActiveSession(server2)); | 1250 // EXPECT_EQ(GetActiveSession(host_port_pair_), GetActiveSession(server2)); |
1118 } | 1251 } |
(...skipping 13 matching lines...) Expand all Loading... | |
1132 socket_data2.AddWrite(ConstructInitialSettingsPacket()); | 1265 socket_data2.AddWrite(ConstructInitialSettingsPacket()); |
1133 socket_data2.AddSocketDataToFactory(&socket_factory_); | 1266 socket_data2.AddSocketDataToFactory(&socket_factory_); |
1134 | 1267 |
1135 HostPortPair server2(kServer2HostName, kDefaultServerPort); | 1268 HostPortPair server2(kServer2HostName, kDefaultServerPort); |
1136 host_resolver_.set_synchronous_mode(true); | 1269 host_resolver_.set_synchronous_mode(true); |
1137 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), | 1270 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), |
1138 "192.168.0.1", ""); | 1271 "192.168.0.1", ""); |
1139 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); | 1272 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); |
1140 | 1273 |
1141 QuicStreamRequest request(factory_.get()); | 1274 QuicStreamRequest request(factory_.get()); |
1142 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_, | 1275 EXPECT_EQ( |
1143 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1276 OK, request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
1144 callback_.callback())); | 1277 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1278 callback_.callback())); | |
1145 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 1279 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
1146 EXPECT_TRUE(stream.get()); | 1280 EXPECT_TRUE(stream.get()); |
1147 | 1281 |
1148 TestCompletionCallback callback; | 1282 TestCompletionCallback callback; |
1149 QuicStreamRequest request2(factory_.get()); | 1283 QuicStreamRequest request2(factory_.get()); |
1150 EXPECT_EQ(OK, request2.Request(server2, privacy_mode_, | 1284 EXPECT_EQ(OK, request2.Request(server2, advertised_versions_, privacy_mode_, |
1151 /*cert_verify_flags=*/0, url2_, "GET", | 1285 /*cert_verify_flags=*/0, url2_, "GET", |
1152 net_log_, callback.callback())); | 1286 net_log_, callback.callback())); |
1153 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 1287 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
1154 EXPECT_TRUE(stream2.get()); | 1288 EXPECT_TRUE(stream2.get()); |
1155 | 1289 |
1156 factory_->OnSessionGoingAway(GetActiveSession(host_port_pair_)); | 1290 factory_->OnSessionGoingAway(GetActiveSession(host_port_pair_)); |
1157 EXPECT_FALSE(HasActiveSession(host_port_pair_)); | 1291 EXPECT_FALSE(HasActiveSession(host_port_pair_)); |
1158 EXPECT_FALSE(HasActiveSession(server2)); | 1292 EXPECT_FALSE(HasActiveSession(server2)); |
1159 | 1293 |
1160 TestCompletionCallback callback3; | 1294 TestCompletionCallback callback3; |
1161 QuicStreamRequest request3(factory_.get()); | 1295 QuicStreamRequest request3(factory_.get()); |
1162 EXPECT_EQ(OK, request3.Request(server2, privacy_mode_, | 1296 EXPECT_EQ(OK, request3.Request(server2, advertised_versions_, privacy_mode_, |
1163 /*cert_verify_flags=*/0, url2_, "GET", | 1297 /*cert_verify_flags=*/0, url2_, "GET", |
1164 net_log_, callback3.callback())); | 1298 net_log_, callback3.callback())); |
1165 std::unique_ptr<HttpStream> stream3 = request3.CreateStream(); | 1299 std::unique_ptr<HttpStream> stream3 = request3.CreateStream(); |
1166 EXPECT_TRUE(stream3.get()); | 1300 EXPECT_TRUE(stream3.get()); |
1167 | 1301 |
1168 EXPECT_TRUE(HasActiveSession(server2)); | 1302 EXPECT_TRUE(HasActiveSession(server2)); |
1169 | 1303 |
1170 EXPECT_TRUE(socket_data1.AllReadDataConsumed()); | 1304 EXPECT_TRUE(socket_data1.AllReadDataConsumed()); |
1171 EXPECT_TRUE(socket_data1.AllWriteDataConsumed()); | 1305 EXPECT_TRUE(socket_data1.AllWriteDataConsumed()); |
1172 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); | 1306 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); |
(...skipping 12 matching lines...) Expand all Loading... | |
1185 HostPortPair server2(kServer2HostName, 443); | 1319 HostPortPair server2(kServer2HostName, 443); |
1186 | 1320 |
1187 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 1321 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
1188 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 1322 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
1189 | 1323 |
1190 host_resolver_.set_synchronous_mode(true); | 1324 host_resolver_.set_synchronous_mode(true); |
1191 host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", ""); | 1325 host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", ""); |
1192 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); | 1326 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); |
1193 | 1327 |
1194 QuicStreamRequest request(factory_.get()); | 1328 QuicStreamRequest request(factory_.get()); |
1195 EXPECT_EQ(OK, request.Request(server1, privacy_mode_, | 1329 EXPECT_EQ(OK, request.Request(server1, advertised_versions_, privacy_mode_, |
1196 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1330 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1197 callback_.callback())); | 1331 callback_.callback())); |
1198 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 1332 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
1199 EXPECT_TRUE(stream.get()); | 1333 EXPECT_TRUE(stream.get()); |
1200 | 1334 |
1201 TestCompletionCallback callback; | 1335 TestCompletionCallback callback; |
1202 QuicStreamRequest request2(factory_.get()); | 1336 QuicStreamRequest request2(factory_.get()); |
1203 EXPECT_EQ(OK, request2.Request(server2, privacy_mode_, | 1337 EXPECT_EQ(OK, request2.Request(server2, advertised_versions_, privacy_mode_, |
1204 /*cert_verify_flags=*/0, url2_, "GET", | 1338 /*cert_verify_flags=*/0, url2_, "GET", |
1205 net_log_, callback_.callback())); | 1339 net_log_, callback_.callback())); |
1206 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 1340 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
1207 EXPECT_TRUE(stream2.get()); | 1341 EXPECT_TRUE(stream2.get()); |
1208 | 1342 |
1209 EXPECT_EQ(GetActiveSession(server1), GetActiveSession(server2)); | 1343 EXPECT_EQ(GetActiveSession(server1), GetActiveSession(server2)); |
1210 | 1344 |
1211 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 1345 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
1212 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 1346 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
1213 } | 1347 } |
(...skipping 15 matching lines...) Expand all Loading... | |
1229 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 1363 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
1230 verify_details.cert_verify_result.public_key_hashes.push_back( | 1364 verify_details.cert_verify_result.public_key_hashes.push_back( |
1231 test::GetTestHashValue(primary_pin)); | 1365 test::GetTestHashValue(primary_pin)); |
1232 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 1366 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
1233 | 1367 |
1234 host_resolver_.set_synchronous_mode(true); | 1368 host_resolver_.set_synchronous_mode(true); |
1235 host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", ""); | 1369 host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", ""); |
1236 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); | 1370 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); |
1237 | 1371 |
1238 QuicStreamRequest request(factory_.get()); | 1372 QuicStreamRequest request(factory_.get()); |
1239 EXPECT_EQ(OK, request.Request(server1, privacy_mode_, | 1373 EXPECT_EQ(OK, request.Request(server1, advertised_versions_, privacy_mode_, |
1240 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1374 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1241 callback_.callback())); | 1375 callback_.callback())); |
1242 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 1376 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
1243 EXPECT_TRUE(stream.get()); | 1377 EXPECT_TRUE(stream.get()); |
1244 | 1378 |
1245 TestCompletionCallback callback; | 1379 TestCompletionCallback callback; |
1246 QuicStreamRequest request2(factory_.get()); | 1380 QuicStreamRequest request2(factory_.get()); |
1247 EXPECT_EQ(OK, request2.Request(server2, privacy_mode_, | 1381 EXPECT_EQ(OK, request2.Request(server2, advertised_versions_, privacy_mode_, |
1248 /*cert_verify_flags=*/0, url2_, "GET", | 1382 /*cert_verify_flags=*/0, url2_, "GET", |
1249 net_log_, callback_.callback())); | 1383 net_log_, callback_.callback())); |
1250 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 1384 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
1251 EXPECT_TRUE(stream2.get()); | 1385 EXPECT_TRUE(stream2.get()); |
1252 | 1386 |
1253 EXPECT_EQ(GetActiveSession(server1), GetActiveSession(server2)); | 1387 EXPECT_EQ(GetActiveSession(server1), GetActiveSession(server2)); |
1254 | 1388 |
1255 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 1389 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
1256 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 1390 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
1257 } | 1391 } |
(...skipping 26 matching lines...) Expand all Loading... | |
1284 ProofVerifyDetailsChromium verify_details2 = DefaultProofVerifyDetails(); | 1418 ProofVerifyDetailsChromium verify_details2 = DefaultProofVerifyDetails(); |
1285 verify_details2.cert_verify_result.public_key_hashes.push_back( | 1419 verify_details2.cert_verify_result.public_key_hashes.push_back( |
1286 test::GetTestHashValue(primary_pin)); | 1420 test::GetTestHashValue(primary_pin)); |
1287 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details2); | 1421 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details2); |
1288 | 1422 |
1289 host_resolver_.set_synchronous_mode(true); | 1423 host_resolver_.set_synchronous_mode(true); |
1290 host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", ""); | 1424 host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", ""); |
1291 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); | 1425 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); |
1292 | 1426 |
1293 QuicStreamRequest request(factory_.get()); | 1427 QuicStreamRequest request(factory_.get()); |
1294 EXPECT_EQ(OK, request.Request(server1, privacy_mode_, | 1428 EXPECT_EQ(OK, request.Request(server1, advertised_versions_, privacy_mode_, |
1295 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1429 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1296 callback_.callback())); | 1430 callback_.callback())); |
1297 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 1431 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
1298 EXPECT_TRUE(stream.get()); | 1432 EXPECT_TRUE(stream.get()); |
1299 | 1433 |
1300 TestCompletionCallback callback; | 1434 TestCompletionCallback callback; |
1301 QuicStreamRequest request2(factory_.get()); | 1435 QuicStreamRequest request2(factory_.get()); |
1302 EXPECT_EQ(OK, request2.Request(server2, privacy_mode_, | 1436 EXPECT_EQ(OK, request2.Request(server2, advertised_versions_, privacy_mode_, |
1303 /*cert_verify_flags=*/0, url2_, "GET", | 1437 /*cert_verify_flags=*/0, url2_, "GET", |
1304 net_log_, callback_.callback())); | 1438 net_log_, callback_.callback())); |
1305 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 1439 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
1306 EXPECT_TRUE(stream2.get()); | 1440 EXPECT_TRUE(stream2.get()); |
1307 | 1441 |
1308 EXPECT_NE(GetActiveSession(server1), GetActiveSession(server2)); | 1442 EXPECT_NE(GetActiveSession(server1), GetActiveSession(server2)); |
1309 | 1443 |
1310 EXPECT_TRUE(socket_data1.AllReadDataConsumed()); | 1444 EXPECT_TRUE(socket_data1.AllReadDataConsumed()); |
1311 EXPECT_TRUE(socket_data1.AllWriteDataConsumed()); | 1445 EXPECT_TRUE(socket_data1.AllWriteDataConsumed()); |
1312 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); | 1446 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); |
1313 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); | 1447 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); |
1314 } | 1448 } |
1315 | 1449 |
1316 TEST_P(QuicStreamFactoryTest, Goaway) { | 1450 TEST_P(QuicStreamFactoryTest, Goaway) { |
1317 Initialize(); | 1451 Initialize(); |
1318 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 1452 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
1319 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 1453 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
1320 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 1454 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
1321 | 1455 |
1322 MockQuicData socket_data; | 1456 MockQuicData socket_data; |
1323 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 1457 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
1324 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 1458 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
1325 socket_data.AddSocketDataToFactory(&socket_factory_); | 1459 socket_data.AddSocketDataToFactory(&socket_factory_); |
1326 MockQuicData socket_data2; | 1460 MockQuicData socket_data2; |
1327 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 1461 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
1328 socket_data2.AddWrite(ConstructInitialSettingsPacket()); | 1462 socket_data2.AddWrite(ConstructInitialSettingsPacket()); |
1329 socket_data2.AddSocketDataToFactory(&socket_factory_); | 1463 socket_data2.AddSocketDataToFactory(&socket_factory_); |
1330 | 1464 |
1331 QuicStreamRequest request(factory_.get()); | 1465 QuicStreamRequest request(factory_.get()); |
1332 EXPECT_EQ(ERR_IO_PENDING, | 1466 EXPECT_EQ( |
1333 request.Request(host_port_pair_, privacy_mode_, | 1467 ERR_IO_PENDING, |
1334 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1468 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
1335 callback_.callback())); | 1469 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1470 callback_.callback())); | |
1336 | 1471 |
1337 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 1472 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
1338 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 1473 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
1339 EXPECT_TRUE(stream.get()); | 1474 EXPECT_TRUE(stream.get()); |
1340 | 1475 |
1341 // Mark the session as going away. Ensure that while it is still alive | 1476 // Mark the session as going away. Ensure that while it is still alive |
1342 // that it is no longer active. | 1477 // that it is no longer active. |
1343 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); | 1478 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); |
1344 factory_->OnSessionGoingAway(session); | 1479 factory_->OnSessionGoingAway(session); |
1345 EXPECT_EQ(true, | 1480 EXPECT_EQ(true, |
1346 QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session)); | 1481 QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session)); |
1347 EXPECT_FALSE(HasActiveSession(host_port_pair_)); | 1482 EXPECT_FALSE(HasActiveSession(host_port_pair_)); |
1348 | 1483 |
1349 // Create a new request for the same destination and verify that a | 1484 // Create a new request for the same destination and verify that a |
1350 // new session is created. | 1485 // new session is created. |
1351 QuicStreamRequest request2(factory_.get()); | 1486 QuicStreamRequest request2(factory_.get()); |
1352 EXPECT_EQ(ERR_IO_PENDING, | 1487 EXPECT_EQ( |
1353 request2.Request(host_port_pair_, privacy_mode_, | 1488 ERR_IO_PENDING, |
1354 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1489 request2.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
1355 callback_.callback())); | 1490 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1491 callback_.callback())); | |
1356 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 1492 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
1357 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 1493 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
1358 EXPECT_TRUE(stream2.get()); | 1494 EXPECT_TRUE(stream2.get()); |
1359 | 1495 |
1360 EXPECT_TRUE(HasActiveSession(host_port_pair_)); | 1496 EXPECT_TRUE(HasActiveSession(host_port_pair_)); |
1361 EXPECT_NE(session, GetActiveSession(host_port_pair_)); | 1497 EXPECT_NE(session, GetActiveSession(host_port_pair_)); |
1362 EXPECT_EQ(true, | 1498 EXPECT_EQ(true, |
1363 QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session)); | 1499 QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session)); |
1364 | 1500 |
1365 stream2.reset(); | 1501 stream2.reset(); |
(...skipping 19 matching lines...) Expand all Loading... | |
1385 server_maker_.MakeRstPacket(1, false, stream_id, QUIC_STREAM_CANCELLED)); | 1521 server_maker_.MakeRstPacket(1, false, stream_id, QUIC_STREAM_CANCELLED)); |
1386 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 1522 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
1387 socket_data.AddSocketDataToFactory(&socket_factory_); | 1523 socket_data.AddSocketDataToFactory(&socket_factory_); |
1388 | 1524 |
1389 HttpRequestInfo request_info; | 1525 HttpRequestInfo request_info; |
1390 std::vector<std::unique_ptr<HttpStream>> streams; | 1526 std::vector<std::unique_ptr<HttpStream>> streams; |
1391 // The MockCryptoClientStream sets max_open_streams to be | 1527 // The MockCryptoClientStream sets max_open_streams to be |
1392 // kDefaultMaxStreamsPerConnection / 2. | 1528 // kDefaultMaxStreamsPerConnection / 2. |
1393 for (size_t i = 0; i < kDefaultMaxStreamsPerConnection / 2; i++) { | 1529 for (size_t i = 0; i < kDefaultMaxStreamsPerConnection / 2; i++) { |
1394 QuicStreamRequest request(factory_.get()); | 1530 QuicStreamRequest request(factory_.get()); |
1395 int rv = request.Request(host_port_pair_, privacy_mode_, | 1531 int rv = request.Request( |
1396 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1532 host_port_pair_, advertised_versions_, privacy_mode_, |
1397 callback_.callback()); | 1533 /*cert_verify_flags=*/0, url_, "GET", net_log_, callback_.callback()); |
1398 if (i == 0) { | 1534 if (i == 0) { |
1399 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); | 1535 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
1400 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 1536 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
1401 } else { | 1537 } else { |
1402 EXPECT_THAT(rv, IsOk()); | 1538 EXPECT_THAT(rv, IsOk()); |
1403 } | 1539 } |
1404 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 1540 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
1405 EXPECT_TRUE(stream); | 1541 EXPECT_TRUE(stream); |
1406 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 1542 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
1407 net_log_, CompletionCallback())); | 1543 net_log_, CompletionCallback())); |
1408 streams.push_back(std::move(stream)); | 1544 streams.push_back(std::move(stream)); |
1409 } | 1545 } |
1410 | 1546 |
1411 QuicStreamRequest request(factory_.get()); | 1547 QuicStreamRequest request(factory_.get()); |
1412 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_, | 1548 EXPECT_EQ( |
1413 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1549 OK, request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
1414 CompletionCallback())); | 1550 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1551 CompletionCallback())); | |
1415 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 1552 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
1416 EXPECT_TRUE(stream); | 1553 EXPECT_TRUE(stream); |
1417 EXPECT_EQ(ERR_IO_PENDING, | 1554 EXPECT_EQ(ERR_IO_PENDING, |
1418 stream->InitializeStream(&request_info, DEFAULT_PRIORITY, net_log_, | 1555 stream->InitializeStream(&request_info, DEFAULT_PRIORITY, net_log_, |
1419 callback_.callback())); | 1556 callback_.callback())); |
1420 | 1557 |
1421 // Close the first stream. | 1558 // Close the first stream. |
1422 streams.front()->Close(false); | 1559 streams.front()->Close(false); |
1423 // Trigger exchange of RSTs that in turn allow progress for the last | 1560 // Trigger exchange of RSTs that in turn allow progress for the last |
1424 // stream. | 1561 // stream. |
(...skipping 11 matching lines...) Expand all Loading... | |
1436 } | 1573 } |
1437 | 1574 |
1438 TEST_P(QuicStreamFactoryTest, ResolutionErrorInCreate) { | 1575 TEST_P(QuicStreamFactoryTest, ResolutionErrorInCreate) { |
1439 Initialize(); | 1576 Initialize(); |
1440 MockQuicData socket_data; | 1577 MockQuicData socket_data; |
1441 socket_data.AddSocketDataToFactory(&socket_factory_); | 1578 socket_data.AddSocketDataToFactory(&socket_factory_); |
1442 | 1579 |
1443 host_resolver_.rules()->AddSimulatedFailure(kDefaultServerHostName); | 1580 host_resolver_.rules()->AddSimulatedFailure(kDefaultServerHostName); |
1444 | 1581 |
1445 QuicStreamRequest request(factory_.get()); | 1582 QuicStreamRequest request(factory_.get()); |
1446 EXPECT_EQ(ERR_IO_PENDING, | 1583 EXPECT_EQ( |
1447 request.Request(host_port_pair_, privacy_mode_, | 1584 ERR_IO_PENDING, |
1448 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1585 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
1449 callback_.callback())); | 1586 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1587 callback_.callback())); | |
1450 | 1588 |
1451 EXPECT_THAT(callback_.WaitForResult(), IsError(ERR_NAME_NOT_RESOLVED)); | 1589 EXPECT_THAT(callback_.WaitForResult(), IsError(ERR_NAME_NOT_RESOLVED)); |
1452 | 1590 |
1453 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 1591 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
1454 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 1592 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
1455 } | 1593 } |
1456 | 1594 |
1457 TEST_P(QuicStreamFactoryTest, ConnectErrorInCreate) { | 1595 TEST_P(QuicStreamFactoryTest, ConnectErrorInCreate) { |
1458 Initialize(); | 1596 Initialize(); |
1459 | 1597 |
1460 MockQuicData socket_data; | 1598 MockQuicData socket_data; |
1461 socket_data.AddConnect(SYNCHRONOUS, ERR_ADDRESS_IN_USE); | 1599 socket_data.AddConnect(SYNCHRONOUS, ERR_ADDRESS_IN_USE); |
1462 socket_data.AddSocketDataToFactory(&socket_factory_); | 1600 socket_data.AddSocketDataToFactory(&socket_factory_); |
1463 | 1601 |
1464 QuicStreamRequest request(factory_.get()); | 1602 QuicStreamRequest request(factory_.get()); |
1465 EXPECT_EQ(ERR_IO_PENDING, | 1603 EXPECT_EQ( |
1466 request.Request(host_port_pair_, privacy_mode_, | 1604 ERR_IO_PENDING, |
1467 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1605 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
1468 callback_.callback())); | 1606 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1607 callback_.callback())); | |
1469 | 1608 |
1470 EXPECT_THAT(callback_.WaitForResult(), IsError(ERR_ADDRESS_IN_USE)); | 1609 EXPECT_THAT(callback_.WaitForResult(), IsError(ERR_ADDRESS_IN_USE)); |
1471 | 1610 |
1472 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 1611 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
1473 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 1612 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
1474 } | 1613 } |
1475 | 1614 |
1476 TEST_P(QuicStreamFactoryTest, CancelCreate) { | 1615 TEST_P(QuicStreamFactoryTest, CancelCreate) { |
1477 Initialize(); | 1616 Initialize(); |
1478 MockQuicData socket_data; | 1617 MockQuicData socket_data; |
1479 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 1618 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
1480 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 1619 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
1481 socket_data.AddSocketDataToFactory(&socket_factory_); | 1620 socket_data.AddSocketDataToFactory(&socket_factory_); |
1482 { | 1621 { |
1483 QuicStreamRequest request(factory_.get()); | 1622 QuicStreamRequest request(factory_.get()); |
1484 EXPECT_EQ(ERR_IO_PENDING, | 1623 EXPECT_EQ( |
1485 request.Request(host_port_pair_, privacy_mode_, | 1624 ERR_IO_PENDING, |
1486 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1625 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
1487 callback_.callback())); | 1626 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1627 callback_.callback())); | |
1488 } | 1628 } |
1489 | 1629 |
1490 base::RunLoop().RunUntilIdle(); | 1630 base::RunLoop().RunUntilIdle(); |
1491 | 1631 |
1492 QuicStreamRequest request2(factory_.get()); | 1632 QuicStreamRequest request2(factory_.get()); |
1493 EXPECT_EQ(OK, request2.Request(host_port_pair_, privacy_mode_, | 1633 EXPECT_EQ( |
1494 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1634 OK, request2.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
1495 callback_.callback())); | 1635 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1636 callback_.callback())); | |
1496 std::unique_ptr<HttpStream> stream = request2.CreateStream(); | 1637 std::unique_ptr<HttpStream> stream = request2.CreateStream(); |
1497 | 1638 |
1498 EXPECT_TRUE(stream.get()); | 1639 EXPECT_TRUE(stream.get()); |
1499 stream.reset(); | 1640 stream.reset(); |
1500 | 1641 |
1501 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 1642 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
1502 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 1643 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
1503 } | 1644 } |
1504 | 1645 |
1505 TEST_P(QuicStreamFactoryTest, CloseAllSessions) { | 1646 TEST_P(QuicStreamFactoryTest, CloseAllSessions) { |
1506 Initialize(); | 1647 Initialize(); |
1507 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 1648 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
1508 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 1649 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
1509 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 1650 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
1510 | 1651 |
1511 MockQuicData socket_data; | 1652 MockQuicData socket_data; |
1512 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 1653 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
1513 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 1654 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
1514 socket_data.AddWrite(ConstructClientRstPacket(2)); | 1655 socket_data.AddWrite(ConstructClientRstPacket(2)); |
1515 socket_data.AddSocketDataToFactory(&socket_factory_); | 1656 socket_data.AddSocketDataToFactory(&socket_factory_); |
1516 | 1657 |
1517 MockQuicData socket_data2; | 1658 MockQuicData socket_data2; |
1518 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 1659 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
1519 socket_data2.AddWrite(ConstructInitialSettingsPacket()); | 1660 socket_data2.AddWrite(ConstructInitialSettingsPacket()); |
1520 socket_data2.AddSocketDataToFactory(&socket_factory_); | 1661 socket_data2.AddSocketDataToFactory(&socket_factory_); |
1521 | 1662 |
1522 QuicStreamRequest request(factory_.get()); | 1663 QuicStreamRequest request(factory_.get()); |
1523 EXPECT_EQ(ERR_IO_PENDING, | 1664 EXPECT_EQ( |
1524 request.Request(host_port_pair_, privacy_mode_, | 1665 ERR_IO_PENDING, |
1525 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1666 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
1526 callback_.callback())); | 1667 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1668 callback_.callback())); | |
1527 | 1669 |
1528 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 1670 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
1529 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 1671 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
1530 HttpRequestInfo request_info; | 1672 HttpRequestInfo request_info; |
1531 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 1673 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
1532 net_log_, CompletionCallback())); | 1674 net_log_, CompletionCallback())); |
1533 | 1675 |
1534 // Close the session and verify that stream saw the error. | 1676 // Close the session and verify that stream saw the error. |
1535 factory_->CloseAllSessions(ERR_INTERNET_DISCONNECTED, QUIC_INTERNAL_ERROR); | 1677 factory_->CloseAllSessions(ERR_INTERNET_DISCONNECTED, QUIC_INTERNAL_ERROR); |
1536 EXPECT_EQ(ERR_INTERNET_DISCONNECTED, | 1678 EXPECT_EQ(ERR_INTERNET_DISCONNECTED, |
1537 stream->ReadResponseHeaders(callback_.callback())); | 1679 stream->ReadResponseHeaders(callback_.callback())); |
1538 | 1680 |
1539 // Now attempting to request a stream to the same origin should create | 1681 // Now attempting to request a stream to the same origin should create |
1540 // a new session. | 1682 // a new session. |
1541 | 1683 |
1542 QuicStreamRequest request2(factory_.get()); | 1684 QuicStreamRequest request2(factory_.get()); |
1543 EXPECT_EQ(ERR_IO_PENDING, | 1685 EXPECT_EQ( |
1544 request2.Request(host_port_pair_, privacy_mode_, | 1686 ERR_IO_PENDING, |
1545 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1687 request2.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
1546 callback_.callback())); | 1688 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1689 callback_.callback())); | |
1547 | 1690 |
1548 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 1691 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
1549 stream = request2.CreateStream(); | 1692 stream = request2.CreateStream(); |
1550 stream.reset(); // Will reset stream 3. | 1693 stream.reset(); // Will reset stream 3. |
1551 | 1694 |
1552 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 1695 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
1553 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 1696 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
1554 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); | 1697 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); |
1555 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); | 1698 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); |
1556 } | 1699 } |
(...skipping 10 matching lines...) Expand all Loading... | |
1567 MockCryptoClientStream::USE_DEFAULT_CRYPTO_STREAM); | 1710 MockCryptoClientStream::USE_DEFAULT_CRYPTO_STREAM); |
1568 | 1711 |
1569 MockQuicData socket_data; | 1712 MockQuicData socket_data; |
1570 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 1713 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
1571 // Trigger PACKET_WRITE_ERROR when sending packets in crypto connect. | 1714 // Trigger PACKET_WRITE_ERROR when sending packets in crypto connect. |
1572 socket_data.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE); | 1715 socket_data.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE); |
1573 socket_data.AddSocketDataToFactory(&socket_factory_); | 1716 socket_data.AddSocketDataToFactory(&socket_factory_); |
1574 | 1717 |
1575 // Create request, should fail after the write of the CHLO fails. | 1718 // Create request, should fail after the write of the CHLO fails. |
1576 QuicStreamRequest request(factory_.get()); | 1719 QuicStreamRequest request(factory_.get()); |
1577 EXPECT_EQ(ERR_IO_PENDING, | 1720 EXPECT_EQ( |
1578 request.Request(host_port_pair_, privacy_mode_, | 1721 ERR_IO_PENDING, |
1579 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1722 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
1580 callback_.callback())); | 1723 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1724 callback_.callback())); | |
1581 EXPECT_EQ(ERR_QUIC_HANDSHAKE_FAILED, callback_.WaitForResult()); | 1725 EXPECT_EQ(ERR_QUIC_HANDSHAKE_FAILED, callback_.WaitForResult()); |
1582 EXPECT_FALSE(HasActiveSession(host_port_pair_)); | 1726 EXPECT_FALSE(HasActiveSession(host_port_pair_)); |
1583 EXPECT_FALSE(HasActiveJob(host_port_pair_, privacy_mode_)); | 1727 EXPECT_FALSE(HasActiveJob(host_port_pair_, privacy_mode_)); |
1584 | 1728 |
1585 // Verify new requests can be sent normally without hanging. | 1729 // Verify new requests can be sent normally without hanging. |
1586 crypto_client_stream_factory_.set_handshake_mode( | 1730 crypto_client_stream_factory_.set_handshake_mode( |
1587 MockCryptoClientStream::COLD_START); | 1731 MockCryptoClientStream::COLD_START); |
1588 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 1732 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
1589 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 1733 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
1590 MockQuicData socket_data2; | 1734 MockQuicData socket_data2; |
1591 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 1735 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
1592 socket_data2.AddWrite(ConstructInitialSettingsPacket()); | 1736 socket_data2.AddWrite(ConstructInitialSettingsPacket()); |
1593 socket_data2.AddSocketDataToFactory(&socket_factory_); | 1737 socket_data2.AddSocketDataToFactory(&socket_factory_); |
1594 | 1738 |
1595 QuicStreamRequest request2(factory_.get()); | 1739 QuicStreamRequest request2(factory_.get()); |
1596 EXPECT_EQ(ERR_IO_PENDING, | 1740 EXPECT_EQ( |
1597 request2.Request(host_port_pair_, privacy_mode_, | 1741 ERR_IO_PENDING, |
1598 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1742 request2.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
1599 callback_.callback())); | 1743 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1744 callback_.callback())); | |
1600 EXPECT_FALSE(HasActiveSession(host_port_pair_)); | 1745 EXPECT_FALSE(HasActiveSession(host_port_pair_)); |
1601 EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_)); | 1746 EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_)); |
1602 // Run the message loop to complete host resolution. | 1747 // Run the message loop to complete host resolution. |
1603 base::RunLoop().RunUntilIdle(); | 1748 base::RunLoop().RunUntilIdle(); |
1604 | 1749 |
1605 // Complete handshake. QuicStreamFactory::Job should complete and succeed. | 1750 // Complete handshake. QuicStreamFactory::Job should complete and succeed. |
1606 crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( | 1751 crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
1607 QuicSession::HANDSHAKE_CONFIRMED); | 1752 QuicSession::HANDSHAKE_CONFIRMED); |
1608 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 1753 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
1609 EXPECT_TRUE(HasActiveSession(host_port_pair_)); | 1754 EXPECT_TRUE(HasActiveSession(host_port_pair_)); |
(...skipping 19 matching lines...) Expand all Loading... | |
1629 "192.168.0.1", ""); | 1774 "192.168.0.1", ""); |
1630 | 1775 |
1631 MockQuicData socket_data; | 1776 MockQuicData socket_data; |
1632 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 1777 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
1633 // Trigger PACKET_WRITE_ERROR when sending packets in crypto connect. | 1778 // Trigger PACKET_WRITE_ERROR when sending packets in crypto connect. |
1634 socket_data.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE); | 1779 socket_data.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE); |
1635 socket_data.AddSocketDataToFactory(&socket_factory_); | 1780 socket_data.AddSocketDataToFactory(&socket_factory_); |
1636 | 1781 |
1637 // Create request, should fail immediately. | 1782 // Create request, should fail immediately. |
1638 QuicStreamRequest request(factory_.get()); | 1783 QuicStreamRequest request(factory_.get()); |
1639 EXPECT_EQ(ERR_QUIC_HANDSHAKE_FAILED, | 1784 EXPECT_EQ( |
1640 request.Request(host_port_pair_, privacy_mode_, | 1785 ERR_QUIC_HANDSHAKE_FAILED, |
1641 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1786 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
1642 callback_.callback())); | 1787 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1788 callback_.callback())); | |
1643 // Check no active session, or active jobs left for this server. | 1789 // Check no active session, or active jobs left for this server. |
1644 EXPECT_FALSE(HasActiveSession(host_port_pair_)); | 1790 EXPECT_FALSE(HasActiveSession(host_port_pair_)); |
1645 EXPECT_FALSE(HasActiveJob(host_port_pair_, privacy_mode_)); | 1791 EXPECT_FALSE(HasActiveJob(host_port_pair_, privacy_mode_)); |
1646 | 1792 |
1647 // Verify new requests can be sent normally without hanging. | 1793 // Verify new requests can be sent normally without hanging. |
1648 crypto_client_stream_factory_.set_handshake_mode( | 1794 crypto_client_stream_factory_.set_handshake_mode( |
1649 MockCryptoClientStream::COLD_START); | 1795 MockCryptoClientStream::COLD_START); |
1650 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 1796 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
1651 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 1797 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
1652 MockQuicData socket_data2; | 1798 MockQuicData socket_data2; |
1653 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 1799 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
1654 socket_data2.AddWrite(ConstructInitialSettingsPacket()); | 1800 socket_data2.AddWrite(ConstructInitialSettingsPacket()); |
1655 socket_data2.AddSocketDataToFactory(&socket_factory_); | 1801 socket_data2.AddSocketDataToFactory(&socket_factory_); |
1656 | 1802 |
1657 QuicStreamRequest request2(factory_.get()); | 1803 QuicStreamRequest request2(factory_.get()); |
1658 EXPECT_EQ(ERR_IO_PENDING, | 1804 EXPECT_EQ( |
1659 request2.Request(host_port_pair_, privacy_mode_, | 1805 ERR_IO_PENDING, |
1660 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1806 request2.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
1661 callback_.callback())); | 1807 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1808 callback_.callback())); | |
1662 EXPECT_FALSE(HasActiveSession(host_port_pair_)); | 1809 EXPECT_FALSE(HasActiveSession(host_port_pair_)); |
1663 EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_)); | 1810 EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_)); |
1664 | 1811 |
1665 // Complete handshake. | 1812 // Complete handshake. |
1666 crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( | 1813 crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
1667 QuicSession::HANDSHAKE_CONFIRMED); | 1814 QuicSession::HANDSHAKE_CONFIRMED); |
1668 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 1815 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
1669 EXPECT_TRUE(HasActiveSession(host_port_pair_)); | 1816 EXPECT_TRUE(HasActiveSession(host_port_pair_)); |
1670 EXPECT_FALSE(HasActiveJob(host_port_pair_, privacy_mode_)); | 1817 EXPECT_FALSE(HasActiveJob(host_port_pair_, privacy_mode_)); |
1671 | 1818 |
(...skipping 19 matching lines...) Expand all Loading... | |
1691 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 1838 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
1692 socket_data.AddWrite(ConstructClientRstPacket(2)); | 1839 socket_data.AddWrite(ConstructClientRstPacket(2)); |
1693 socket_data.AddSocketDataToFactory(&socket_factory_); | 1840 socket_data.AddSocketDataToFactory(&socket_factory_); |
1694 | 1841 |
1695 MockQuicData socket_data2; | 1842 MockQuicData socket_data2; |
1696 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 1843 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
1697 socket_data2.AddWrite(ConstructInitialSettingsPacket()); | 1844 socket_data2.AddWrite(ConstructInitialSettingsPacket()); |
1698 socket_data2.AddSocketDataToFactory(&socket_factory_); | 1845 socket_data2.AddSocketDataToFactory(&socket_factory_); |
1699 | 1846 |
1700 QuicStreamRequest request(factory_.get()); | 1847 QuicStreamRequest request(factory_.get()); |
1701 EXPECT_EQ(ERR_IO_PENDING, | 1848 EXPECT_EQ( |
1702 request.Request(host_port_pair_, privacy_mode_, | 1849 ERR_IO_PENDING, |
1703 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1850 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
1704 callback_.callback())); | 1851 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1852 callback_.callback())); | |
1705 | 1853 |
1706 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 1854 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
1707 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 1855 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
1708 HttpRequestInfo request_info; | 1856 HttpRequestInfo request_info; |
1709 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 1857 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
1710 net_log_, CompletionCallback())); | 1858 net_log_, CompletionCallback())); |
1711 | 1859 |
1712 // Change the IP address and verify that stream saw the error. | 1860 // Change the IP address and verify that stream saw the error. |
1713 NotifyIPAddressChanged(); | 1861 NotifyIPAddressChanged(); |
1714 EXPECT_EQ(ERR_NETWORK_CHANGED, | 1862 EXPECT_EQ(ERR_NETWORK_CHANGED, |
1715 stream->ReadResponseHeaders(callback_.callback())); | 1863 stream->ReadResponseHeaders(callback_.callback())); |
1716 EXPECT_TRUE(factory_->require_confirmation()); | 1864 EXPECT_TRUE(factory_->require_confirmation()); |
1717 | 1865 |
1718 // Now attempting to request a stream to the same origin should create | 1866 // Now attempting to request a stream to the same origin should create |
1719 // a new session. | 1867 // a new session. |
1720 | 1868 |
1721 QuicStreamRequest request2(factory_.get()); | 1869 QuicStreamRequest request2(factory_.get()); |
1722 EXPECT_EQ(ERR_IO_PENDING, | 1870 EXPECT_EQ( |
1723 request2.Request(host_port_pair_, privacy_mode_, | 1871 ERR_IO_PENDING, |
1724 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1872 request2.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
1725 callback_.callback())); | 1873 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1874 callback_.callback())); | |
1726 | 1875 |
1727 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 1876 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
1728 stream = request2.CreateStream(); | 1877 stream = request2.CreateStream(); |
1729 stream.reset(); // Will reset stream 3. | 1878 stream.reset(); // Will reset stream 3. |
1730 | 1879 |
1731 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 1880 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
1732 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 1881 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
1733 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); | 1882 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); |
1734 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); | 1883 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); |
1735 } | 1884 } |
(...skipping 23 matching lines...) Expand all Loading... | |
1759 packet_number++, GetNthClientInitiatedStreamId(0), true, true, | 1908 packet_number++, GetNthClientInitiatedStreamId(0), true, true, |
1760 &header_stream_offset)); | 1909 &header_stream_offset)); |
1761 if (async_write_before) { | 1910 if (async_write_before) { |
1762 socket_data.AddWrite(ASYNC, OK); | 1911 socket_data.AddWrite(ASYNC, OK); |
1763 packet_number++; | 1912 packet_number++; |
1764 } | 1913 } |
1765 socket_data.AddSocketDataToFactory(&socket_factory_); | 1914 socket_data.AddSocketDataToFactory(&socket_factory_); |
1766 | 1915 |
1767 // Create request and QuicHttpStream. | 1916 // Create request and QuicHttpStream. |
1768 QuicStreamRequest request(factory_.get()); | 1917 QuicStreamRequest request(factory_.get()); |
1769 EXPECT_EQ(ERR_IO_PENDING, | 1918 EXPECT_EQ( |
1770 request.Request(host_port_pair_, privacy_mode_, | 1919 ERR_IO_PENDING, |
1771 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1920 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
1772 callback_.callback())); | 1921 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1922 callback_.callback())); | |
1773 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 1923 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
1774 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 1924 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
1775 EXPECT_TRUE(stream.get()); | 1925 EXPECT_TRUE(stream.get()); |
1776 | 1926 |
1777 // Cause QUIC stream to be created. | 1927 // Cause QUIC stream to be created. |
1778 HttpRequestInfo request_info; | 1928 HttpRequestInfo request_info; |
1779 request_info.method = "GET"; | 1929 request_info.method = "GET"; |
1780 request_info.url = url_; | 1930 request_info.url = url_; |
1781 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 1931 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
1782 net_log_, CompletionCallback())); | 1932 net_log_, CompletionCallback())); |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1826 EXPECT_EQ(200, response.headers->response_code()); | 1976 EXPECT_EQ(200, response.headers->response_code()); |
1827 | 1977 |
1828 // Create a new request for the same destination and verify that a | 1978 // Create a new request for the same destination and verify that a |
1829 // new session is created. | 1979 // new session is created. |
1830 MockQuicData socket_data2; | 1980 MockQuicData socket_data2; |
1831 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 1981 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
1832 socket_data2.AddWrite(ConstructInitialSettingsPacket()); | 1982 socket_data2.AddWrite(ConstructInitialSettingsPacket()); |
1833 socket_data2.AddSocketDataToFactory(&socket_factory_); | 1983 socket_data2.AddSocketDataToFactory(&socket_factory_); |
1834 | 1984 |
1835 QuicStreamRequest request2(factory_.get()); | 1985 QuicStreamRequest request2(factory_.get()); |
1836 EXPECT_EQ(ERR_IO_PENDING, | 1986 EXPECT_EQ( |
1837 request2.Request(host_port_pair_, privacy_mode_, | 1987 ERR_IO_PENDING, |
1838 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1988 request2.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
1839 callback_.callback())); | 1989 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1990 callback_.callback())); | |
1840 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 1991 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
1841 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 1992 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
1842 EXPECT_TRUE(stream2.get()); | 1993 EXPECT_TRUE(stream2.get()); |
1843 | 1994 |
1844 EXPECT_TRUE(HasActiveSession(host_port_pair_)); | 1995 EXPECT_TRUE(HasActiveSession(host_port_pair_)); |
1845 QuicChromiumClientSession* new_session = GetActiveSession(host_port_pair_); | 1996 QuicChromiumClientSession* new_session = GetActiveSession(host_port_pair_); |
1846 EXPECT_NE(session, new_session); | 1997 EXPECT_NE(session, new_session); |
1847 | 1998 |
1848 // On a DISCONNECTED notification, nothing happens to the migrated | 1999 // On a DISCONNECTED notification, nothing happens to the migrated |
1849 // session, but the new session is closed since it has no open | 2000 // session, but the new session is closed since it has no open |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1889 packet_number++, GetNthClientInitiatedStreamId(0), true, true, | 2040 packet_number++, GetNthClientInitiatedStreamId(0), true, true, |
1890 &header_stream_offset)); | 2041 &header_stream_offset)); |
1891 if (async_write_before) { | 2042 if (async_write_before) { |
1892 socket_data.AddWrite(ASYNC, OK); | 2043 socket_data.AddWrite(ASYNC, OK); |
1893 packet_number++; | 2044 packet_number++; |
1894 } | 2045 } |
1895 socket_data.AddSocketDataToFactory(&socket_factory_); | 2046 socket_data.AddSocketDataToFactory(&socket_factory_); |
1896 | 2047 |
1897 // Create request and QuicHttpStream. | 2048 // Create request and QuicHttpStream. |
1898 QuicStreamRequest request(factory_.get()); | 2049 QuicStreamRequest request(factory_.get()); |
1899 EXPECT_EQ(ERR_IO_PENDING, | 2050 EXPECT_EQ( |
1900 request.Request(host_port_pair_, privacy_mode_, | 2051 ERR_IO_PENDING, |
1901 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2052 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
1902 callback_.callback())); | 2053 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2054 callback_.callback())); | |
1903 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 2055 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
1904 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 2056 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
1905 EXPECT_TRUE(stream.get()); | 2057 EXPECT_TRUE(stream.get()); |
1906 | 2058 |
1907 // Cause QUIC stream to be created. | 2059 // Cause QUIC stream to be created. |
1908 HttpRequestInfo request_info; | 2060 HttpRequestInfo request_info; |
1909 request_info.method = "GET"; | 2061 request_info.method = "GET"; |
1910 request_info.url = url_; | 2062 request_info.url = url_; |
1911 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 2063 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
1912 net_log_, CompletionCallback())); | 2064 net_log_, CompletionCallback())); |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1951 EXPECT_EQ(1u, session->GetNumActiveStreams()); | 2103 EXPECT_EQ(1u, session->GetNumActiveStreams()); |
1952 | 2104 |
1953 // Create a new request for the same destination and verify that a | 2105 // Create a new request for the same destination and verify that a |
1954 // new session is created. | 2106 // new session is created. |
1955 MockQuicData socket_data2; | 2107 MockQuicData socket_data2; |
1956 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 2108 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
1957 socket_data2.AddWrite(ConstructInitialSettingsPacket()); | 2109 socket_data2.AddWrite(ConstructInitialSettingsPacket()); |
1958 socket_data2.AddSocketDataToFactory(&socket_factory_); | 2110 socket_data2.AddSocketDataToFactory(&socket_factory_); |
1959 | 2111 |
1960 QuicStreamRequest request2(factory_.get()); | 2112 QuicStreamRequest request2(factory_.get()); |
1961 EXPECT_EQ(ERR_IO_PENDING, | 2113 EXPECT_EQ( |
1962 request2.Request(host_port_pair_, privacy_mode_, | 2114 ERR_IO_PENDING, |
1963 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2115 request2.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
1964 callback_.callback())); | 2116 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2117 callback_.callback())); | |
1965 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 2118 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
1966 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 2119 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
1967 EXPECT_TRUE(stream2.get()); | 2120 EXPECT_TRUE(stream2.get()); |
1968 | 2121 |
1969 EXPECT_TRUE(HasActiveSession(host_port_pair_)); | 2122 EXPECT_TRUE(HasActiveSession(host_port_pair_)); |
1970 EXPECT_NE(session, GetActiveSession(host_port_pair_)); | 2123 EXPECT_NE(session, GetActiveSession(host_port_pair_)); |
1971 EXPECT_EQ(true, | 2124 EXPECT_EQ(true, |
1972 QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session)); | 2125 QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session)); |
1973 | 2126 |
1974 stream.reset(); | 2127 stream.reset(); |
(...skipping 24 matching lines...) Expand all Loading... | |
1999 // Use the test task runner, to force the migration alarm timeout later. | 2152 // Use the test task runner, to force the migration alarm timeout later. |
2000 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), runner_.get()); | 2153 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), runner_.get()); |
2001 | 2154 |
2002 MockQuicData socket_data; | 2155 MockQuicData socket_data; |
2003 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 2156 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
2004 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 2157 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
2005 socket_data.AddSocketDataToFactory(&socket_factory_); | 2158 socket_data.AddSocketDataToFactory(&socket_factory_); |
2006 | 2159 |
2007 // Create request and QuicHttpStream. | 2160 // Create request and QuicHttpStream. |
2008 QuicStreamRequest request(factory_.get()); | 2161 QuicStreamRequest request(factory_.get()); |
2009 EXPECT_EQ(ERR_IO_PENDING, | 2162 EXPECT_EQ( |
2010 request.Request(host_port_pair_, privacy_mode_, | 2163 ERR_IO_PENDING, |
2011 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2164 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
2012 callback_.callback())); | 2165 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2166 callback_.callback())); | |
2013 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 2167 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
2014 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 2168 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
2015 EXPECT_TRUE(stream.get()); | 2169 EXPECT_TRUE(stream.get()); |
2016 | 2170 |
2017 // Cause QUIC stream to be created. | 2171 // Cause QUIC stream to be created. |
2018 HttpRequestInfo request_info; | 2172 HttpRequestInfo request_info; |
2019 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 2173 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
2020 net_log_, CompletionCallback())); | 2174 net_log_, CompletionCallback())); |
2021 | 2175 |
2022 // Ensure that session is alive and active. | 2176 // Ensure that session is alive and active. |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2057 | 2211 |
2058 MockQuicData socket_data; | 2212 MockQuicData socket_data; |
2059 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 2213 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
2060 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 2214 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
2061 socket_data.AddWrite(client_maker_.MakeRstPacket( | 2215 socket_data.AddWrite(client_maker_.MakeRstPacket( |
2062 2, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); | 2216 2, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); |
2063 socket_data.AddSocketDataToFactory(&socket_factory_); | 2217 socket_data.AddSocketDataToFactory(&socket_factory_); |
2064 | 2218 |
2065 // Create request and QuicHttpStream. | 2219 // Create request and QuicHttpStream. |
2066 QuicStreamRequest request(factory_.get()); | 2220 QuicStreamRequest request(factory_.get()); |
2067 EXPECT_EQ(ERR_IO_PENDING, | 2221 EXPECT_EQ( |
2068 request.Request(host_port_pair_, privacy_mode_, | 2222 ERR_IO_PENDING, |
2069 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2223 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
2070 callback_.callback())); | 2224 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2225 callback_.callback())); | |
2071 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 2226 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
2072 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 2227 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
2073 EXPECT_TRUE(stream.get()); | 2228 EXPECT_TRUE(stream.get()); |
2074 | 2229 |
2075 // Cause QUIC stream to be created, but marked as non-migratable. | 2230 // Cause QUIC stream to be created, but marked as non-migratable. |
2076 HttpRequestInfo request_info; | 2231 HttpRequestInfo request_info; |
2077 request_info.load_flags |= LOAD_DISABLE_CONNECTION_MIGRATION; | 2232 request_info.load_flags |= LOAD_DISABLE_CONNECTION_MIGRATION; |
2078 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 2233 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
2079 net_log_, CompletionCallback())); | 2234 net_log_, CompletionCallback())); |
2080 | 2235 |
(...skipping 25 matching lines...) Expand all Loading... | |
2106 | 2261 |
2107 MockQuicData socket_data; | 2262 MockQuicData socket_data; |
2108 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 2263 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
2109 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 2264 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
2110 socket_data.AddWrite(client_maker_.MakeRstPacket( | 2265 socket_data.AddWrite(client_maker_.MakeRstPacket( |
2111 2, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); | 2266 2, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); |
2112 socket_data.AddSocketDataToFactory(&socket_factory_); | 2267 socket_data.AddSocketDataToFactory(&socket_factory_); |
2113 | 2268 |
2114 // Create request and QuicHttpStream. | 2269 // Create request and QuicHttpStream. |
2115 QuicStreamRequest request(factory_.get()); | 2270 QuicStreamRequest request(factory_.get()); |
2116 EXPECT_EQ(ERR_IO_PENDING, | 2271 EXPECT_EQ( |
2117 request.Request(host_port_pair_, privacy_mode_, | 2272 ERR_IO_PENDING, |
2118 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2273 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
2119 callback_.callback())); | 2274 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2275 callback_.callback())); | |
2120 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 2276 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
2121 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 2277 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
2122 EXPECT_TRUE(stream.get()); | 2278 EXPECT_TRUE(stream.get()); |
2123 | 2279 |
2124 // Cause QUIC stream to be created. | 2280 // Cause QUIC stream to be created. |
2125 HttpRequestInfo request_info; | 2281 HttpRequestInfo request_info; |
2126 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 2282 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
2127 net_log_, CompletionCallback())); | 2283 net_log_, CompletionCallback())); |
2128 | 2284 |
2129 // Ensure that session is alive and active. | 2285 // Ensure that session is alive and active. |
(...skipping 28 matching lines...) Expand all Loading... | |
2158 | 2314 |
2159 MockQuicData socket_data; | 2315 MockQuicData socket_data; |
2160 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 2316 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
2161 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 2317 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
2162 socket_data.AddWrite(client_maker_.MakeRstPacket( | 2318 socket_data.AddWrite(client_maker_.MakeRstPacket( |
2163 2, true, GetNthClientInitiatedStreamId(0), QUIC_RST_ACKNOWLEDGEMENT)); | 2319 2, true, GetNthClientInitiatedStreamId(0), QUIC_RST_ACKNOWLEDGEMENT)); |
2164 socket_data.AddSocketDataToFactory(&socket_factory_); | 2320 socket_data.AddSocketDataToFactory(&socket_factory_); |
2165 | 2321 |
2166 // Create request and QuicHttpStream. | 2322 // Create request and QuicHttpStream. |
2167 QuicStreamRequest request(factory_.get()); | 2323 QuicStreamRequest request(factory_.get()); |
2168 EXPECT_EQ(ERR_IO_PENDING, | 2324 EXPECT_EQ( |
2169 request.Request(host_port_pair_, privacy_mode_, | 2325 ERR_IO_PENDING, |
2170 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2326 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
2171 callback_.callback())); | 2327 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2328 callback_.callback())); | |
2172 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 2329 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
2173 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 2330 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
2174 EXPECT_TRUE(stream.get()); | 2331 EXPECT_TRUE(stream.get()); |
2175 | 2332 |
2176 // Cause QUIC stream to be created, but marked as non-migratable. | 2333 // Cause QUIC stream to be created, but marked as non-migratable. |
2177 HttpRequestInfo request_info; | 2334 HttpRequestInfo request_info; |
2178 request_info.load_flags |= LOAD_DISABLE_CONNECTION_MIGRATION; | 2335 request_info.load_flags |= LOAD_DISABLE_CONNECTION_MIGRATION; |
2179 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 2336 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
2180 net_log_, CompletionCallback())); | 2337 net_log_, CompletionCallback())); |
2181 | 2338 |
(...skipping 24 matching lines...) Expand all Loading... | |
2206 | 2363 |
2207 MockQuicData socket_data; | 2364 MockQuicData socket_data; |
2208 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 2365 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
2209 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 2366 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
2210 socket_data.AddWrite(client_maker_.MakeRstPacket( | 2367 socket_data.AddWrite(client_maker_.MakeRstPacket( |
2211 2, true, GetNthClientInitiatedStreamId(0), QUIC_RST_ACKNOWLEDGEMENT)); | 2368 2, true, GetNthClientInitiatedStreamId(0), QUIC_RST_ACKNOWLEDGEMENT)); |
2212 socket_data.AddSocketDataToFactory(&socket_factory_); | 2369 socket_data.AddSocketDataToFactory(&socket_factory_); |
2213 | 2370 |
2214 // Create request and QuicHttpStream. | 2371 // Create request and QuicHttpStream. |
2215 QuicStreamRequest request(factory_.get()); | 2372 QuicStreamRequest request(factory_.get()); |
2216 EXPECT_EQ(ERR_IO_PENDING, | 2373 EXPECT_EQ( |
2217 request.Request(host_port_pair_, privacy_mode_, | 2374 ERR_IO_PENDING, |
2218 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2375 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
2219 callback_.callback())); | 2376 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2377 callback_.callback())); | |
2220 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 2378 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
2221 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 2379 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
2222 EXPECT_TRUE(stream.get()); | 2380 EXPECT_TRUE(stream.get()); |
2223 | 2381 |
2224 // Cause QUIC stream to be created. | 2382 // Cause QUIC stream to be created. |
2225 HttpRequestInfo request_info; | 2383 HttpRequestInfo request_info; |
2226 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 2384 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
2227 net_log_, CompletionCallback())); | 2385 net_log_, CompletionCallback())); |
2228 | 2386 |
2229 // Ensure that session is alive and active. | 2387 // Ensure that session is alive and active. |
(...skipping 24 matching lines...) Expand all Loading... | |
2254 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 2412 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
2255 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 2413 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
2256 | 2414 |
2257 MockQuicData socket_data; | 2415 MockQuicData socket_data; |
2258 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 2416 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
2259 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 2417 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
2260 socket_data.AddSocketDataToFactory(&socket_factory_); | 2418 socket_data.AddSocketDataToFactory(&socket_factory_); |
2261 | 2419 |
2262 // Create request and QuicHttpStream. | 2420 // Create request and QuicHttpStream. |
2263 QuicStreamRequest request(factory_.get()); | 2421 QuicStreamRequest request(factory_.get()); |
2264 EXPECT_EQ(ERR_IO_PENDING, | 2422 EXPECT_EQ( |
2265 request.Request(host_port_pair_, privacy_mode_, | 2423 ERR_IO_PENDING, |
2266 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2424 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
2267 callback_.callback())); | 2425 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2426 callback_.callback())); | |
2268 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 2427 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
2269 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 2428 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
2270 EXPECT_TRUE(stream.get()); | 2429 EXPECT_TRUE(stream.get()); |
2271 | 2430 |
2272 // Ensure that session is alive and active. | 2431 // Ensure that session is alive and active. |
2273 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); | 2432 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); |
2274 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session)); | 2433 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session)); |
2275 EXPECT_TRUE(HasActiveSession(host_port_pair_)); | 2434 EXPECT_TRUE(HasActiveSession(host_port_pair_)); |
2276 | 2435 |
2277 // Trigger connection migration. Since there are no active streams, | 2436 // Trigger connection migration. Since there are no active streams, |
(...skipping 14 matching lines...) Expand all Loading... | |
2292 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 2451 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
2293 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 2452 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
2294 | 2453 |
2295 MockQuicData socket_data; | 2454 MockQuicData socket_data; |
2296 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 2455 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
2297 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 2456 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
2298 socket_data.AddSocketDataToFactory(&socket_factory_); | 2457 socket_data.AddSocketDataToFactory(&socket_factory_); |
2299 | 2458 |
2300 // Create request and QuicHttpStream. | 2459 // Create request and QuicHttpStream. |
2301 QuicStreamRequest request(factory_.get()); | 2460 QuicStreamRequest request(factory_.get()); |
2302 EXPECT_EQ(ERR_IO_PENDING, | 2461 EXPECT_EQ( |
2303 request.Request(host_port_pair_, privacy_mode_, | 2462 ERR_IO_PENDING, |
2304 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2463 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
2305 callback_.callback())); | 2464 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2465 callback_.callback())); | |
2306 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 2466 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
2307 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 2467 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
2308 EXPECT_TRUE(stream.get()); | 2468 EXPECT_TRUE(stream.get()); |
2309 | 2469 |
2310 // Ensure that session is alive and active. | 2470 // Ensure that session is alive and active. |
2311 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); | 2471 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); |
2312 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session)); | 2472 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session)); |
2313 EXPECT_TRUE(HasActiveSession(host_port_pair_)); | 2473 EXPECT_TRUE(HasActiveSession(host_port_pair_)); |
2314 | 2474 |
2315 // Trigger connection migration. Since there are no active streams, | 2475 // Trigger connection migration. Since there are no active streams, |
(...skipping 18 matching lines...) Expand all Loading... | |
2334 QuicStreamOffset header_stream_offset = 0; | 2494 QuicStreamOffset header_stream_offset = 0; |
2335 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 2495 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
2336 socket_data.AddWrite( | 2496 socket_data.AddWrite( |
2337 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 2497 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
2338 socket_data.AddWrite(ConstructGetRequestPacket( | 2498 socket_data.AddWrite(ConstructGetRequestPacket( |
2339 2, GetNthClientInitiatedStreamId(0), true, true, &header_stream_offset)); | 2499 2, GetNthClientInitiatedStreamId(0), true, true, &header_stream_offset)); |
2340 socket_data.AddSocketDataToFactory(&socket_factory_); | 2500 socket_data.AddSocketDataToFactory(&socket_factory_); |
2341 | 2501 |
2342 // Create request and QuicHttpStream. | 2502 // Create request and QuicHttpStream. |
2343 QuicStreamRequest request(factory_.get()); | 2503 QuicStreamRequest request(factory_.get()); |
2344 EXPECT_EQ(ERR_IO_PENDING, | 2504 EXPECT_EQ( |
2345 request.Request(host_port_pair_, privacy_mode_, | 2505 ERR_IO_PENDING, |
2346 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2506 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
2347 callback_.callback())); | 2507 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2508 callback_.callback())); | |
2348 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 2509 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
2349 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 2510 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
2350 EXPECT_TRUE(stream.get()); | 2511 EXPECT_TRUE(stream.get()); |
2351 | 2512 |
2352 // Cause QUIC stream to be created. | 2513 // Cause QUIC stream to be created. |
2353 HttpRequestInfo request_info; | 2514 HttpRequestInfo request_info; |
2354 request_info.method = "GET"; | 2515 request_info.method = "GET"; |
2355 request_info.url = url_; | 2516 request_info.url = url_; |
2356 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 2517 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
2357 net_log_, CompletionCallback())); | 2518 net_log_, CompletionCallback())); |
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2410 // Response headers are received over the new network. | 2571 // Response headers are received over the new network. |
2411 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 2572 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
2412 EXPECT_EQ(200, response.headers->response_code()); | 2573 EXPECT_EQ(200, response.headers->response_code()); |
2413 | 2574 |
2414 // Create a new request and verify that a new session is created. | 2575 // Create a new request and verify that a new session is created. |
2415 MockQuicData socket_data2; | 2576 MockQuicData socket_data2; |
2416 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 2577 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
2417 socket_data2.AddWrite(ConstructInitialSettingsPacket()); | 2578 socket_data2.AddWrite(ConstructInitialSettingsPacket()); |
2418 socket_data2.AddSocketDataToFactory(&socket_factory_); | 2579 socket_data2.AddSocketDataToFactory(&socket_factory_); |
2419 QuicStreamRequest request2(factory_.get()); | 2580 QuicStreamRequest request2(factory_.get()); |
2420 EXPECT_EQ(ERR_IO_PENDING, | 2581 EXPECT_EQ( |
2421 request2.Request(host_port_pair_, privacy_mode_, | 2582 ERR_IO_PENDING, |
2422 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2583 request2.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
2423 callback_.callback())); | 2584 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2585 callback_.callback())); | |
2424 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 2586 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
2425 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 2587 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
2426 EXPECT_TRUE(stream2.get()); | 2588 EXPECT_TRUE(stream2.get()); |
2427 | 2589 |
2428 EXPECT_TRUE(HasActiveSession(host_port_pair_)); | 2590 EXPECT_TRUE(HasActiveSession(host_port_pair_)); |
2429 EXPECT_NE(session, GetActiveSession(host_port_pair_)); | 2591 EXPECT_NE(session, GetActiveSession(host_port_pair_)); |
2430 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session)); | 2592 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session)); |
2431 | 2593 |
2432 stream.reset(); | 2594 stream.reset(); |
2433 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 2595 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
(...skipping 25 matching lines...) Expand all Loading... | |
2459 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 2621 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
2460 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 2622 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
2461 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 2623 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
2462 | 2624 |
2463 host_resolver_.set_synchronous_mode(true); | 2625 host_resolver_.set_synchronous_mode(true); |
2464 host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", ""); | 2626 host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", ""); |
2465 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.2", ""); | 2627 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.2", ""); |
2466 | 2628 |
2467 // Create request and QuicHttpStream to create session1. | 2629 // Create request and QuicHttpStream to create session1. |
2468 QuicStreamRequest request1(factory_.get()); | 2630 QuicStreamRequest request1(factory_.get()); |
2469 EXPECT_EQ(OK, request1.Request(server1, privacy_mode_, | 2631 EXPECT_EQ(OK, request1.Request(server1, advertised_versions_, privacy_mode_, |
2470 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2632 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2471 callback_.callback())); | 2633 callback_.callback())); |
2472 std::unique_ptr<HttpStream> stream1 = request1.CreateStream(); | 2634 std::unique_ptr<HttpStream> stream1 = request1.CreateStream(); |
2473 EXPECT_TRUE(stream1.get()); | 2635 EXPECT_TRUE(stream1.get()); |
2474 | 2636 |
2475 // Create request and QuicHttpStream to create session2. | 2637 // Create request and QuicHttpStream to create session2. |
2476 QuicStreamRequest request2(factory_.get()); | 2638 QuicStreamRequest request2(factory_.get()); |
2477 EXPECT_EQ(OK, request2.Request(server2, privacy_mode_, | 2639 EXPECT_EQ(OK, request2.Request(server2, advertised_versions_, privacy_mode_, |
2478 /*cert_verify_flags=*/0, url2_, "GET", | 2640 /*cert_verify_flags=*/0, url2_, "GET", |
2479 net_log_, callback_.callback())); | 2641 net_log_, callback_.callback())); |
2480 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 2642 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
2481 EXPECT_TRUE(stream2.get()); | 2643 EXPECT_TRUE(stream2.get()); |
2482 | 2644 |
2483 QuicChromiumClientSession* session1 = GetActiveSession(server1); | 2645 QuicChromiumClientSession* session1 = GetActiveSession(server1); |
2484 QuicChromiumClientSession* session2 = GetActiveSession(server2); | 2646 QuicChromiumClientSession* session2 = GetActiveSession(server2); |
2485 EXPECT_NE(session1, session2); | 2647 EXPECT_NE(session1, session2); |
2486 | 2648 |
2487 // Cause QUIC stream to be created and send GET so session1 has an open | 2649 // Cause QUIC stream to be created and send GET so session1 has an open |
(...skipping 63 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2551 QuicStreamOffset header_stream_offset = 0; | 2713 QuicStreamOffset header_stream_offset = 0; |
2552 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 2714 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
2553 socket_data.AddWrite( | 2715 socket_data.AddWrite( |
2554 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 2716 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
2555 socket_data.AddWrite(ConstructGetRequestPacket( | 2717 socket_data.AddWrite(ConstructGetRequestPacket( |
2556 2, GetNthClientInitiatedStreamId(0), true, true, &header_stream_offset)); | 2718 2, GetNthClientInitiatedStreamId(0), true, true, &header_stream_offset)); |
2557 socket_data.AddSocketDataToFactory(&socket_factory_); | 2719 socket_data.AddSocketDataToFactory(&socket_factory_); |
2558 | 2720 |
2559 // Create request and QuicHttpStream. | 2721 // Create request and QuicHttpStream. |
2560 QuicStreamRequest request(factory_.get()); | 2722 QuicStreamRequest request(factory_.get()); |
2561 EXPECT_EQ(ERR_IO_PENDING, | 2723 EXPECT_EQ( |
2562 request.Request(host_port_pair_, privacy_mode_, | 2724 ERR_IO_PENDING, |
2563 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2725 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
2564 callback_.callback())); | 2726 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2727 callback_.callback())); | |
2565 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 2728 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
2566 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 2729 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
2567 EXPECT_TRUE(stream.get()); | 2730 EXPECT_TRUE(stream.get()); |
2568 | 2731 |
2569 // Cause QUIC stream to be created. | 2732 // Cause QUIC stream to be created. |
2570 HttpRequestInfo request_info; | 2733 HttpRequestInfo request_info; |
2571 request_info.method = "GET"; | 2734 request_info.method = "GET"; |
2572 request_info.url = url_; | 2735 request_info.url = url_; |
2573 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 2736 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
2574 net_log_, CompletionCallback())); | 2737 net_log_, CompletionCallback())); |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2615 EXPECT_EQ(200, response.headers->response_code()); | 2778 EXPECT_EQ(200, response.headers->response_code()); |
2616 | 2779 |
2617 // Create a new request for the same destination and verify that a | 2780 // Create a new request for the same destination and verify that a |
2618 // new session is created. | 2781 // new session is created. |
2619 MockQuicData socket_data2; | 2782 MockQuicData socket_data2; |
2620 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 2783 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
2621 socket_data2.AddWrite(ConstructInitialSettingsPacket()); | 2784 socket_data2.AddWrite(ConstructInitialSettingsPacket()); |
2622 socket_data2.AddSocketDataToFactory(&socket_factory_); | 2785 socket_data2.AddSocketDataToFactory(&socket_factory_); |
2623 | 2786 |
2624 QuicStreamRequest request2(factory_.get()); | 2787 QuicStreamRequest request2(factory_.get()); |
2625 EXPECT_EQ(ERR_IO_PENDING, | 2788 EXPECT_EQ( |
2626 request2.Request(host_port_pair_, privacy_mode_, | 2789 ERR_IO_PENDING, |
2627 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2790 request2.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
2628 callback_.callback())); | 2791 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2792 callback_.callback())); | |
2629 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 2793 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
2630 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 2794 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
2631 EXPECT_TRUE(stream2.get()); | 2795 EXPECT_TRUE(stream2.get()); |
2632 | 2796 |
2633 EXPECT_TRUE(HasActiveSession(host_port_pair_)); | 2797 EXPECT_TRUE(HasActiveSession(host_port_pair_)); |
2634 QuicChromiumClientSession* new_session = GetActiveSession(host_port_pair_); | 2798 QuicChromiumClientSession* new_session = GetActiveSession(host_port_pair_); |
2635 EXPECT_NE(session, new_session); | 2799 EXPECT_NE(session, new_session); |
2636 | 2800 |
2637 // On a NETWORK_MADE_DEFAULT notification, nothing happens to the | 2801 // On a NETWORK_MADE_DEFAULT notification, nothing happens to the |
2638 // migrated session, but the new session is closed since it has no | 2802 // migrated session, but the new session is closed since it has no |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2676 QuicStreamOffset header_stream_offset = 0; | 2840 QuicStreamOffset header_stream_offset = 0; |
2677 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 2841 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
2678 socket_data.AddWrite( | 2842 socket_data.AddWrite( |
2679 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 2843 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
2680 socket_data.AddWrite(ConstructGetRequestPacket( | 2844 socket_data.AddWrite(ConstructGetRequestPacket( |
2681 2, GetNthClientInitiatedStreamId(0), true, true, &header_stream_offset)); | 2845 2, GetNthClientInitiatedStreamId(0), true, true, &header_stream_offset)); |
2682 socket_data.AddSocketDataToFactory(&socket_factory_); | 2846 socket_data.AddSocketDataToFactory(&socket_factory_); |
2683 | 2847 |
2684 // Create request and QuicHttpStream. | 2848 // Create request and QuicHttpStream. |
2685 QuicStreamRequest request(factory_.get()); | 2849 QuicStreamRequest request(factory_.get()); |
2686 EXPECT_EQ(ERR_IO_PENDING, | 2850 EXPECT_EQ( |
2687 request.Request(host_port_pair_, privacy_mode_, | 2851 ERR_IO_PENDING, |
2688 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2852 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
2689 callback_.callback())); | 2853 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2854 callback_.callback())); | |
2690 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 2855 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
2691 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 2856 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
2692 EXPECT_TRUE(stream.get()); | 2857 EXPECT_TRUE(stream.get()); |
2693 | 2858 |
2694 // Cause QUIC stream to be created. | 2859 // Cause QUIC stream to be created. |
2695 HttpRequestInfo request_info; | 2860 HttpRequestInfo request_info; |
2696 request_info.method = "GET"; | 2861 request_info.method = "GET"; |
2697 request_info.url = url_; | 2862 request_info.url = url_; |
2698 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 2863 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
2699 net_log_, CompletionCallback())); | 2864 net_log_, CompletionCallback())); |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2742 EXPECT_EQ(200, response.headers->response_code()); | 2907 EXPECT_EQ(200, response.headers->response_code()); |
2743 | 2908 |
2744 // Create a new request for the same destination and verify that a | 2909 // Create a new request for the same destination and verify that a |
2745 // new session is created. | 2910 // new session is created. |
2746 MockQuicData socket_data2; | 2911 MockQuicData socket_data2; |
2747 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 2912 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
2748 socket_data2.AddWrite(ConstructInitialSettingsPacket()); | 2913 socket_data2.AddWrite(ConstructInitialSettingsPacket()); |
2749 socket_data2.AddSocketDataToFactory(&socket_factory_); | 2914 socket_data2.AddSocketDataToFactory(&socket_factory_); |
2750 | 2915 |
2751 QuicStreamRequest request2(factory_.get()); | 2916 QuicStreamRequest request2(factory_.get()); |
2752 EXPECT_EQ(ERR_IO_PENDING, | 2917 EXPECT_EQ( |
2753 request2.Request(host_port_pair_, privacy_mode_, | 2918 ERR_IO_PENDING, |
2754 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2919 request2.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
2755 callback_.callback())); | 2920 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2921 callback_.callback())); | |
2756 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 2922 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
2757 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 2923 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
2758 EXPECT_TRUE(stream2.get()); | 2924 EXPECT_TRUE(stream2.get()); |
2759 | 2925 |
2760 EXPECT_TRUE(HasActiveSession(host_port_pair_)); | 2926 EXPECT_TRUE(HasActiveSession(host_port_pair_)); |
2761 QuicChromiumClientSession* new_session = GetActiveSession(host_port_pair_); | 2927 QuicChromiumClientSession* new_session = GetActiveSession(host_port_pair_); |
2762 EXPECT_NE(session, new_session); | 2928 EXPECT_NE(session, new_session); |
2763 | 2929 |
2764 // On a NETWORK_MADE_DEFAULT notification, nothing happens to the | 2930 // On a NETWORK_MADE_DEFAULT notification, nothing happens to the |
2765 // migrated session, but the new session is closed since it has no | 2931 // migrated session, but the new session is closed since it has no |
(...skipping 29 matching lines...) Expand all Loading... | |
2795 | 2961 |
2796 MockQuicData socket_data; | 2962 MockQuicData socket_data; |
2797 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 2963 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
2798 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 2964 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
2799 socket_data.AddWrite(client_maker_.MakeRstPacket( | 2965 socket_data.AddWrite(client_maker_.MakeRstPacket( |
2800 2, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); | 2966 2, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); |
2801 socket_data.AddSocketDataToFactory(&socket_factory_); | 2967 socket_data.AddSocketDataToFactory(&socket_factory_); |
2802 | 2968 |
2803 // Create request and QuicHttpStream. | 2969 // Create request and QuicHttpStream. |
2804 QuicStreamRequest request(factory_.get()); | 2970 QuicStreamRequest request(factory_.get()); |
2805 EXPECT_EQ(ERR_IO_PENDING, | 2971 EXPECT_EQ( |
2806 request.Request(host_port_pair_, privacy_mode_, | 2972 ERR_IO_PENDING, |
2807 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2973 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
2808 callback_.callback())); | 2974 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2975 callback_.callback())); | |
2809 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 2976 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
2810 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 2977 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
2811 EXPECT_TRUE(stream.get()); | 2978 EXPECT_TRUE(stream.get()); |
2812 | 2979 |
2813 // Cause QUIC stream to be created. | 2980 // Cause QUIC stream to be created. |
2814 HttpRequestInfo request_info; | 2981 HttpRequestInfo request_info; |
2815 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 2982 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
2816 net_log_, CompletionCallback())); | 2983 net_log_, CompletionCallback())); |
2817 | 2984 |
2818 // Ensure that session is alive and active. | 2985 // Ensure that session is alive and active. |
(...skipping 28 matching lines...) Expand all Loading... | |
2847 | 3014 |
2848 MockQuicData socket_data; | 3015 MockQuicData socket_data; |
2849 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 3016 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
2850 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 3017 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
2851 socket_data.AddWrite(client_maker_.MakeRstPacket( | 3018 socket_data.AddWrite(client_maker_.MakeRstPacket( |
2852 2, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); | 3019 2, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); |
2853 socket_data.AddSocketDataToFactory(&socket_factory_); | 3020 socket_data.AddSocketDataToFactory(&socket_factory_); |
2854 | 3021 |
2855 // Create request and QuicHttpStream. | 3022 // Create request and QuicHttpStream. |
2856 QuicStreamRequest request(factory_.get()); | 3023 QuicStreamRequest request(factory_.get()); |
2857 EXPECT_EQ(ERR_IO_PENDING, | 3024 EXPECT_EQ( |
2858 request.Request(host_port_pair_, privacy_mode_, | 3025 ERR_IO_PENDING, |
2859 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 3026 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
2860 callback_.callback())); | 3027 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
3028 callback_.callback())); | |
2861 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 3029 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
2862 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 3030 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
2863 EXPECT_TRUE(stream.get()); | 3031 EXPECT_TRUE(stream.get()); |
2864 | 3032 |
2865 // Cause QUIC stream to be created, but marked as non-migratable. | 3033 // Cause QUIC stream to be created, but marked as non-migratable. |
2866 HttpRequestInfo request_info; | 3034 HttpRequestInfo request_info; |
2867 request_info.load_flags |= LOAD_DISABLE_CONNECTION_MIGRATION; | 3035 request_info.load_flags |= LOAD_DISABLE_CONNECTION_MIGRATION; |
2868 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 3036 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
2869 net_log_, CompletionCallback())); | 3037 net_log_, CompletionCallback())); |
2870 | 3038 |
(...skipping 28 matching lines...) Expand all Loading... | |
2899 | 3067 |
2900 MockQuicData socket_data; | 3068 MockQuicData socket_data; |
2901 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 3069 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
2902 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 3070 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
2903 socket_data.AddWrite(client_maker_.MakeRstPacket( | 3071 socket_data.AddWrite(client_maker_.MakeRstPacket( |
2904 2, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); | 3072 2, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); |
2905 socket_data.AddSocketDataToFactory(&socket_factory_); | 3073 socket_data.AddSocketDataToFactory(&socket_factory_); |
2906 | 3074 |
2907 // Create request and QuicHttpStream. | 3075 // Create request and QuicHttpStream. |
2908 QuicStreamRequest request(factory_.get()); | 3076 QuicStreamRequest request(factory_.get()); |
2909 EXPECT_EQ(ERR_IO_PENDING, | 3077 EXPECT_EQ( |
2910 request.Request(host_port_pair_, privacy_mode_, | 3078 ERR_IO_PENDING, |
2911 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 3079 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
2912 callback_.callback())); | 3080 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
3081 callback_.callback())); | |
2913 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 3082 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
2914 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 3083 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
2915 EXPECT_TRUE(stream.get()); | 3084 EXPECT_TRUE(stream.get()); |
2916 | 3085 |
2917 // Cause QUIC stream to be created. | 3086 // Cause QUIC stream to be created. |
2918 HttpRequestInfo request_info; | 3087 HttpRequestInfo request_info; |
2919 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 3088 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
2920 net_log_, CompletionCallback())); | 3089 net_log_, CompletionCallback())); |
2921 | 3090 |
2922 // Ensure that session is alive and active. | 3091 // Ensure that session is alive and active. |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2957 MockQuicData socket_data; | 3126 MockQuicData socket_data; |
2958 QuicStreamOffset header_stream_offset = 0; | 3127 QuicStreamOffset header_stream_offset = 0; |
2959 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 3128 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
2960 socket_data.AddWrite( | 3129 socket_data.AddWrite( |
2961 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 3130 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
2962 socket_data.AddWrite(write_error_mode, ERR_ADDRESS_UNREACHABLE); | 3131 socket_data.AddWrite(write_error_mode, ERR_ADDRESS_UNREACHABLE); |
2963 socket_data.AddSocketDataToFactory(&socket_factory_); | 3132 socket_data.AddSocketDataToFactory(&socket_factory_); |
2964 | 3133 |
2965 // Create request and QuicHttpStream. | 3134 // Create request and QuicHttpStream. |
2966 QuicStreamRequest request(factory_.get()); | 3135 QuicStreamRequest request(factory_.get()); |
2967 EXPECT_EQ(ERR_IO_PENDING, | 3136 EXPECT_EQ( |
2968 request.Request(host_port_pair_, privacy_mode_, | 3137 ERR_IO_PENDING, |
2969 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 3138 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
2970 callback_.callback())); | 3139 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
3140 callback_.callback())); | |
2971 EXPECT_EQ(OK, callback_.WaitForResult()); | 3141 EXPECT_EQ(OK, callback_.WaitForResult()); |
2972 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 3142 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
2973 EXPECT_TRUE(stream.get()); | 3143 EXPECT_TRUE(stream.get()); |
2974 | 3144 |
2975 // Cause QUIC stream to be created. | 3145 // Cause QUIC stream to be created. |
2976 HttpRequestInfo request_info; | 3146 HttpRequestInfo request_info; |
2977 request_info.method = "GET"; | 3147 request_info.method = "GET"; |
2978 request_info.url = GURL("https://www.example.org/"); | 3148 request_info.url = GURL("https://www.example.org/"); |
2979 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 3149 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
2980 net_log_, CompletionCallback())); | 3150 net_log_, CompletionCallback())); |
(...skipping 65 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3046 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), runner_.get()); | 3216 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), runner_.get()); |
3047 | 3217 |
3048 MockQuicData socket_data; | 3218 MockQuicData socket_data; |
3049 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 3219 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
3050 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 3220 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
3051 socket_data.AddWrite(write_error_mode, ERR_ADDRESS_UNREACHABLE); | 3221 socket_data.AddWrite(write_error_mode, ERR_ADDRESS_UNREACHABLE); |
3052 socket_data.AddSocketDataToFactory(&socket_factory_); | 3222 socket_data.AddSocketDataToFactory(&socket_factory_); |
3053 | 3223 |
3054 // Create request and QuicHttpStream. | 3224 // Create request and QuicHttpStream. |
3055 QuicStreamRequest request(factory_.get()); | 3225 QuicStreamRequest request(factory_.get()); |
3056 EXPECT_EQ(ERR_IO_PENDING, | 3226 EXPECT_EQ( |
3057 request.Request(host_port_pair_, privacy_mode_, | 3227 ERR_IO_PENDING, |
3058 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 3228 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
3059 callback_.callback())); | 3229 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
3230 callback_.callback())); | |
3060 EXPECT_EQ(OK, callback_.WaitForResult()); | 3231 EXPECT_EQ(OK, callback_.WaitForResult()); |
3061 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 3232 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
3062 EXPECT_TRUE(stream.get()); | 3233 EXPECT_TRUE(stream.get()); |
3063 | 3234 |
3064 // Cause QUIC stream to be created. | 3235 // Cause QUIC stream to be created. |
3065 HttpRequestInfo request_info; | 3236 HttpRequestInfo request_info; |
3066 request_info.method = "GET"; | 3237 request_info.method = "GET"; |
3067 request_info.url = GURL("https://www.example.org/"); | 3238 request_info.url = GURL("https://www.example.org/"); |
3068 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 3239 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
3069 net_log_, CompletionCallback())); | 3240 net_log_, CompletionCallback())); |
(...skipping 65 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3135 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 3306 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
3136 | 3307 |
3137 MockQuicData socket_data; | 3308 MockQuicData socket_data; |
3138 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 3309 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
3139 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 3310 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
3140 socket_data.AddWrite(write_error_mode, ERR_ADDRESS_UNREACHABLE); | 3311 socket_data.AddWrite(write_error_mode, ERR_ADDRESS_UNREACHABLE); |
3141 socket_data.AddSocketDataToFactory(&socket_factory_); | 3312 socket_data.AddSocketDataToFactory(&socket_factory_); |
3142 | 3313 |
3143 // Create request and QuicHttpStream. | 3314 // Create request and QuicHttpStream. |
3144 QuicStreamRequest request(factory_.get()); | 3315 QuicStreamRequest request(factory_.get()); |
3145 EXPECT_EQ(ERR_IO_PENDING, | 3316 EXPECT_EQ( |
3146 request.Request(host_port_pair_, privacy_mode_, | 3317 ERR_IO_PENDING, |
3147 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 3318 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
3148 callback_.callback())); | 3319 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
3320 callback_.callback())); | |
3149 EXPECT_EQ(OK, callback_.WaitForResult()); | 3321 EXPECT_EQ(OK, callback_.WaitForResult()); |
3150 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 3322 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
3151 EXPECT_TRUE(stream.get()); | 3323 EXPECT_TRUE(stream.get()); |
3152 | 3324 |
3153 // Cause QUIC stream to be created, but marked as non-migratable. | 3325 // Cause QUIC stream to be created, but marked as non-migratable. |
3154 HttpRequestInfo request_info; | 3326 HttpRequestInfo request_info; |
3155 request_info.load_flags |= LOAD_DISABLE_CONNECTION_MIGRATION; | 3327 request_info.load_flags |= LOAD_DISABLE_CONNECTION_MIGRATION; |
3156 request_info.method = "GET"; | 3328 request_info.method = "GET"; |
3157 request_info.url = GURL("https://www.example.org/"); | 3329 request_info.url = GURL("https://www.example.org/"); |
3158 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 3330 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3199 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 3371 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
3200 | 3372 |
3201 MockQuicData socket_data; | 3373 MockQuicData socket_data; |
3202 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 3374 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
3203 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 3375 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
3204 socket_data.AddWrite(write_error_mode, ERR_ADDRESS_UNREACHABLE); | 3376 socket_data.AddWrite(write_error_mode, ERR_ADDRESS_UNREACHABLE); |
3205 socket_data.AddSocketDataToFactory(&socket_factory_); | 3377 socket_data.AddSocketDataToFactory(&socket_factory_); |
3206 | 3378 |
3207 // Create request and QuicHttpStream. | 3379 // Create request and QuicHttpStream. |
3208 QuicStreamRequest request(factory_.get()); | 3380 QuicStreamRequest request(factory_.get()); |
3209 EXPECT_EQ(ERR_IO_PENDING, | 3381 EXPECT_EQ( |
3210 request.Request(host_port_pair_, privacy_mode_, | 3382 ERR_IO_PENDING, |
3211 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 3383 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
3212 callback_.callback())); | 3384 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
3385 callback_.callback())); | |
3213 EXPECT_EQ(OK, callback_.WaitForResult()); | 3386 EXPECT_EQ(OK, callback_.WaitForResult()); |
3214 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 3387 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
3215 EXPECT_TRUE(stream.get()); | 3388 EXPECT_TRUE(stream.get()); |
3216 | 3389 |
3217 // Cause QUIC stream to be created. | 3390 // Cause QUIC stream to be created. |
3218 HttpRequestInfo request_info; | 3391 HttpRequestInfo request_info; |
3219 request_info.method = "GET"; | 3392 request_info.method = "GET"; |
3220 request_info.url = GURL("https://www.example.org/"); | 3393 request_info.url = GURL("https://www.example.org/"); |
3221 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 3394 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
3222 net_log_, CompletionCallback())); | 3395 net_log_, CompletionCallback())); |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3278 } | 3451 } |
3279 socket_data[i].AddWrite( | 3452 socket_data[i].AddWrite( |
3280 (i % 2 == 0) ? first_write_error_mode : second_write_error_mode, | 3453 (i % 2 == 0) ? first_write_error_mode : second_write_error_mode, |
3281 ERR_FAILED); | 3454 ERR_FAILED); |
3282 } | 3455 } |
3283 socket_data[i].AddSocketDataToFactory(&socket_factory_); | 3456 socket_data[i].AddSocketDataToFactory(&socket_factory_); |
3284 } | 3457 } |
3285 | 3458 |
3286 // Create request and QuicHttpStream. | 3459 // Create request and QuicHttpStream. |
3287 QuicStreamRequest request(factory_.get()); | 3460 QuicStreamRequest request(factory_.get()); |
3288 EXPECT_EQ(ERR_IO_PENDING, | 3461 EXPECT_EQ( |
3289 request.Request(host_port_pair_, privacy_mode_, | 3462 ERR_IO_PENDING, |
3290 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 3463 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
3291 callback_.callback())); | 3464 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
3465 callback_.callback())); | |
3292 EXPECT_EQ(OK, callback_.WaitForResult()); | 3466 EXPECT_EQ(OK, callback_.WaitForResult()); |
3293 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 3467 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
3294 EXPECT_TRUE(stream.get()); | 3468 EXPECT_TRUE(stream.get()); |
3295 | 3469 |
3296 // Cause QUIC stream to be created. | 3470 // Cause QUIC stream to be created. |
3297 HttpRequestInfo request_info; | 3471 HttpRequestInfo request_info; |
3298 request_info.method = "GET"; | 3472 request_info.method = "GET"; |
3299 request_info.url = GURL("https://www.example.org/"); | 3473 request_info.url = GURL("https://www.example.org/"); |
3300 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 3474 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
3301 net_log_, CompletionCallback())); | 3475 net_log_, CompletionCallback())); |
(...skipping 56 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3358 MockQuicData socket_data; | 3532 MockQuicData socket_data; |
3359 QuicStreamOffset header_stream_offset = 0; | 3533 QuicStreamOffset header_stream_offset = 0; |
3360 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 3534 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
3361 socket_data.AddWrite( | 3535 socket_data.AddWrite( |
3362 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 3536 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
3363 socket_data.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE); | 3537 socket_data.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE); |
3364 socket_data.AddSocketDataToFactory(&socket_factory_); | 3538 socket_data.AddSocketDataToFactory(&socket_factory_); |
3365 | 3539 |
3366 // Create request and QuicHttpStream. | 3540 // Create request and QuicHttpStream. |
3367 QuicStreamRequest request(factory_.get()); | 3541 QuicStreamRequest request(factory_.get()); |
3368 EXPECT_EQ(ERR_IO_PENDING, | 3542 EXPECT_EQ( |
3369 request.Request(host_port_pair_, privacy_mode_, | 3543 ERR_IO_PENDING, |
3370 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 3544 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
3371 callback_.callback())); | 3545 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
3546 callback_.callback())); | |
3372 EXPECT_EQ(OK, callback_.WaitForResult()); | 3547 EXPECT_EQ(OK, callback_.WaitForResult()); |
3373 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 3548 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
3374 EXPECT_TRUE(stream.get()); | 3549 EXPECT_TRUE(stream.get()); |
3375 | 3550 |
3376 // Cause QUIC stream to be created. | 3551 // Cause QUIC stream to be created. |
3377 HttpRequestInfo request_info; | 3552 HttpRequestInfo request_info; |
3378 request_info.method = "GET"; | 3553 request_info.method = "GET"; |
3379 request_info.url = GURL("https://www.example.org/"); | 3554 request_info.url = GURL("https://www.example.org/"); |
3380 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 3555 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
3381 net_log_, CompletionCallback())); | 3556 net_log_, CompletionCallback())); |
(...skipping 74 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3456 MockQuicData socket_data; | 3631 MockQuicData socket_data; |
3457 QuicStreamOffset header_stream_offset = 0; | 3632 QuicStreamOffset header_stream_offset = 0; |
3458 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 3633 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
3459 socket_data.AddWrite( | 3634 socket_data.AddWrite( |
3460 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 3635 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
3461 socket_data.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE); | 3636 socket_data.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE); |
3462 socket_data.AddSocketDataToFactory(&socket_factory_); | 3637 socket_data.AddSocketDataToFactory(&socket_factory_); |
3463 | 3638 |
3464 // Create request and QuicHttpStream. | 3639 // Create request and QuicHttpStream. |
3465 QuicStreamRequest request(factory_.get()); | 3640 QuicStreamRequest request(factory_.get()); |
3466 EXPECT_EQ(ERR_IO_PENDING, | 3641 EXPECT_EQ( |
3467 request.Request(host_port_pair_, privacy_mode_, | 3642 ERR_IO_PENDING, |
3468 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 3643 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
3469 callback_.callback())); | 3644 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
3645 callback_.callback())); | |
3470 EXPECT_EQ(OK, callback_.WaitForResult()); | 3646 EXPECT_EQ(OK, callback_.WaitForResult()); |
3471 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 3647 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
3472 EXPECT_TRUE(stream.get()); | 3648 EXPECT_TRUE(stream.get()); |
3473 | 3649 |
3474 // Cause QUIC stream to be created. | 3650 // Cause QUIC stream to be created. |
3475 HttpRequestInfo request_info; | 3651 HttpRequestInfo request_info; |
3476 request_info.method = "GET"; | 3652 request_info.method = "GET"; |
3477 request_info.url = GURL("https://www.example.org/"); | 3653 request_info.url = GURL("https://www.example.org/"); |
3478 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 3654 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
3479 net_log_, CompletionCallback())); | 3655 net_log_, CompletionCallback())); |
(...skipping 75 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3555 MockQuicData socket_data; | 3731 MockQuicData socket_data; |
3556 QuicStreamOffset header_stream_offset = 0; | 3732 QuicStreamOffset header_stream_offset = 0; |
3557 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 3733 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
3558 socket_data.AddWrite( | 3734 socket_data.AddWrite( |
3559 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 3735 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
3560 socket_data.AddWrite(SYNCHRONOUS, ERR_FAILED); | 3736 socket_data.AddWrite(SYNCHRONOUS, ERR_FAILED); |
3561 socket_data.AddSocketDataToFactory(&socket_factory_); | 3737 socket_data.AddSocketDataToFactory(&socket_factory_); |
3562 | 3738 |
3563 // Create request and QuicHttpStream. | 3739 // Create request and QuicHttpStream. |
3564 QuicStreamRequest request(factory_.get()); | 3740 QuicStreamRequest request(factory_.get()); |
3565 EXPECT_EQ(ERR_IO_PENDING, | 3741 EXPECT_EQ( |
3566 request.Request(host_port_pair_, privacy_mode_, | 3742 ERR_IO_PENDING, |
3567 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 3743 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
3568 callback_.callback())); | 3744 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
3745 callback_.callback())); | |
3569 EXPECT_EQ(OK, callback_.WaitForResult()); | 3746 EXPECT_EQ(OK, callback_.WaitForResult()); |
3570 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 3747 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
3571 EXPECT_TRUE(stream.get()); | 3748 EXPECT_TRUE(stream.get()); |
3572 | 3749 |
3573 // Cause QUIC stream to be created. | 3750 // Cause QUIC stream to be created. |
3574 HttpRequestInfo request_info; | 3751 HttpRequestInfo request_info; |
3575 request_info.method = "GET"; | 3752 request_info.method = "GET"; |
3576 request_info.url = GURL("https://www.example.org/"); | 3753 request_info.url = GURL("https://www.example.org/"); |
3577 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 3754 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
3578 net_log_, CompletionCallback())); | 3755 net_log_, CompletionCallback())); |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3636 EXPECT_EQ(200, response.headers->response_code()); | 3813 EXPECT_EQ(200, response.headers->response_code()); |
3637 | 3814 |
3638 // Create a new request for the same destination and verify that a | 3815 // Create a new request for the same destination and verify that a |
3639 // new session is created. | 3816 // new session is created. |
3640 MockQuicData socket_data2; | 3817 MockQuicData socket_data2; |
3641 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 3818 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
3642 socket_data2.AddWrite(ConstructInitialSettingsPacket()); | 3819 socket_data2.AddWrite(ConstructInitialSettingsPacket()); |
3643 socket_data2.AddSocketDataToFactory(&socket_factory_); | 3820 socket_data2.AddSocketDataToFactory(&socket_factory_); |
3644 | 3821 |
3645 QuicStreamRequest request2(factory_.get()); | 3822 QuicStreamRequest request2(factory_.get()); |
3646 EXPECT_EQ(ERR_IO_PENDING, | 3823 EXPECT_EQ( |
3647 request2.Request(host_port_pair_, privacy_mode_, | 3824 ERR_IO_PENDING, |
3648 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 3825 request2.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
3649 callback_.callback())); | 3826 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
3827 callback_.callback())); | |
3650 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 3828 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
3651 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 3829 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
3652 EXPECT_TRUE(stream2.get()); | 3830 EXPECT_TRUE(stream2.get()); |
3653 | 3831 |
3654 EXPECT_TRUE(HasActiveSession(host_port_pair_)); | 3832 EXPECT_TRUE(HasActiveSession(host_port_pair_)); |
3655 QuicChromiumClientSession* new_session = GetActiveSession(host_port_pair_); | 3833 QuicChromiumClientSession* new_session = GetActiveSession(host_port_pair_); |
3656 EXPECT_NE(session, new_session); | 3834 EXPECT_NE(session, new_session); |
3657 | 3835 |
3658 stream.reset(); | 3836 stream.reset(); |
3659 stream2.reset(); | 3837 stream2.reset(); |
(...skipping 28 matching lines...) Expand all Loading... | |
3688 MockQuicData socket_data; | 3866 MockQuicData socket_data; |
3689 QuicStreamOffset header_stream_offset = 0; | 3867 QuicStreamOffset header_stream_offset = 0; |
3690 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 3868 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
3691 socket_data.AddWrite( | 3869 socket_data.AddWrite( |
3692 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 3870 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
3693 socket_data.AddWrite(SYNCHRONOUS, ERR_FAILED); | 3871 socket_data.AddWrite(SYNCHRONOUS, ERR_FAILED); |
3694 socket_data.AddSocketDataToFactory(&socket_factory_); | 3872 socket_data.AddSocketDataToFactory(&socket_factory_); |
3695 | 3873 |
3696 // Create request and QuicHttpStream. | 3874 // Create request and QuicHttpStream. |
3697 QuicStreamRequest request(factory_.get()); | 3875 QuicStreamRequest request(factory_.get()); |
3698 EXPECT_EQ(ERR_IO_PENDING, | 3876 EXPECT_EQ( |
3699 request.Request(host_port_pair_, privacy_mode_, | 3877 ERR_IO_PENDING, |
3700 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 3878 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
3701 callback_.callback())); | 3879 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
3880 callback_.callback())); | |
3702 EXPECT_EQ(OK, callback_.WaitForResult()); | 3881 EXPECT_EQ(OK, callback_.WaitForResult()); |
3703 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 3882 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
3704 EXPECT_TRUE(stream.get()); | 3883 EXPECT_TRUE(stream.get()); |
3705 | 3884 |
3706 // Cause QUIC stream to be created. | 3885 // Cause QUIC stream to be created. |
3707 HttpRequestInfo request_info; | 3886 HttpRequestInfo request_info; |
3708 request_info.method = "GET"; | 3887 request_info.method = "GET"; |
3709 request_info.url = GURL("https://www.example.org/"); | 3888 request_info.url = GURL("https://www.example.org/"); |
3710 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 3889 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
3711 net_log_, CompletionCallback())); | 3890 net_log_, CompletionCallback())); |
(...skipping 65 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3777 ->NotifyNetworkConnected(kNewNetworkForTests); | 3956 ->NotifyNetworkConnected(kNewNetworkForTests); |
3778 | 3957 |
3779 // Create a new request for the same destination and verify that a | 3958 // Create a new request for the same destination and verify that a |
3780 // new session is created. | 3959 // new session is created. |
3781 MockQuicData socket_data2; | 3960 MockQuicData socket_data2; |
3782 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 3961 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
3783 socket_data2.AddWrite(ConstructInitialSettingsPacket()); | 3962 socket_data2.AddWrite(ConstructInitialSettingsPacket()); |
3784 socket_data2.AddSocketDataToFactory(&socket_factory_); | 3963 socket_data2.AddSocketDataToFactory(&socket_factory_); |
3785 | 3964 |
3786 QuicStreamRequest request2(factory_.get()); | 3965 QuicStreamRequest request2(factory_.get()); |
3787 EXPECT_EQ(ERR_IO_PENDING, | 3966 EXPECT_EQ( |
3788 request2.Request(host_port_pair_, privacy_mode_, | 3967 ERR_IO_PENDING, |
3789 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 3968 request2.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
3790 callback_.callback())); | 3969 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
3970 callback_.callback())); | |
3791 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 3971 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
3792 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 3972 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
3793 EXPECT_TRUE(stream2.get()); | 3973 EXPECT_TRUE(stream2.get()); |
3794 | 3974 |
3795 EXPECT_TRUE(HasActiveSession(host_port_pair_)); | 3975 EXPECT_TRUE(HasActiveSession(host_port_pair_)); |
3796 QuicChromiumClientSession* new_session = GetActiveSession(host_port_pair_); | 3976 QuicChromiumClientSession* new_session = GetActiveSession(host_port_pair_); |
3797 EXPECT_NE(session, new_session); | 3977 EXPECT_NE(session, new_session); |
3798 | 3978 |
3799 stream.reset(); | 3979 stream.reset(); |
3800 stream2.reset(); | 3980 stream2.reset(); |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3842 QuicStreamOffset header_stream_offset = 0; | 4022 QuicStreamOffset header_stream_offset = 0; |
3843 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 4023 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
3844 socket_data.AddWrite( | 4024 socket_data.AddWrite( |
3845 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 4025 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
3846 socket_data.AddWrite(ConstructGetRequestPacket( | 4026 socket_data.AddWrite(ConstructGetRequestPacket( |
3847 2, GetNthClientInitiatedStreamId(0), true, true, &header_stream_offset)); | 4027 2, GetNthClientInitiatedStreamId(0), true, true, &header_stream_offset)); |
3848 socket_data.AddSocketDataToFactory(&socket_factory_); | 4028 socket_data.AddSocketDataToFactory(&socket_factory_); |
3849 | 4029 |
3850 // Create request and QuicHttpStream. | 4030 // Create request and QuicHttpStream. |
3851 QuicStreamRequest request(factory_.get()); | 4031 QuicStreamRequest request(factory_.get()); |
3852 EXPECT_EQ(ERR_IO_PENDING, | 4032 EXPECT_EQ( |
3853 request.Request(host_port_pair_, privacy_mode_, | 4033 ERR_IO_PENDING, |
3854 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4034 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
3855 callback_.callback())); | 4035 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4036 callback_.callback())); | |
3856 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 4037 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
3857 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 4038 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
3858 EXPECT_TRUE(stream.get()); | 4039 EXPECT_TRUE(stream.get()); |
3859 | 4040 |
3860 // Cause QUIC stream to be created. | 4041 // Cause QUIC stream to be created. |
3861 HttpRequestInfo request_info; | 4042 HttpRequestInfo request_info; |
3862 request_info.method = "GET"; | 4043 request_info.method = "GET"; |
3863 request_info.url = url_; | 4044 request_info.url = url_; |
3864 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 4045 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
3865 net_log_, CompletionCallback())); | 4046 net_log_, CompletionCallback())); |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3905 QuicStreamOffset header_stream_offset = 0; | 4086 QuicStreamOffset header_stream_offset = 0; |
3906 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 4087 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
3907 socket_data1.AddWrite( | 4088 socket_data1.AddWrite( |
3908 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 4089 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
3909 socket_data1.AddWrite(ConstructGetRequestPacket( | 4090 socket_data1.AddWrite(ConstructGetRequestPacket( |
3910 2, GetNthClientInitiatedStreamId(0), true, true, &header_stream_offset)); | 4091 2, GetNthClientInitiatedStreamId(0), true, true, &header_stream_offset)); |
3911 socket_data1.AddSocketDataToFactory(&socket_factory_); | 4092 socket_data1.AddSocketDataToFactory(&socket_factory_); |
3912 | 4093 |
3913 // Create request and QuicHttpStream. | 4094 // Create request and QuicHttpStream. |
3914 QuicStreamRequest request(factory_.get()); | 4095 QuicStreamRequest request(factory_.get()); |
3915 EXPECT_EQ(ERR_IO_PENDING, | 4096 EXPECT_EQ( |
3916 request.Request(host_port_pair_, privacy_mode_, | 4097 ERR_IO_PENDING, |
3917 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4098 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
3918 callback_.callback())); | 4099 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4100 callback_.callback())); | |
3919 EXPECT_EQ(OK, callback_.WaitForResult()); | 4101 EXPECT_EQ(OK, callback_.WaitForResult()); |
3920 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 4102 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
3921 EXPECT_TRUE(stream.get()); | 4103 EXPECT_TRUE(stream.get()); |
3922 | 4104 |
3923 // Cause QUIC stream to be created. | 4105 // Cause QUIC stream to be created. |
3924 HttpRequestInfo request_info; | 4106 HttpRequestInfo request_info; |
3925 request_info.method = "GET"; | 4107 request_info.method = "GET"; |
3926 request_info.url = GURL("https://www.example.org/"); | 4108 request_info.url = GURL("https://www.example.org/"); |
3927 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 4109 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
3928 net_log_, CompletionCallback())); | 4110 net_log_, CompletionCallback())); |
(...skipping 118 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
4047 // Set up only socket data provider. | 4229 // Set up only socket data provider. |
4048 MockQuicData socket_data1; | 4230 MockQuicData socket_data1; |
4049 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 4231 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
4050 socket_data1.AddWrite(ConstructInitialSettingsPacket()); | 4232 socket_data1.AddWrite(ConstructInitialSettingsPacket()); |
4051 socket_data1.AddWrite(client_maker_.MakeRstPacket( | 4233 socket_data1.AddWrite(client_maker_.MakeRstPacket( |
4052 2, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); | 4234 2, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); |
4053 socket_data1.AddSocketDataToFactory(&socket_factory_); | 4235 socket_data1.AddSocketDataToFactory(&socket_factory_); |
4054 | 4236 |
4055 // Create request and QuicHttpStream. | 4237 // Create request and QuicHttpStream. |
4056 QuicStreamRequest request(factory_.get()); | 4238 QuicStreamRequest request(factory_.get()); |
4057 EXPECT_EQ(ERR_IO_PENDING, | 4239 EXPECT_EQ( |
4058 request.Request(host_port_pair_, privacy_mode_, | 4240 ERR_IO_PENDING, |
4059 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4241 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
4060 callback_.callback())); | 4242 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4243 callback_.callback())); | |
4061 EXPECT_EQ(OK, callback_.WaitForResult()); | 4244 EXPECT_EQ(OK, callback_.WaitForResult()); |
4062 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 4245 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
4063 EXPECT_TRUE(stream.get()); | 4246 EXPECT_TRUE(stream.get()); |
4064 | 4247 |
4065 // Cause QUIC stream to be created. | 4248 // Cause QUIC stream to be created. |
4066 HttpRequestInfo request_info; | 4249 HttpRequestInfo request_info; |
4067 request_info.method = "GET"; | 4250 request_info.method = "GET"; |
4068 request_info.url = GURL("https://www.example.org/"); | 4251 request_info.url = GURL("https://www.example.org/"); |
4069 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 4252 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
4070 net_log_, CompletionCallback())); | 4253 net_log_, CompletionCallback())); |
(...skipping 30 matching lines...) Expand all Loading... | |
4101 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 4284 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
4102 socket_data.AddWrite(ConstructClientRstPacket(2)); | 4285 socket_data.AddWrite(ConstructClientRstPacket(2)); |
4103 socket_data.AddSocketDataToFactory(&socket_factory_); | 4286 socket_data.AddSocketDataToFactory(&socket_factory_); |
4104 | 4287 |
4105 MockQuicData socket_data2; | 4288 MockQuicData socket_data2; |
4106 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 4289 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
4107 socket_data2.AddWrite(ConstructInitialSettingsPacket(1, nullptr)); | 4290 socket_data2.AddWrite(ConstructInitialSettingsPacket(1, nullptr)); |
4108 socket_data2.AddSocketDataToFactory(&socket_factory_); | 4291 socket_data2.AddSocketDataToFactory(&socket_factory_); |
4109 | 4292 |
4110 QuicStreamRequest request(factory_.get()); | 4293 QuicStreamRequest request(factory_.get()); |
4111 EXPECT_EQ(ERR_IO_PENDING, | 4294 EXPECT_EQ( |
4112 request.Request(host_port_pair_, privacy_mode_, | 4295 ERR_IO_PENDING, |
4113 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4296 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
4114 callback_.callback())); | 4297 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4298 callback_.callback())); | |
4115 | 4299 |
4116 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 4300 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
4117 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 4301 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
4118 HttpRequestInfo request_info; | 4302 HttpRequestInfo request_info; |
4119 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 4303 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
4120 net_log_, CompletionCallback())); | 4304 net_log_, CompletionCallback())); |
4121 | 4305 |
4122 ssl_config_service_->NotifySSLConfigChange(); | 4306 ssl_config_service_->NotifySSLConfigChange(); |
4123 EXPECT_EQ(ERR_CERT_DATABASE_CHANGED, | 4307 EXPECT_EQ(ERR_CERT_DATABASE_CHANGED, |
4124 stream->ReadResponseHeaders(callback_.callback())); | 4308 stream->ReadResponseHeaders(callback_.callback())); |
4125 EXPECT_FALSE(factory_->require_confirmation()); | 4309 EXPECT_FALSE(factory_->require_confirmation()); |
4126 | 4310 |
4127 // Now attempting to request a stream to the same origin should create | 4311 // Now attempting to request a stream to the same origin should create |
4128 // a new session. | 4312 // a new session. |
4129 | 4313 |
4130 QuicStreamRequest request2(factory_.get()); | 4314 QuicStreamRequest request2(factory_.get()); |
4131 EXPECT_EQ(ERR_IO_PENDING, | 4315 EXPECT_EQ( |
4132 request2.Request(host_port_pair_, privacy_mode_, | 4316 ERR_IO_PENDING, |
4133 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4317 request2.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
4134 callback_.callback())); | 4318 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4319 callback_.callback())); | |
4135 | 4320 |
4136 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 4321 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
4137 stream = request2.CreateStream(); | 4322 stream = request2.CreateStream(); |
4138 stream.reset(); // Will reset stream 3. | 4323 stream.reset(); // Will reset stream 3. |
4139 | 4324 |
4140 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 4325 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
4141 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 4326 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
4142 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); | 4327 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); |
4143 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); | 4328 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); |
4144 } | 4329 } |
4145 | 4330 |
4146 TEST_P(QuicStreamFactoryTest, OnCertDBChanged) { | 4331 TEST_P(QuicStreamFactoryTest, OnCertDBChanged) { |
4147 Initialize(); | 4332 Initialize(); |
4148 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 4333 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
4149 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 4334 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
4150 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 4335 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
4151 | 4336 |
4152 MockQuicData socket_data; | 4337 MockQuicData socket_data; |
4153 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 4338 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
4154 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 4339 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
4155 socket_data.AddWrite(ConstructClientRstPacket(2)); | 4340 socket_data.AddWrite(ConstructClientRstPacket(2)); |
4156 socket_data.AddSocketDataToFactory(&socket_factory_); | 4341 socket_data.AddSocketDataToFactory(&socket_factory_); |
4157 | 4342 |
4158 MockQuicData socket_data2; | 4343 MockQuicData socket_data2; |
4159 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 4344 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
4160 socket_data2.AddWrite(ConstructInitialSettingsPacket(1, nullptr)); | 4345 socket_data2.AddWrite(ConstructInitialSettingsPacket(1, nullptr)); |
4161 socket_data2.AddSocketDataToFactory(&socket_factory_); | 4346 socket_data2.AddSocketDataToFactory(&socket_factory_); |
4162 | 4347 |
4163 QuicStreamRequest request(factory_.get()); | 4348 QuicStreamRequest request(factory_.get()); |
4164 EXPECT_EQ(ERR_IO_PENDING, | 4349 EXPECT_EQ( |
4165 request.Request(host_port_pair_, privacy_mode_, | 4350 ERR_IO_PENDING, |
4166 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4351 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
4167 callback_.callback())); | 4352 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4353 callback_.callback())); | |
4168 | 4354 |
4169 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 4355 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
4170 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 4356 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
4171 HttpRequestInfo request_info; | 4357 HttpRequestInfo request_info; |
4172 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 4358 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
4173 net_log_, CompletionCallback())); | 4359 net_log_, CompletionCallback())); |
4174 | 4360 |
4175 // Change the CA cert and verify that stream saw the event. | 4361 // Change the CA cert and verify that stream saw the event. |
4176 factory_->OnCertDBChanged(); | 4362 factory_->OnCertDBChanged(); |
4177 EXPECT_EQ(ERR_CERT_DATABASE_CHANGED, | 4363 EXPECT_EQ(ERR_CERT_DATABASE_CHANGED, |
4178 stream->ReadResponseHeaders(callback_.callback())); | 4364 stream->ReadResponseHeaders(callback_.callback())); |
4179 EXPECT_FALSE(factory_->require_confirmation()); | 4365 EXPECT_FALSE(factory_->require_confirmation()); |
4180 | 4366 |
4181 // Now attempting to request a stream to the same origin should create | 4367 // Now attempting to request a stream to the same origin should create |
4182 // a new session. | 4368 // a new session. |
4183 | 4369 |
4184 QuicStreamRequest request2(factory_.get()); | 4370 QuicStreamRequest request2(factory_.get()); |
4185 EXPECT_EQ(ERR_IO_PENDING, | 4371 EXPECT_EQ( |
4186 request2.Request(host_port_pair_, privacy_mode_, | 4372 ERR_IO_PENDING, |
4187 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4373 request2.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
4188 callback_.callback())); | 4374 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4375 callback_.callback())); | |
4189 | 4376 |
4190 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 4377 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
4191 stream = request2.CreateStream(); | 4378 stream = request2.CreateStream(); |
4192 stream.reset(); // Will reset stream 3. | 4379 stream.reset(); // Will reset stream 3. |
4193 | 4380 |
4194 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 4381 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
4195 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 4382 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
4196 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); | 4383 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); |
4197 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); | 4384 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); |
4198 } | 4385 } |
(...skipping 81 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
4280 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 4467 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
4281 socket_data.AddSocketDataToFactory(&socket_factory_); | 4468 socket_data.AddSocketDataToFactory(&socket_factory_); |
4282 | 4469 |
4283 crypto_client_stream_factory_.set_handshake_mode( | 4470 crypto_client_stream_factory_.set_handshake_mode( |
4284 MockCryptoClientStream::ZERO_RTT); | 4471 MockCryptoClientStream::ZERO_RTT); |
4285 host_resolver_.set_synchronous_mode(true); | 4472 host_resolver_.set_synchronous_mode(true); |
4286 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), | 4473 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), |
4287 "192.168.0.1", ""); | 4474 "192.168.0.1", ""); |
4288 | 4475 |
4289 QuicStreamRequest request(factory_.get()); | 4476 QuicStreamRequest request(factory_.get()); |
4290 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_, | 4477 EXPECT_EQ( |
4291 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4478 OK, request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
4292 callback_.callback())); | 4479 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4480 callback_.callback())); | |
4293 | 4481 |
4294 // If we are waiting for disk cache, we would have posted a task. Verify that | 4482 // If we are waiting for disk cache, we would have posted a task. Verify that |
4295 // the CancelWaitForDataReady task hasn't been posted. | 4483 // the CancelWaitForDataReady task hasn't been posted. |
4296 ASSERT_EQ(0u, runner_->GetPostedTasks().size()); | 4484 ASSERT_EQ(0u, runner_->GetPostedTasks().size()); |
4297 | 4485 |
4298 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 4486 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
4299 EXPECT_TRUE(stream.get()); | 4487 EXPECT_TRUE(stream.get()); |
4300 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 4488 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
4301 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 4489 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
4302 } | 4490 } |
(...skipping 24 matching lines...) Expand all Loading... | |
4327 host_resolver_.set_synchronous_mode(true); | 4515 host_resolver_.set_synchronous_mode(true); |
4328 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), | 4516 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), |
4329 "192.168.0.1", ""); | 4517 "192.168.0.1", ""); |
4330 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); | 4518 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); |
4331 | 4519 |
4332 // Quic should use default PING timeout when no previous connection times out | 4520 // Quic should use default PING timeout when no previous connection times out |
4333 // with open stream. | 4521 // with open stream. |
4334 EXPECT_EQ(QuicTime::Delta::FromSeconds(kPingTimeoutSecs), | 4522 EXPECT_EQ(QuicTime::Delta::FromSeconds(kPingTimeoutSecs), |
4335 QuicStreamFactoryPeer::GetPingTimeout(factory_.get())); | 4523 QuicStreamFactoryPeer::GetPingTimeout(factory_.get())); |
4336 QuicStreamRequest request(factory_.get()); | 4524 QuicStreamRequest request(factory_.get()); |
4337 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_, | 4525 EXPECT_EQ( |
4338 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4526 OK, request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
4339 callback_.callback())); | 4527 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4528 callback_.callback())); | |
4340 | 4529 |
4341 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); | 4530 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); |
4342 EXPECT_EQ(QuicTime::Delta::FromSeconds(kPingTimeoutSecs), | 4531 EXPECT_EQ(QuicTime::Delta::FromSeconds(kPingTimeoutSecs), |
4343 session->connection()->ping_timeout()); | 4532 session->connection()->ping_timeout()); |
4344 | 4533 |
4345 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 4534 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
4346 EXPECT_TRUE(stream.get()); | 4535 EXPECT_TRUE(stream.get()); |
4347 HttpRequestInfo request_info; | 4536 HttpRequestInfo request_info; |
4348 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 4537 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
4349 net_log_, CompletionCallback())); | 4538 net_log_, CompletionCallback())); |
4350 | 4539 |
4351 DVLOG(1) | 4540 DVLOG(1) |
4352 << "Created 1st session and initialized a stream. Now trigger timeout"; | 4541 << "Created 1st session and initialized a stream. Now trigger timeout"; |
4353 session->connection()->CloseConnection(QUIC_NETWORK_IDLE_TIMEOUT, "test", | 4542 session->connection()->CloseConnection(QUIC_NETWORK_IDLE_TIMEOUT, "test", |
4354 ConnectionCloseBehavior::SILENT_CLOSE); | 4543 ConnectionCloseBehavior::SILENT_CLOSE); |
4355 // Need to spin the loop now to ensure that | 4544 // Need to spin the loop now to ensure that |
4356 // QuicStreamFactory::OnSessionClosed() runs. | 4545 // QuicStreamFactory::OnSessionClosed() runs. |
4357 base::RunLoop run_loop; | 4546 base::RunLoop run_loop; |
4358 run_loop.RunUntilIdle(); | 4547 run_loop.RunUntilIdle(); |
4359 | 4548 |
4360 // The first connection times out with open stream, QUIC should reduce initial | 4549 // The first connection times out with open stream, QUIC should reduce initial |
4361 // PING time for subsequent connections. | 4550 // PING time for subsequent connections. |
4362 EXPECT_EQ(QuicTime::Delta::FromSeconds(10), | 4551 EXPECT_EQ(QuicTime::Delta::FromSeconds(10), |
4363 QuicStreamFactoryPeer::GetPingTimeout(factory_.get())); | 4552 QuicStreamFactoryPeer::GetPingTimeout(factory_.get())); |
4364 | 4553 |
4365 // Test two-in-a-row timeouts with open streams. | 4554 // Test two-in-a-row timeouts with open streams. |
4366 DVLOG(1) << "Create 2nd session and timeout with open stream"; | 4555 DVLOG(1) << "Create 2nd session and timeout with open stream"; |
4367 TestCompletionCallback callback2; | 4556 TestCompletionCallback callback2; |
4368 QuicStreamRequest request2(factory_.get()); | 4557 QuicStreamRequest request2(factory_.get()); |
4369 EXPECT_EQ(OK, request2.Request(server2, privacy_mode_, | 4558 EXPECT_EQ(OK, request2.Request(server2, advertised_versions_, privacy_mode_, |
4370 /*cert_verify_flags=*/0, url2_, "GET", | 4559 /*cert_verify_flags=*/0, url2_, "GET", |
4371 net_log_, callback2.callback())); | 4560 net_log_, callback2.callback())); |
4372 QuicChromiumClientSession* session2 = GetActiveSession(server2); | 4561 QuicChromiumClientSession* session2 = GetActiveSession(server2); |
4373 EXPECT_EQ(QuicTime::Delta::FromSeconds(10), | 4562 EXPECT_EQ(QuicTime::Delta::FromSeconds(10), |
4374 session2->connection()->ping_timeout()); | 4563 session2->connection()->ping_timeout()); |
4375 | 4564 |
4376 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 4565 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
4377 EXPECT_TRUE(stream2.get()); | 4566 EXPECT_TRUE(stream2.get()); |
4378 EXPECT_EQ(OK, stream2->InitializeStream(&request_info, DEFAULT_PRIORITY, | 4567 EXPECT_EQ(OK, stream2->InitializeStream(&request_info, DEFAULT_PRIORITY, |
4379 net_log_, CompletionCallback())); | 4568 net_log_, CompletionCallback())); |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
4424 | 4613 |
4425 while (HasActiveCertVerifierJob(quic_server_id)) { | 4614 while (HasActiveCertVerifierJob(quic_server_id)) { |
4426 base::RunLoop().RunUntilIdle(); | 4615 base::RunLoop().RunUntilIdle(); |
4427 } | 4616 } |
4428 } | 4617 } |
4429 // Verify CertVerifierJob has finished. | 4618 // Verify CertVerifierJob has finished. |
4430 EXPECT_FALSE(HasActiveCertVerifierJob(quic_server_id)); | 4619 EXPECT_FALSE(HasActiveCertVerifierJob(quic_server_id)); |
4431 | 4620 |
4432 // Start a QUIC request. | 4621 // Start a QUIC request. |
4433 QuicStreamRequest request(factory_.get()); | 4622 QuicStreamRequest request(factory_.get()); |
4434 EXPECT_EQ(ERR_IO_PENDING, | 4623 EXPECT_EQ( |
4435 request.Request(host_port_pair_, privacy_mode_, | 4624 ERR_IO_PENDING, |
4436 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4625 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
4437 callback_.callback())); | 4626 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4627 callback_.callback())); | |
4438 | 4628 |
4439 EXPECT_EQ(OK, callback_.WaitForResult()); | 4629 EXPECT_EQ(OK, callback_.WaitForResult()); |
4440 | 4630 |
4441 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 4631 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
4442 EXPECT_TRUE(stream.get()); | 4632 EXPECT_TRUE(stream.get()); |
4443 | 4633 |
4444 // Restore |race_cert_verification|. | 4634 // Restore |race_cert_verification|. |
4445 QuicStreamFactoryPeer::SetRaceCertVerification(factory_.get(), | 4635 QuicStreamFactoryPeer::SetRaceCertVerification(factory_.get(), |
4446 race_cert_verification); | 4636 race_cert_verification); |
4447 | 4637 |
(...skipping 22 matching lines...) Expand all Loading... | |
4470 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), | 4660 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), |
4471 "192.168.0.1", ""); | 4661 "192.168.0.1", ""); |
4472 | 4662 |
4473 // Set up the TaskObserver to verify QuicChromiumPacketReader::StartReading | 4663 // Set up the TaskObserver to verify QuicChromiumPacketReader::StartReading |
4474 // posts a task. | 4664 // posts a task. |
4475 // TODO(rtenneti): Change SpdySessionTestTaskObserver to NetTestTaskObserver?? | 4665 // TODO(rtenneti): Change SpdySessionTestTaskObserver to NetTestTaskObserver?? |
4476 SpdySessionTestTaskObserver observer("quic_chromium_packet_reader.cc", | 4666 SpdySessionTestTaskObserver observer("quic_chromium_packet_reader.cc", |
4477 "StartReading"); | 4667 "StartReading"); |
4478 | 4668 |
4479 QuicStreamRequest request(factory_.get()); | 4669 QuicStreamRequest request(factory_.get()); |
4480 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_, | 4670 EXPECT_EQ( |
4481 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4671 OK, request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
4482 callback_.callback())); | 4672 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4673 callback_.callback())); | |
4483 | 4674 |
4484 // Call run_loop so that QuicChromiumPacketReader::OnReadComplete() gets | 4675 // Call run_loop so that QuicChromiumPacketReader::OnReadComplete() gets |
4485 // called. | 4676 // called. |
4486 base::RunLoop run_loop; | 4677 base::RunLoop run_loop; |
4487 run_loop.RunUntilIdle(); | 4678 run_loop.RunUntilIdle(); |
4488 | 4679 |
4489 // Verify task that the observer's executed_count is 1, which indicates | 4680 // Verify task that the observer's executed_count is 1, which indicates |
4490 // QuicChromiumPacketReader::StartReading() has posted only one task and | 4681 // QuicChromiumPacketReader::StartReading() has posted only one task and |
4491 // yielded the read. | 4682 // yielded the read. |
4492 EXPECT_EQ(1u, observer.executed_count()); | 4683 EXPECT_EQ(1u, observer.executed_count()); |
(...skipping 22 matching lines...) Expand all Loading... | |
4515 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), | 4706 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), |
4516 "192.168.0.1", ""); | 4707 "192.168.0.1", ""); |
4517 | 4708 |
4518 // Set up the TaskObserver to verify QuicChromiumPacketReader::StartReading | 4709 // Set up the TaskObserver to verify QuicChromiumPacketReader::StartReading |
4519 // posts a task. | 4710 // posts a task. |
4520 // TODO(rtenneti): Change SpdySessionTestTaskObserver to NetTestTaskObserver?? | 4711 // TODO(rtenneti): Change SpdySessionTestTaskObserver to NetTestTaskObserver?? |
4521 SpdySessionTestTaskObserver observer("quic_chromium_packet_reader.cc", | 4712 SpdySessionTestTaskObserver observer("quic_chromium_packet_reader.cc", |
4522 "StartReading"); | 4713 "StartReading"); |
4523 | 4714 |
4524 QuicStreamRequest request(factory_.get()); | 4715 QuicStreamRequest request(factory_.get()); |
4525 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_, | 4716 EXPECT_EQ( |
4526 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4717 OK, request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
4527 callback_.callback())); | 4718 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4719 callback_.callback())); | |
4528 | 4720 |
4529 // Call run_loop so that QuicChromiumPacketReader::OnReadComplete() gets | 4721 // Call run_loop so that QuicChromiumPacketReader::OnReadComplete() gets |
4530 // called. | 4722 // called. |
4531 base::RunLoop run_loop; | 4723 base::RunLoop run_loop; |
4532 run_loop.RunUntilIdle(); | 4724 run_loop.RunUntilIdle(); |
4533 | 4725 |
4534 // Verify task that the observer's executed_count is 1, which indicates | 4726 // Verify task that the observer's executed_count is 1, which indicates |
4535 // QuicChromiumPacketReader::StartReading() has posted only one task and | 4727 // QuicChromiumPacketReader::StartReading() has posted only one task and |
4536 // yielded the read. | 4728 // yielded the read. |
4537 EXPECT_EQ(1u, observer.executed_count()); | 4729 EXPECT_EQ(1u, observer.executed_count()); |
4538 | 4730 |
4539 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 4731 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
4540 EXPECT_FALSE(stream.get()); // Session is already closed. | 4732 EXPECT_FALSE(stream.get()); // Session is already closed. |
4541 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 4733 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
4542 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 4734 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
4543 } | 4735 } |
4544 | 4736 |
4545 TEST_P(QuicStreamFactoryTest, ServerPushSessionAffinity) { | 4737 TEST_P(QuicStreamFactoryTest, ServerPushSessionAffinity) { |
4546 Initialize(); | 4738 Initialize(); |
4547 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 4739 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
4548 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 4740 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
4549 | 4741 |
4550 MockQuicData socket_data; | 4742 MockQuicData socket_data; |
4551 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 4743 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
4552 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 4744 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
4553 socket_data.AddSocketDataToFactory(&socket_factory_); | 4745 socket_data.AddSocketDataToFactory(&socket_factory_); |
4554 | 4746 |
4555 QuicStreamRequest request(factory_.get()); | 4747 QuicStreamRequest request(factory_.get()); |
4556 EXPECT_EQ(ERR_IO_PENDING, | 4748 EXPECT_EQ( |
4557 request.Request(host_port_pair_, privacy_mode_, | 4749 ERR_IO_PENDING, |
4558 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4750 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
4559 callback_.callback())); | 4751 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4752 callback_.callback())); | |
4560 | 4753 |
4561 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 4754 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
4562 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 4755 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
4563 EXPECT_TRUE(stream.get()); | 4756 EXPECT_TRUE(stream.get()); |
4564 | 4757 |
4565 EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumPushStreamsCreated(factory_.get())); | 4758 EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumPushStreamsCreated(factory_.get())); |
4566 | 4759 |
4567 string url = "https://www.example.org/"; | 4760 string url = "https://www.example.org/"; |
4568 | 4761 |
4569 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); | 4762 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); |
4570 | 4763 |
4571 QuicClientPromisedInfo promised(session, GetNthServerInitiatedStreamId(0), | 4764 QuicClientPromisedInfo promised(session, GetNthServerInitiatedStreamId(0), |
4572 kDefaultUrl); | 4765 kDefaultUrl); |
4573 (*QuicStreamFactoryPeer::GetPushPromiseIndex(factory_.get()) | 4766 (*QuicStreamFactoryPeer::GetPushPromiseIndex(factory_.get()) |
4574 ->promised_by_url())[kDefaultUrl] = &promised; | 4767 ->promised_by_url())[kDefaultUrl] = &promised; |
4575 | 4768 |
4576 QuicStreamRequest request2(factory_.get()); | 4769 QuicStreamRequest request2(factory_.get()); |
4577 EXPECT_EQ(OK, request2.Request(host_port_pair_, privacy_mode_, | 4770 EXPECT_EQ( |
4578 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4771 OK, request2.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
4579 callback_.callback())); | 4772 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4773 callback_.callback())); | |
4580 | 4774 |
4581 EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumPushStreamsCreated(factory_.get())); | 4775 EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumPushStreamsCreated(factory_.get())); |
4582 } | 4776 } |
4583 | 4777 |
4584 TEST_P(QuicStreamFactoryTest, ServerPushPrivacyModeMismatch) { | 4778 TEST_P(QuicStreamFactoryTest, ServerPushPrivacyModeMismatch) { |
4585 Initialize(); | 4779 Initialize(); |
4586 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 4780 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
4587 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 4781 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
4588 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 4782 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
4589 | 4783 |
4590 MockQuicData socket_data1; | 4784 MockQuicData socket_data1; |
4591 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 4785 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
4592 socket_data1.AddWrite(ConstructInitialSettingsPacket()); | 4786 socket_data1.AddWrite(ConstructInitialSettingsPacket()); |
4593 socket_data1.AddWrite(client_maker_.MakeRstPacket( | 4787 socket_data1.AddWrite(client_maker_.MakeRstPacket( |
4594 2, true, GetNthServerInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); | 4788 2, true, GetNthServerInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); |
4595 socket_data1.AddSocketDataToFactory(&socket_factory_); | 4789 socket_data1.AddSocketDataToFactory(&socket_factory_); |
4596 | 4790 |
4597 MockQuicData socket_data2; | 4791 MockQuicData socket_data2; |
4598 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 4792 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
4599 socket_data2.AddWrite(ConstructInitialSettingsPacket()); | 4793 socket_data2.AddWrite(ConstructInitialSettingsPacket()); |
4600 socket_data2.AddSocketDataToFactory(&socket_factory_); | 4794 socket_data2.AddSocketDataToFactory(&socket_factory_); |
4601 | 4795 |
4602 QuicStreamRequest request(factory_.get()); | 4796 QuicStreamRequest request(factory_.get()); |
4603 EXPECT_EQ(ERR_IO_PENDING, | 4797 EXPECT_EQ( |
4604 request.Request(host_port_pair_, privacy_mode_, | 4798 ERR_IO_PENDING, |
4605 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4799 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
4606 callback_.callback())); | 4800 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4801 callback_.callback())); | |
4607 | 4802 |
4608 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 4803 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
4609 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 4804 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
4610 EXPECT_TRUE(stream.get()); | 4805 EXPECT_TRUE(stream.get()); |
4611 | 4806 |
4612 EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumPushStreamsCreated(factory_.get())); | 4807 EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumPushStreamsCreated(factory_.get())); |
4613 | 4808 |
4614 string url = "https://www.example.org/"; | 4809 string url = "https://www.example.org/"; |
4615 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); | 4810 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); |
4616 | 4811 |
4617 QuicClientPromisedInfo promised(session, GetNthServerInitiatedStreamId(0), | 4812 QuicClientPromisedInfo promised(session, GetNthServerInitiatedStreamId(0), |
4618 kDefaultUrl); | 4813 kDefaultUrl); |
4619 | 4814 |
4620 QuicClientPushPromiseIndex* index = | 4815 QuicClientPushPromiseIndex* index = |
4621 QuicStreamFactoryPeer::GetPushPromiseIndex(factory_.get()); | 4816 QuicStreamFactoryPeer::GetPushPromiseIndex(factory_.get()); |
4622 | 4817 |
4623 (*index->promised_by_url())[kDefaultUrl] = &promised; | 4818 (*index->promised_by_url())[kDefaultUrl] = &promised; |
4624 EXPECT_EQ(index->GetPromised(kDefaultUrl), &promised); | 4819 EXPECT_EQ(index->GetPromised(kDefaultUrl), &promised); |
4625 | 4820 |
4626 // Doing the request should not use the push stream, but rather | 4821 // Doing the request should not use the push stream, but rather |
4627 // cancel it because the privacy modes do not match. | 4822 // cancel it because the privacy modes do not match. |
4628 QuicStreamRequest request2(factory_.get()); | 4823 QuicStreamRequest request2(factory_.get()); |
4629 EXPECT_EQ(ERR_IO_PENDING, | 4824 EXPECT_EQ(ERR_IO_PENDING, |
4630 request2.Request(host_port_pair_, PRIVACY_MODE_ENABLED, | 4825 request2.Request(host_port_pair_, advertised_versions_, |
4826 PRIVACY_MODE_ENABLED, | |
4631 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4827 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4632 callback_.callback())); | 4828 callback_.callback())); |
4633 | 4829 |
4634 EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumPushStreamsCreated(factory_.get())); | 4830 EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumPushStreamsCreated(factory_.get())); |
4635 EXPECT_EQ(index->GetPromised(kDefaultUrl), nullptr); | 4831 EXPECT_EQ(index->GetPromised(kDefaultUrl), nullptr); |
4636 | 4832 |
4637 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 4833 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
4638 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 4834 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
4639 EXPECT_TRUE(stream2.get()); | 4835 EXPECT_TRUE(stream2.get()); |
4640 | 4836 |
(...skipping 14 matching lines...) Expand all Loading... | |
4655 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 4851 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
4656 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 4852 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
4657 | 4853 |
4658 MockQuicData socket_data; | 4854 MockQuicData socket_data; |
4659 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 4855 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
4660 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 4856 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
4661 socket_data.AddSocketDataToFactory(&socket_factory_); | 4857 socket_data.AddSocketDataToFactory(&socket_factory_); |
4662 | 4858 |
4663 QuicStreamRequest request1(factory_.get()); | 4859 QuicStreamRequest request1(factory_.get()); |
4664 EXPECT_EQ(ERR_IO_PENDING, | 4860 EXPECT_EQ(ERR_IO_PENDING, |
4665 request1.Request(destination1, privacy_mode_, | 4861 request1.Request(destination1, advertised_versions_, privacy_mode_, |
4666 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4862 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4667 callback_.callback())); | 4863 callback_.callback())); |
4668 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 4864 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
4669 std::unique_ptr<HttpStream> stream1 = request1.CreateStream(); | 4865 std::unique_ptr<HttpStream> stream1 = request1.CreateStream(); |
4670 EXPECT_TRUE(stream1.get()); | 4866 EXPECT_TRUE(stream1.get()); |
4671 EXPECT_TRUE(HasActiveSession(host_port_pair_)); | 4867 EXPECT_TRUE(HasActiveSession(host_port_pair_)); |
4672 | 4868 |
4673 // Second request returns synchronously because it pools to existing session. | 4869 // Second request returns synchronously because it pools to existing session. |
4674 TestCompletionCallback callback2; | 4870 TestCompletionCallback callback2; |
4675 QuicStreamRequest request2(factory_.get()); | 4871 QuicStreamRequest request2(factory_.get()); |
4676 EXPECT_EQ(OK, request2.Request(destination2, privacy_mode_, | 4872 EXPECT_EQ(OK, |
4677 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4873 request2.Request(destination2, advertised_versions_, privacy_mode_, |
4678 callback2.callback())); | 4874 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4875 callback2.callback())); | |
4679 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 4876 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
4680 EXPECT_TRUE(stream2.get()); | 4877 EXPECT_TRUE(stream2.get()); |
4681 | 4878 |
4682 QuicChromiumClientSession::Handle* session1 = | 4879 QuicChromiumClientSession::Handle* session1 = |
4683 QuicHttpStreamPeer::GetSessionHandle(stream1.get()); | 4880 QuicHttpStreamPeer::GetSessionHandle(stream1.get()); |
4684 QuicChromiumClientSession::Handle* session2 = | 4881 QuicChromiumClientSession::Handle* session2 = |
4685 QuicHttpStreamPeer::GetSessionHandle(stream2.get()); | 4882 QuicHttpStreamPeer::GetSessionHandle(stream2.get()); |
4686 EXPECT_TRUE(session1->SharesSameSession(*session2)); | 4883 EXPECT_TRUE(session1->SharesSameSession(*session2)); |
4687 EXPECT_EQ(QuicServerId(host_port_pair_, privacy_mode_), | 4884 EXPECT_EQ(QuicServerId(host_port_pair_, privacy_mode_), |
4688 session1->server_id()); | 4885 session1->server_id()); |
4689 | 4886 |
4690 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 4887 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
4691 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 4888 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
4692 } | 4889 } |
4693 | 4890 |
4694 TEST_P(QuicStreamFactoryTest, ForceHolBlockingEnabled) { | 4891 TEST_P(QuicStreamFactoryTest, ForceHolBlockingEnabled) { |
4695 force_hol_blocking_ = true; | 4892 force_hol_blocking_ = true; |
4696 Initialize(); | 4893 Initialize(); |
4697 | 4894 |
4698 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 4895 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
4699 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 4896 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
4700 | 4897 |
4701 MockQuicData socket_data; | 4898 MockQuicData socket_data; |
4702 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 4899 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
4703 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 4900 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
4704 socket_data.AddSocketDataToFactory(&socket_factory_); | 4901 socket_data.AddSocketDataToFactory(&socket_factory_); |
4705 | 4902 |
4706 QuicStreamRequest request(factory_.get()); | 4903 QuicStreamRequest request(factory_.get()); |
4707 EXPECT_EQ(ERR_IO_PENDING, | 4904 EXPECT_EQ( |
4708 request.Request(host_port_pair_, privacy_mode_, | 4905 ERR_IO_PENDING, |
4709 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4906 request.Request(host_port_pair_, advertised_versions_, privacy_mode_, |
4710 callback_.callback())); | 4907 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4908 callback_.callback())); | |
4711 | 4909 |
4712 EXPECT_EQ(OK, callback_.WaitForResult()); | 4910 EXPECT_EQ(OK, callback_.WaitForResult()); |
4713 | 4911 |
4714 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); | 4912 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); |
4715 if (session->connection()->version() == QUIC_VERSION_36) { | 4913 if (session->connection()->version() == QUIC_VERSION_36) { |
4716 EXPECT_TRUE(session->force_hol_blocking()); | 4914 EXPECT_TRUE(session->force_hol_blocking()); |
4717 } else { | 4915 } else { |
4718 EXPECT_FALSE(session->force_hol_blocking()); | 4916 EXPECT_FALSE(session->force_hol_blocking()); |
4719 } | 4917 } |
4720 } | 4918 } |
(...skipping 73 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
4794 ASSERT_TRUE(cert->VerifyNameMatch(origin2_.host(), false)); | 4992 ASSERT_TRUE(cert->VerifyNameMatch(origin2_.host(), false)); |
4795 | 4993 |
4796 ProofVerifyDetailsChromium verify_details; | 4994 ProofVerifyDetailsChromium verify_details; |
4797 verify_details.cert_verify_result.verified_cert = cert; | 4995 verify_details.cert_verify_result.verified_cert = cert; |
4798 verify_details.cert_verify_result.is_issued_by_known_root = true; | 4996 verify_details.cert_verify_result.is_issued_by_known_root = true; |
4799 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 4997 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
4800 | 4998 |
4801 AddHangingSocketData(); | 4999 AddHangingSocketData(); |
4802 | 5000 |
4803 QuicStreamRequest request(factory_.get()); | 5001 QuicStreamRequest request(factory_.get()); |
4804 EXPECT_EQ(ERR_IO_PENDING, request.Request(destination, privacy_mode_, | 5002 EXPECT_EQ(ERR_IO_PENDING, |
4805 /*cert_verify_flags=*/0, url, "GET", | 5003 request.Request(destination, advertised_versions_, privacy_mode_, |
4806 net_log_, callback_.callback())); | 5004 /*cert_verify_flags=*/0, url, "GET", net_log_, |
5005 callback_.callback())); | |
4807 | 5006 |
4808 EXPECT_THAT(callback_.WaitForResult(), IsError(ERR_QUIC_HANDSHAKE_FAILED)); | 5007 EXPECT_THAT(callback_.WaitForResult(), IsError(ERR_QUIC_HANDSHAKE_FAILED)); |
4809 | 5008 |
4810 EXPECT_TRUE(AllDataConsumed()); | 5009 EXPECT_TRUE(AllDataConsumed()); |
4811 } | 5010 } |
4812 | 5011 |
4813 // QuicStreamRequest is pooled based on |destination| if certificate matches. | 5012 // QuicStreamRequest is pooled based on |destination| if certificate matches. |
4814 TEST_P(QuicStreamFactoryWithDestinationTest, SharedCertificate) { | 5013 TEST_P(QuicStreamFactoryWithDestinationTest, SharedCertificate) { |
4815 Initialize(); | 5014 Initialize(); |
4816 | 5015 |
(...skipping 20 matching lines...) Expand all Loading... | |
4837 client_maker_.MakeInitialSettingsPacket(1, nullptr)); | 5036 client_maker_.MakeInitialSettingsPacket(1, nullptr)); |
4838 MockWrite writes[] = {MockWrite(SYNCHRONOUS, settings_packet->data(), | 5037 MockWrite writes[] = {MockWrite(SYNCHRONOUS, settings_packet->data(), |
4839 settings_packet->length(), 1)}; | 5038 settings_packet->length(), 1)}; |
4840 std::unique_ptr<SequencedSocketData> sequenced_socket_data( | 5039 std::unique_ptr<SequencedSocketData> sequenced_socket_data( |
4841 new SequencedSocketData(reads, 1, writes, arraysize(writes))); | 5040 new SequencedSocketData(reads, 1, writes, arraysize(writes))); |
4842 socket_factory_.AddSocketDataProvider(sequenced_socket_data.get()); | 5041 socket_factory_.AddSocketDataProvider(sequenced_socket_data.get()); |
4843 sequenced_socket_data_vector_.push_back(std::move(sequenced_socket_data)); | 5042 sequenced_socket_data_vector_.push_back(std::move(sequenced_socket_data)); |
4844 | 5043 |
4845 QuicStreamRequest request1(factory_.get()); | 5044 QuicStreamRequest request1(factory_.get()); |
4846 EXPECT_EQ(ERR_IO_PENDING, | 5045 EXPECT_EQ(ERR_IO_PENDING, |
4847 request1.Request(destination, privacy_mode_, | 5046 request1.Request(destination, advertised_versions_, privacy_mode_, |
4848 /*cert_verify_flags=*/0, url1, "GET", net_log_, | 5047 /*cert_verify_flags=*/0, url1, "GET", net_log_, |
4849 callback_.callback())); | 5048 callback_.callback())); |
4850 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 5049 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
4851 | 5050 |
4852 std::unique_ptr<HttpStream> stream1 = request1.CreateStream(); | 5051 std::unique_ptr<HttpStream> stream1 = request1.CreateStream(); |
4853 EXPECT_TRUE(stream1.get()); | 5052 EXPECT_TRUE(stream1.get()); |
4854 EXPECT_TRUE(HasActiveSession(origin1_)); | 5053 EXPECT_TRUE(HasActiveSession(origin1_)); |
4855 | 5054 |
4856 // Second request returns synchronously because it pools to existing session. | 5055 // Second request returns synchronously because it pools to existing session. |
4857 TestCompletionCallback callback2; | 5056 TestCompletionCallback callback2; |
4858 QuicStreamRequest request2(factory_.get()); | 5057 QuicStreamRequest request2(factory_.get()); |
4859 EXPECT_EQ(OK, request2.Request(destination, privacy_mode_, | 5058 EXPECT_EQ(OK, |
4860 /*cert_verify_flags=*/0, url2, "GET", net_log_, | 5059 request2.Request(destination, advertised_versions_, privacy_mode_, |
4861 callback2.callback())); | 5060 /*cert_verify_flags=*/0, url2, "GET", net_log_, |
5061 callback2.callback())); | |
4862 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 5062 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
4863 EXPECT_TRUE(stream2.get()); | 5063 EXPECT_TRUE(stream2.get()); |
4864 | 5064 |
4865 QuicChromiumClientSession::Handle* session1 = | 5065 QuicChromiumClientSession::Handle* session1 = |
4866 QuicHttpStreamPeer::GetSessionHandle(stream1.get()); | 5066 QuicHttpStreamPeer::GetSessionHandle(stream1.get()); |
4867 QuicChromiumClientSession::Handle* session2 = | 5067 QuicChromiumClientSession::Handle* session2 = |
4868 QuicHttpStreamPeer::GetSessionHandle(stream2.get()); | 5068 QuicHttpStreamPeer::GetSessionHandle(stream2.get()); |
4869 EXPECT_TRUE(session1->SharesSameSession(*session2)); | 5069 EXPECT_TRUE(session1->SharesSameSession(*session2)); |
4870 | 5070 |
4871 EXPECT_EQ(QuicServerId(origin1_, privacy_mode_), session1->server_id()); | 5071 EXPECT_EQ(QuicServerId(origin1_, privacy_mode_), session1->server_id()); |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
4908 std::unique_ptr<SequencedSocketData> sequenced_socket_data( | 5108 std::unique_ptr<SequencedSocketData> sequenced_socket_data( |
4909 new SequencedSocketData(reads, 1, writes, arraysize(writes))); | 5109 new SequencedSocketData(reads, 1, writes, arraysize(writes))); |
4910 socket_factory_.AddSocketDataProvider(sequenced_socket_data.get()); | 5110 socket_factory_.AddSocketDataProvider(sequenced_socket_data.get()); |
4911 sequenced_socket_data_vector_.push_back(std::move(sequenced_socket_data)); | 5111 sequenced_socket_data_vector_.push_back(std::move(sequenced_socket_data)); |
4912 std::unique_ptr<SequencedSocketData> sequenced_socket_data1( | 5112 std::unique_ptr<SequencedSocketData> sequenced_socket_data1( |
4913 new SequencedSocketData(reads, 1, writes, arraysize(writes))); | 5113 new SequencedSocketData(reads, 1, writes, arraysize(writes))); |
4914 socket_factory_.AddSocketDataProvider(sequenced_socket_data1.get()); | 5114 socket_factory_.AddSocketDataProvider(sequenced_socket_data1.get()); |
4915 sequenced_socket_data_vector_.push_back(std::move(sequenced_socket_data1)); | 5115 sequenced_socket_data_vector_.push_back(std::move(sequenced_socket_data1)); |
4916 | 5116 |
4917 QuicStreamRequest request1(factory_.get()); | 5117 QuicStreamRequest request1(factory_.get()); |
4918 EXPECT_EQ(ERR_IO_PENDING, | 5118 EXPECT_EQ( |
4919 request1.Request(destination, PRIVACY_MODE_DISABLED, | 5119 ERR_IO_PENDING, |
4920 /*cert_verify_flags=*/0, url1, "GET", net_log_, | 5120 request1.Request(destination, advertised_versions_, PRIVACY_MODE_DISABLED, |
4921 callback_.callback())); | 5121 /*cert_verify_flags=*/0, url1, "GET", net_log_, |
5122 callback_.callback())); | |
4922 EXPECT_EQ(OK, callback_.WaitForResult()); | 5123 EXPECT_EQ(OK, callback_.WaitForResult()); |
4923 std::unique_ptr<HttpStream> stream1 = request1.CreateStream(); | 5124 std::unique_ptr<HttpStream> stream1 = request1.CreateStream(); |
4924 EXPECT_TRUE(stream1.get()); | 5125 EXPECT_TRUE(stream1.get()); |
4925 EXPECT_TRUE(HasActiveSession(origin1_)); | 5126 EXPECT_TRUE(HasActiveSession(origin1_)); |
4926 | 5127 |
4927 TestCompletionCallback callback2; | 5128 TestCompletionCallback callback2; |
4928 QuicStreamRequest request2(factory_.get()); | 5129 QuicStreamRequest request2(factory_.get()); |
4929 EXPECT_EQ(ERR_IO_PENDING, | 5130 EXPECT_EQ( |
4930 request2.Request(destination, PRIVACY_MODE_ENABLED, | 5131 ERR_IO_PENDING, |
4931 /*cert_verify_flags=*/0, url2, "GET", net_log_, | 5132 request2.Request(destination, advertised_versions_, PRIVACY_MODE_ENABLED, |
4932 callback2.callback())); | 5133 /*cert_verify_flags=*/0, url2, "GET", net_log_, |
5134 callback2.callback())); | |
4933 EXPECT_EQ(OK, callback2.WaitForResult()); | 5135 EXPECT_EQ(OK, callback2.WaitForResult()); |
4934 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 5136 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
4935 EXPECT_TRUE(stream2.get()); | 5137 EXPECT_TRUE(stream2.get()); |
4936 | 5138 |
4937 // |request2| does not pool to the first session, because PrivacyMode does not | 5139 // |request2| does not pool to the first session, because PrivacyMode does not |
4938 // match. Instead, another session is opened to the same destination, but | 5140 // match. Instead, another session is opened to the same destination, but |
4939 // with a different QuicServerId. | 5141 // with a different QuicServerId. |
4940 QuicChromiumClientSession::Handle* session1 = | 5142 QuicChromiumClientSession::Handle* session1 = |
4941 QuicHttpStreamPeer::GetSessionHandle(stream1.get()); | 5143 QuicHttpStreamPeer::GetSessionHandle(stream1.get()); |
4942 QuicChromiumClientSession::Handle* session2 = | 5144 QuicChromiumClientSession::Handle* session2 = |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
4992 new SequencedSocketData(reads, 1, writes, arraysize(writes))); | 5194 new SequencedSocketData(reads, 1, writes, arraysize(writes))); |
4993 socket_factory_.AddSocketDataProvider(sequenced_socket_data.get()); | 5195 socket_factory_.AddSocketDataProvider(sequenced_socket_data.get()); |
4994 sequenced_socket_data_vector_.push_back(std::move(sequenced_socket_data)); | 5196 sequenced_socket_data_vector_.push_back(std::move(sequenced_socket_data)); |
4995 std::unique_ptr<SequencedSocketData> sequenced_socket_data1( | 5197 std::unique_ptr<SequencedSocketData> sequenced_socket_data1( |
4996 new SequencedSocketData(reads, 1, writes, arraysize(writes))); | 5198 new SequencedSocketData(reads, 1, writes, arraysize(writes))); |
4997 socket_factory_.AddSocketDataProvider(sequenced_socket_data1.get()); | 5199 socket_factory_.AddSocketDataProvider(sequenced_socket_data1.get()); |
4998 sequenced_socket_data_vector_.push_back(std::move(sequenced_socket_data1)); | 5200 sequenced_socket_data_vector_.push_back(std::move(sequenced_socket_data1)); |
4999 | 5201 |
5000 QuicStreamRequest request1(factory_.get()); | 5202 QuicStreamRequest request1(factory_.get()); |
5001 EXPECT_EQ(ERR_IO_PENDING, | 5203 EXPECT_EQ(ERR_IO_PENDING, |
5002 request1.Request(destination, privacy_mode_, | 5204 request1.Request(destination, advertised_versions_, privacy_mode_, |
5003 /*cert_verify_flags=*/0, url1, "GET", net_log_, | 5205 /*cert_verify_flags=*/0, url1, "GET", net_log_, |
5004 callback_.callback())); | 5206 callback_.callback())); |
5005 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 5207 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
5006 std::unique_ptr<HttpStream> stream1 = request1.CreateStream(); | 5208 std::unique_ptr<HttpStream> stream1 = request1.CreateStream(); |
5007 EXPECT_TRUE(stream1.get()); | 5209 EXPECT_TRUE(stream1.get()); |
5008 EXPECT_TRUE(HasActiveSession(origin1_)); | 5210 EXPECT_TRUE(HasActiveSession(origin1_)); |
5009 | 5211 |
5010 TestCompletionCallback callback2; | 5212 TestCompletionCallback callback2; |
5011 QuicStreamRequest request2(factory_.get()); | 5213 QuicStreamRequest request2(factory_.get()); |
5012 EXPECT_EQ(ERR_IO_PENDING, | 5214 EXPECT_EQ(ERR_IO_PENDING, |
5013 request2.Request(destination, privacy_mode_, | 5215 request2.Request(destination, advertised_versions_, privacy_mode_, |
5014 /*cert_verify_flags=*/0, url2, "GET", net_log_, | 5216 /*cert_verify_flags=*/0, url2, "GET", net_log_, |
5015 callback2.callback())); | 5217 callback2.callback())); |
5016 EXPECT_THAT(callback2.WaitForResult(), IsOk()); | 5218 EXPECT_THAT(callback2.WaitForResult(), IsOk()); |
5017 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 5219 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
5018 EXPECT_TRUE(stream2.get()); | 5220 EXPECT_TRUE(stream2.get()); |
5019 | 5221 |
5020 // |request2| does not pool to the first session, because the certificate does | 5222 // |request2| does not pool to the first session, because the certificate does |
5021 // not match. Instead, another session is opened to the same destination, but | 5223 // not match. Instead, another session is opened to the same destination, but |
5022 // with a different QuicServerId. | 5224 // with a different QuicServerId. |
5023 QuicChromiumClientSession::Handle* session1 = | 5225 QuicChromiumClientSession::Handle* session1 = |
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
5074 // Clear all cached states. | 5276 // Clear all cached states. |
5075 factory_->ClearCachedStatesInCryptoConfig( | 5277 factory_->ClearCachedStatesInCryptoConfig( |
5076 base::Callback<bool(const GURL&)>()); | 5278 base::Callback<bool(const GURL&)>()); |
5077 EXPECT_TRUE(test_cases[0].state->certs().empty()); | 5279 EXPECT_TRUE(test_cases[0].state->certs().empty()); |
5078 EXPECT_TRUE(test_cases[1].state->certs().empty()); | 5280 EXPECT_TRUE(test_cases[1].state->certs().empty()); |
5079 EXPECT_TRUE(test_cases[2].state->certs().empty()); | 5281 EXPECT_TRUE(test_cases[2].state->certs().empty()); |
5080 } | 5282 } |
5081 | 5283 |
5082 } // namespace test | 5284 } // namespace test |
5083 } // namespace net | 5285 } // namespace net |
OLD | NEW |