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_); |
207 clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1)); | 208 clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1)); |
208 } | 209 } |
209 | 210 |
210 void Initialize() { | 211 void Initialize() { |
211 DCHECK(!factory_); | 212 DCHECK(!factory_); |
212 factory_.reset(new QuicStreamFactory( | 213 factory_.reset(new QuicStreamFactory( |
213 net_log_.net_log(), &host_resolver_, ssl_config_service_.get(), | 214 net_log_.net_log(), &host_resolver_, ssl_config_service_.get(), |
214 &socket_factory_, &http_server_properties_, cert_verifier_.get(), | 215 &socket_factory_, &http_server_properties_, cert_verifier_.get(), |
215 &ct_policy_enforcer_, channel_id_service_.get(), | 216 &ct_policy_enforcer_, channel_id_service_.get(), |
216 &transport_security_state_, cert_transparency_verifier_.get(), | 217 &transport_security_state_, cert_transparency_verifier_.get(), |
217 /*SocketPerformanceWatcherFactory*/ nullptr, | 218 /*SocketPerformanceWatcherFactory*/ nullptr, |
218 &crypto_client_stream_factory_, &random_generator_, &clock_, | 219 &crypto_client_stream_factory_, &random_generator_, &clock_, |
219 kDefaultMaxPacketSize, string(), SupportedVersions(version_), | 220 kDefaultMaxPacketSize, string(), supported_versions_, |
220 store_server_configs_in_properties_, close_sessions_on_ip_change_, | 221 store_server_configs_in_properties_, close_sessions_on_ip_change_, |
221 /*mark_quic_broken_when_network_blackholes*/ false, | 222 /*mark_quic_broken_when_network_blackholes*/ false, |
222 idle_connection_timeout_seconds_, reduced_ping_timeout_seconds_, | 223 idle_connection_timeout_seconds_, reduced_ping_timeout_seconds_, |
223 packet_reader_yield_after_duration_milliseconds_, | 224 packet_reader_yield_after_duration_milliseconds_, |
224 migrate_sessions_on_network_change_, migrate_sessions_early_, | 225 migrate_sessions_on_network_change_, migrate_sessions_early_, |
225 allow_server_migration_, force_hol_blocking_, race_cert_verification_, | 226 allow_server_migration_, force_hol_blocking_, race_cert_verification_, |
226 /*do_not_fragment*/ true, estimate_initial_rtt_, QuicTagVector(), | 227 /*do_not_fragment*/ true, estimate_initial_rtt_, QuicTagVector(), |
227 /*enable_token_binding*/ false)); | 228 /*enable_token_binding*/ false)); |
228 factory_->set_require_confirmation(false); | 229 factory_->set_require_confirmation(false); |
229 } | 230 } |
(...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(); | 279 size_t socket_count = socket_factory_.udp_client_socket_ports().size(); |
279 | 280 |
280 MockQuicData socket_data; | 281 MockQuicData socket_data; |
281 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 282 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
282 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 283 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
283 socket_data.AddSocketDataToFactory(&socket_factory_); | 284 socket_data.AddSocketDataToFactory(&socket_factory_); |
284 | 285 |
285 QuicStreamRequest request(factory_.get()); | 286 QuicStreamRequest request(factory_.get()); |
286 GURL url("https://" + destination.host() + "/"); | 287 GURL url("https://" + destination.host() + "/"); |
287 EXPECT_EQ(ERR_IO_PENDING, | 288 EXPECT_EQ(ERR_IO_PENDING, |
288 request.Request(destination, privacy_mode_, | 289 request.Request(destination, version_, privacy_mode_, |
289 /*cert_verify_flags=*/0, url, "GET", net_log_, | 290 /*cert_verify_flags=*/0, url, "GET", net_log_, |
290 callback_.callback())); | 291 callback_.callback())); |
291 | 292 |
292 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 293 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
293 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 294 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
294 EXPECT_TRUE(stream.get()); | 295 EXPECT_TRUE(stream.get()); |
295 stream.reset(); | 296 stream.reset(); |
296 | 297 |
297 QuicChromiumClientSession* session = GetActiveSession(destination); | 298 QuicChromiumClientSession* session = GetActiveSession(destination); |
298 | 299 |
(...skipping 124 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
423 socket_data2.AddWrite(ConstructInitialSettingsPacket()); | 424 socket_data2.AddWrite(ConstructInitialSettingsPacket()); |
424 socket_data2.AddWrite( | 425 socket_data2.AddWrite( |
425 client_maker_.MakePingPacket(2, /*include_version=*/true)); | 426 client_maker_.MakePingPacket(2, /*include_version=*/true)); |
426 socket_data2.AddWrite(client_maker_.MakeRstPacket( | 427 socket_data2.AddWrite(client_maker_.MakeRstPacket( |
427 3, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); | 428 3, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); |
428 socket_data2.AddSocketDataToFactory(&socket_factory_); | 429 socket_data2.AddSocketDataToFactory(&socket_factory_); |
429 | 430 |
430 // Create request and QuicHttpStream. | 431 // Create request and QuicHttpStream. |
431 QuicStreamRequest request(factory_.get()); | 432 QuicStreamRequest request(factory_.get()); |
432 EXPECT_EQ(ERR_IO_PENDING, | 433 EXPECT_EQ(ERR_IO_PENDING, |
433 request.Request(host_port_pair_, privacy_mode_, | 434 request.Request(host_port_pair_, version_, privacy_mode_, |
434 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 435 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
435 callback_.callback())); | 436 callback_.callback())); |
436 EXPECT_EQ(OK, callback_.WaitForResult()); | 437 EXPECT_EQ(OK, callback_.WaitForResult()); |
437 | 438 |
438 // Run QuicChromiumClientSession::WriteToNewSocket() | 439 // Run QuicChromiumClientSession::WriteToNewSocket() |
439 // posted by QuicChromiumClientSession::MigrateToSocket(). | 440 // posted by QuicChromiumClientSession::MigrateToSocket(). |
440 base::RunLoop().RunUntilIdle(); | 441 base::RunLoop().RunUntilIdle(); |
441 | 442 |
442 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 443 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
443 EXPECT_TRUE(stream.get()); | 444 EXPECT_TRUE(stream.get()); |
(...skipping 159 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
603 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), | 604 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), |
604 "192.168.0.1", ""); | 605 "192.168.0.1", ""); |
605 | 606 |
606 // Create a session and verify that the cached state is loaded. | 607 // Create a session and verify that the cached state is loaded. |
607 MockQuicData socket_data; | 608 MockQuicData socket_data; |
608 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 609 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
609 socket_data.AddSocketDataToFactory(&socket_factory_); | 610 socket_data.AddSocketDataToFactory(&socket_factory_); |
610 | 611 |
611 QuicStreamRequest request(factory_.get()); | 612 QuicStreamRequest request(factory_.get()); |
612 EXPECT_EQ(ERR_IO_PENDING, | 613 EXPECT_EQ(ERR_IO_PENDING, |
613 request.Request(quic_server_id.host_port_pair(), privacy_mode_, | 614 request.Request(quic_server_id.host_port_pair(), version_, |
614 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 615 privacy_mode_, /*cert_verify_flags=*/0, url_, |
615 callback_.callback())); | 616 "GET", net_log_, callback_.callback())); |
616 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 617 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
617 | 618 |
618 EXPECT_FALSE(QuicStreamFactoryPeer::CryptoConfigCacheIsEmpty( | 619 EXPECT_FALSE(QuicStreamFactoryPeer::CryptoConfigCacheIsEmpty( |
619 factory_.get(), quic_server_id)); | 620 factory_.get(), quic_server_id)); |
620 QuicCryptoClientConfig* crypto_config = | 621 QuicCryptoClientConfig* crypto_config = |
621 QuicStreamFactoryPeer::GetCryptoConfig(factory_.get()); | 622 QuicStreamFactoryPeer::GetCryptoConfig(factory_.get()); |
622 QuicCryptoClientConfig::CachedState* cached = | 623 QuicCryptoClientConfig::CachedState* cached = |
623 crypto_config->LookupOrCreate(quic_server_id); | 624 crypto_config->LookupOrCreate(quic_server_id); |
624 EXPECT_FALSE(cached->server_config().empty()); | 625 EXPECT_FALSE(cached->server_config().empty()); |
625 EXPECT_TRUE(cached->GetServerConfig()); | 626 EXPECT_TRUE(cached->GetServerConfig()); |
(...skipping 10 matching lines...) Expand all Loading... |
636 // Create a session and verify that the cached state is loaded. | 637 // Create a session and verify that the cached state is loaded. |
637 MockQuicData socket_data2; | 638 MockQuicData socket_data2; |
638 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 639 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
639 socket_data2.AddSocketDataToFactory(&socket_factory_); | 640 socket_data2.AddSocketDataToFactory(&socket_factory_); |
640 | 641 |
641 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), | 642 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), |
642 "192.168.0.2", ""); | 643 "192.168.0.2", ""); |
643 | 644 |
644 QuicStreamRequest request2(factory_.get()); | 645 QuicStreamRequest request2(factory_.get()); |
645 EXPECT_EQ(ERR_IO_PENDING, | 646 EXPECT_EQ(ERR_IO_PENDING, |
646 request2.Request(quic_server_id2.host_port_pair(), privacy_mode_, | 647 request2.Request( |
647 /*cert_verify_flags=*/0, | 648 quic_server_id2.host_port_pair(), version_, privacy_mode_, |
648 GURL("https://mail.example.org/"), "GET", | 649 /*cert_verify_flags=*/0, GURL("https://mail.example.org/"), |
649 net_log_, callback_.callback())); | 650 "GET", net_log_, callback_.callback())); |
650 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 651 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
651 | 652 |
652 EXPECT_FALSE(QuicStreamFactoryPeer::CryptoConfigCacheIsEmpty( | 653 EXPECT_FALSE(QuicStreamFactoryPeer::CryptoConfigCacheIsEmpty( |
653 factory_.get(), quic_server_id2)); | 654 factory_.get(), quic_server_id2)); |
654 QuicCryptoClientConfig::CachedState* cached2 = | 655 QuicCryptoClientConfig::CachedState* cached2 = |
655 crypto_config->LookupOrCreate(quic_server_id2); | 656 crypto_config->LookupOrCreate(quic_server_id2); |
656 EXPECT_FALSE(cached2->server_config().empty()); | 657 EXPECT_FALSE(cached2->server_config().empty()); |
657 EXPECT_TRUE(cached2->GetServerConfig()); | 658 EXPECT_TRUE(cached2->GetServerConfig()); |
658 EXPECT_EQ(server_config2, cached2->server_config()); | 659 EXPECT_EQ(server_config2, cached2->server_config()); |
659 EXPECT_EQ(source_address_token2, cached2->source_address_token()); | 660 EXPECT_EQ(source_address_token2, cached2->source_address_token()); |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
696 bool disconnected); | 697 bool disconnected); |
697 | 698 |
698 MockHostResolver host_resolver_; | 699 MockHostResolver host_resolver_; |
699 scoped_refptr<SSLConfigService> ssl_config_service_; | 700 scoped_refptr<SSLConfigService> ssl_config_service_; |
700 MockClientSocketFactory socket_factory_; | 701 MockClientSocketFactory socket_factory_; |
701 MockCryptoClientStreamFactory crypto_client_stream_factory_; | 702 MockCryptoClientStreamFactory crypto_client_stream_factory_; |
702 MockRandom random_generator_; | 703 MockRandom random_generator_; |
703 MockClock clock_; | 704 MockClock clock_; |
704 scoped_refptr<TestTaskRunner> runner_; | 705 scoped_refptr<TestTaskRunner> runner_; |
705 QuicVersion version_; | 706 QuicVersion version_; |
| 707 QuicVersionVector supported_versions_; |
706 QuicTestPacketMaker client_maker_; | 708 QuicTestPacketMaker client_maker_; |
707 QuicTestPacketMaker server_maker_; | 709 QuicTestPacketMaker server_maker_; |
708 HttpServerPropertiesImpl http_server_properties_; | 710 HttpServerPropertiesImpl http_server_properties_; |
709 std::unique_ptr<CertVerifier> cert_verifier_; | 711 std::unique_ptr<CertVerifier> cert_verifier_; |
710 std::unique_ptr<ChannelIDService> channel_id_service_; | 712 std::unique_ptr<ChannelIDService> channel_id_service_; |
711 TransportSecurityState transport_security_state_; | 713 TransportSecurityState transport_security_state_; |
712 std::unique_ptr<CTVerifier> cert_transparency_verifier_; | 714 std::unique_ptr<CTVerifier> cert_transparency_verifier_; |
713 CTPolicyEnforcer ct_policy_enforcer_; | 715 CTPolicyEnforcer ct_policy_enforcer_; |
714 std::unique_ptr<ScopedMockNetworkChangeNotifier> | 716 std::unique_ptr<ScopedMockNetworkChangeNotifier> |
715 scoped_mock_network_change_notifier_; | 717 scoped_mock_network_change_notifier_; |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
753 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 755 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
754 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 756 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
755 | 757 |
756 MockQuicData socket_data; | 758 MockQuicData socket_data; |
757 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 759 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
758 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 760 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
759 socket_data.AddSocketDataToFactory(&socket_factory_); | 761 socket_data.AddSocketDataToFactory(&socket_factory_); |
760 | 762 |
761 QuicStreamRequest request(factory_.get()); | 763 QuicStreamRequest request(factory_.get()); |
762 EXPECT_EQ(ERR_IO_PENDING, | 764 EXPECT_EQ(ERR_IO_PENDING, |
763 request.Request(host_port_pair_, privacy_mode_, | 765 request.Request(host_port_pair_, version_, privacy_mode_, |
764 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 766 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
765 callback_.callback())); | 767 callback_.callback())); |
766 | 768 |
767 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 769 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
768 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 770 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
769 EXPECT_TRUE(stream.get()); | 771 EXPECT_TRUE(stream.get()); |
770 | 772 |
771 QuicStreamRequest request2(factory_.get()); | 773 QuicStreamRequest request2(factory_.get()); |
772 EXPECT_EQ(OK, request2.Request(host_port_pair_, privacy_mode_, | 774 EXPECT_EQ(OK, request2.Request(host_port_pair_, version_, privacy_mode_, |
773 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 775 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
774 callback_.callback())); | 776 callback_.callback())); |
775 // Will reset stream 3. | 777 // Will reset stream 3. |
776 stream = request2.CreateStream(); | 778 stream = request2.CreateStream(); |
777 | 779 |
778 EXPECT_TRUE(stream.get()); | 780 EXPECT_TRUE(stream.get()); |
779 | 781 |
780 // TODO(rtenneti): We should probably have a tests that HTTP and HTTPS result | 782 // TODO(rtenneti): We should probably have a tests that HTTP and HTTPS result |
781 // in streams on different sessions. | 783 // in streams on different sessions. |
782 QuicStreamRequest request3(factory_.get()); | 784 QuicStreamRequest request3(factory_.get()); |
783 EXPECT_EQ(OK, request3.Request(host_port_pair_, privacy_mode_, | 785 EXPECT_EQ(OK, request3.Request(host_port_pair_, version_, privacy_mode_, |
784 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 786 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
785 callback_.callback())); | 787 callback_.callback())); |
786 stream = request3.CreateStream(); // Will reset stream 5. | 788 stream = request3.CreateStream(); // Will reset stream 5. |
787 stream.reset(); // Will reset stream 7. | 789 stream.reset(); // Will reset stream 7. |
788 | 790 |
789 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 791 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
790 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 792 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
791 } | 793 } |
792 | 794 |
793 TEST_P(QuicStreamFactoryTest, CreateZeroRtt) { | 795 TEST_P(QuicStreamFactoryTest, CreateZeroRtt) { |
794 Initialize(); | 796 Initialize(); |
795 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 797 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
796 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 798 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
797 | 799 |
798 MockQuicData socket_data; | 800 MockQuicData socket_data; |
799 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 801 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
800 socket_data.AddSocketDataToFactory(&socket_factory_); | 802 socket_data.AddSocketDataToFactory(&socket_factory_); |
801 | 803 |
802 crypto_client_stream_factory_.set_handshake_mode( | 804 crypto_client_stream_factory_.set_handshake_mode( |
803 MockCryptoClientStream::ZERO_RTT); | 805 MockCryptoClientStream::ZERO_RTT); |
804 host_resolver_.set_synchronous_mode(true); | 806 host_resolver_.set_synchronous_mode(true); |
805 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), | 807 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), |
806 "192.168.0.1", ""); | 808 "192.168.0.1", ""); |
807 | 809 |
808 QuicStreamRequest request(factory_.get()); | 810 QuicStreamRequest request(factory_.get()); |
809 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_, | 811 EXPECT_EQ(OK, request.Request(host_port_pair_, version_, privacy_mode_, |
810 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 812 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
811 callback_.callback())); | 813 callback_.callback())); |
812 | 814 |
813 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 815 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
814 EXPECT_TRUE(stream.get()); | 816 EXPECT_TRUE(stream.get()); |
815 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 817 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
816 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 818 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
817 } | 819 } |
818 | 820 |
819 TEST_P(QuicStreamFactoryTest, CreateZeroRttPost) { | 821 TEST_P(QuicStreamFactoryTest, CreateZeroRttPost) { |
820 Initialize(); | 822 Initialize(); |
821 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 823 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
822 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 824 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
823 | 825 |
824 MockQuicData socket_data; | 826 MockQuicData socket_data; |
825 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 827 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
826 socket_data.AddSocketDataToFactory(&socket_factory_); | 828 socket_data.AddSocketDataToFactory(&socket_factory_); |
827 | 829 |
828 crypto_client_stream_factory_.set_handshake_mode( | 830 crypto_client_stream_factory_.set_handshake_mode( |
829 MockCryptoClientStream::ZERO_RTT); | 831 MockCryptoClientStream::ZERO_RTT); |
830 host_resolver_.set_synchronous_mode(true); | 832 host_resolver_.set_synchronous_mode(true); |
831 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), | 833 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), |
832 "192.168.0.1", ""); | 834 "192.168.0.1", ""); |
833 | 835 |
834 QuicStreamRequest request(factory_.get()); | 836 QuicStreamRequest request(factory_.get()); |
835 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_, | 837 EXPECT_EQ(OK, request.Request(host_port_pair_, version_, privacy_mode_, |
836 /*cert_verify_flags=*/0, url_, "POST", net_log_, | 838 /*cert_verify_flags=*/0, url_, "POST", net_log_, |
837 callback_.callback())); | 839 callback_.callback())); |
838 | 840 |
839 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 841 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
840 EXPECT_TRUE(stream.get()); | 842 EXPECT_TRUE(stream.get()); |
841 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 843 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
842 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 844 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
843 } | 845 } |
844 | 846 |
845 TEST_P(QuicStreamFactoryTest, DefaultInitialRtt) { | 847 TEST_P(QuicStreamFactoryTest, DefaultInitialRtt) { |
846 Initialize(); | 848 Initialize(); |
847 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 849 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
848 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 850 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
849 | 851 |
850 MockQuicData socket_data; | 852 MockQuicData socket_data; |
851 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 853 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
852 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 854 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
853 socket_data.AddSocketDataToFactory(&socket_factory_); | 855 socket_data.AddSocketDataToFactory(&socket_factory_); |
854 | 856 |
855 QuicStreamRequest request(factory_.get()); | 857 QuicStreamRequest request(factory_.get()); |
856 EXPECT_EQ(ERR_IO_PENDING, | 858 EXPECT_EQ(ERR_IO_PENDING, |
857 request.Request(host_port_pair_, privacy_mode_, | 859 request.Request(host_port_pair_, version_, privacy_mode_, |
858 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 860 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
859 callback_.callback())); | 861 callback_.callback())); |
860 | 862 |
861 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 863 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
862 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 864 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
863 EXPECT_TRUE(stream.get()); | 865 EXPECT_TRUE(stream.get()); |
864 | 866 |
865 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); | 867 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); |
866 EXPECT_EQ(100000u, session->connection()->GetStats().srtt_us); | 868 EXPECT_EQ(100000u, session->connection()->GetStats().srtt_us); |
867 ASSERT_FALSE(session->config()->HasInitialRoundTripTimeUsToSend()); | 869 ASSERT_FALSE(session->config()->HasInitialRoundTripTimeUsToSend()); |
(...skipping 10 matching lines...) Expand all Loading... |
878 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 880 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
879 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 881 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
880 | 882 |
881 MockQuicData socket_data; | 883 MockQuicData socket_data; |
882 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 884 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
883 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 885 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
884 socket_data.AddSocketDataToFactory(&socket_factory_); | 886 socket_data.AddSocketDataToFactory(&socket_factory_); |
885 | 887 |
886 QuicStreamRequest request(factory_.get()); | 888 QuicStreamRequest request(factory_.get()); |
887 EXPECT_EQ(ERR_IO_PENDING, | 889 EXPECT_EQ(ERR_IO_PENDING, |
888 request.Request(host_port_pair_, privacy_mode_, | 890 request.Request(host_port_pair_, version_, privacy_mode_, |
889 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 891 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
890 callback_.callback())); | 892 callback_.callback())); |
891 | 893 |
892 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 894 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
893 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 895 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
894 EXPECT_TRUE(stream.get()); | 896 EXPECT_TRUE(stream.get()); |
895 | 897 |
896 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); | 898 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); |
897 EXPECT_EQ(10000u, session->connection()->GetStats().srtt_us); | 899 EXPECT_EQ(10000u, session->connection()->GetStats().srtt_us); |
898 ASSERT_TRUE(session->config()->HasInitialRoundTripTimeUsToSend()); | 900 ASSERT_TRUE(session->config()->HasInitialRoundTripTimeUsToSend()); |
(...skipping 10 matching lines...) Expand all Loading... |
909 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 911 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
910 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 912 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
911 | 913 |
912 MockQuicData socket_data; | 914 MockQuicData socket_data; |
913 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 915 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
914 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 916 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
915 socket_data.AddSocketDataToFactory(&socket_factory_); | 917 socket_data.AddSocketDataToFactory(&socket_factory_); |
916 | 918 |
917 QuicStreamRequest request(factory_.get()); | 919 QuicStreamRequest request(factory_.get()); |
918 EXPECT_EQ(ERR_IO_PENDING, | 920 EXPECT_EQ(ERR_IO_PENDING, |
919 request.Request(host_port_pair_, privacy_mode_, | 921 request.Request(host_port_pair_, version_, privacy_mode_, |
920 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 922 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
921 callback_.callback())); | 923 callback_.callback())); |
922 | 924 |
923 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 925 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
924 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 926 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
925 EXPECT_TRUE(stream.get()); | 927 EXPECT_TRUE(stream.get()); |
926 | 928 |
927 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); | 929 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); |
928 EXPECT_EQ(1200000u, session->connection()->GetStats().srtt_us); | 930 EXPECT_EQ(1200000u, session->connection()->GetStats().srtt_us); |
929 ASSERT_TRUE(session->config()->HasInitialRoundTripTimeUsToSend()); | 931 ASSERT_TRUE(session->config()->HasInitialRoundTripTimeUsToSend()); |
(...skipping 10 matching lines...) Expand all Loading... |
940 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 942 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
941 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 943 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
942 | 944 |
943 MockQuicData socket_data; | 945 MockQuicData socket_data; |
944 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 946 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
945 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 947 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
946 socket_data.AddSocketDataToFactory(&socket_factory_); | 948 socket_data.AddSocketDataToFactory(&socket_factory_); |
947 | 949 |
948 QuicStreamRequest request(factory_.get()); | 950 QuicStreamRequest request(factory_.get()); |
949 EXPECT_EQ(ERR_IO_PENDING, | 951 EXPECT_EQ(ERR_IO_PENDING, |
950 request.Request(host_port_pair_, privacy_mode_, | 952 request.Request(host_port_pair_, version_, privacy_mode_, |
951 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 953 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
952 callback_.callback())); | 954 callback_.callback())); |
953 | 955 |
954 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 956 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
955 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 957 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
956 EXPECT_TRUE(stream.get()); | 958 EXPECT_TRUE(stream.get()); |
957 | 959 |
958 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); | 960 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); |
959 EXPECT_EQ(400000u, session->connection()->GetStats().srtt_us); | 961 EXPECT_EQ(400000u, session->connection()->GetStats().srtt_us); |
960 ASSERT_TRUE(session->config()->HasInitialRoundTripTimeUsToSend()); | 962 ASSERT_TRUE(session->config()->HasInitialRoundTripTimeUsToSend()); |
961 EXPECT_EQ(400000u, session->config()->GetInitialRoundTripTimeUsToSend()); | 963 EXPECT_EQ(400000u, session->config()->GetInitialRoundTripTimeUsToSend()); |
962 } | 964 } |
963 | 965 |
964 TEST_P(QuicStreamFactoryTest, GoAway) { | 966 TEST_P(QuicStreamFactoryTest, GoAway) { |
965 Initialize(); | 967 Initialize(); |
966 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 968 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
967 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 969 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
968 | 970 |
969 MockQuicData socket_data; | 971 MockQuicData socket_data; |
970 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 972 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
971 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 973 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
972 socket_data.AddSocketDataToFactory(&socket_factory_); | 974 socket_data.AddSocketDataToFactory(&socket_factory_); |
973 | 975 |
974 QuicStreamRequest request(factory_.get()); | 976 QuicStreamRequest request(factory_.get()); |
975 EXPECT_EQ(ERR_IO_PENDING, | 977 EXPECT_EQ(ERR_IO_PENDING, |
976 request.Request(host_port_pair_, privacy_mode_, | 978 request.Request(host_port_pair_, version_, privacy_mode_, |
977 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 979 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
978 callback_.callback())); | 980 callback_.callback())); |
979 | 981 |
980 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 982 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
981 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 983 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
982 EXPECT_TRUE(stream.get()); | 984 EXPECT_TRUE(stream.get()); |
983 | 985 |
984 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); | 986 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); |
985 | 987 |
986 session->OnGoAway(QuicGoAwayFrame()); | 988 session->OnGoAway(QuicGoAwayFrame()); |
987 | 989 |
988 EXPECT_FALSE(HasActiveSession(host_port_pair_)); | 990 EXPECT_FALSE(HasActiveSession(host_port_pair_)); |
989 | 991 |
990 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 992 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
991 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 993 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
992 } | 994 } |
993 | 995 |
994 TEST_P(QuicStreamFactoryTest, GoAwayForConnectionMigrationWithPortOnly) { | 996 TEST_P(QuicStreamFactoryTest, GoAwayForConnectionMigrationWithPortOnly) { |
995 Initialize(); | 997 Initialize(); |
996 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 998 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
997 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 999 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
998 | 1000 |
999 MockQuicData socket_data; | 1001 MockQuicData socket_data; |
1000 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 1002 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
1001 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 1003 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
1002 socket_data.AddSocketDataToFactory(&socket_factory_); | 1004 socket_data.AddSocketDataToFactory(&socket_factory_); |
1003 | 1005 |
1004 QuicStreamRequest request(factory_.get()); | 1006 QuicStreamRequest request(factory_.get()); |
1005 EXPECT_EQ(ERR_IO_PENDING, | 1007 EXPECT_EQ(ERR_IO_PENDING, |
1006 request.Request(host_port_pair_, privacy_mode_, | 1008 request.Request(host_port_pair_, version_, privacy_mode_, |
1007 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1009 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1008 callback_.callback())); | 1010 callback_.callback())); |
1009 | 1011 |
1010 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 1012 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
1011 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 1013 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
1012 EXPECT_TRUE(stream.get()); | 1014 EXPECT_TRUE(stream.get()); |
1013 | 1015 |
1014 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); | 1016 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); |
1015 | 1017 |
1016 session->OnGoAway( | 1018 session->OnGoAway( |
(...skipping 23 matching lines...) Expand all Loading... |
1040 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 1042 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
1041 socket_data.AddSocketDataToFactory(&socket_factory_); | 1043 socket_data.AddSocketDataToFactory(&socket_factory_); |
1042 | 1044 |
1043 HostPortPair server2(kServer2HostName, kDefaultServerPort); | 1045 HostPortPair server2(kServer2HostName, kDefaultServerPort); |
1044 host_resolver_.set_synchronous_mode(true); | 1046 host_resolver_.set_synchronous_mode(true); |
1045 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), | 1047 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), |
1046 "192.168.0.1", ""); | 1048 "192.168.0.1", ""); |
1047 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); | 1049 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); |
1048 | 1050 |
1049 QuicStreamRequest request(factory_.get()); | 1051 QuicStreamRequest request(factory_.get()); |
1050 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_, | 1052 EXPECT_EQ(OK, request.Request(host_port_pair_, version_, privacy_mode_, |
1051 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1053 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1052 callback_.callback())); | 1054 callback_.callback())); |
1053 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 1055 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
1054 EXPECT_TRUE(stream.get()); | 1056 EXPECT_TRUE(stream.get()); |
1055 | 1057 |
1056 TestCompletionCallback callback; | 1058 TestCompletionCallback callback; |
1057 QuicStreamRequest request2(factory_.get()); | 1059 QuicStreamRequest request2(factory_.get()); |
1058 EXPECT_EQ(OK, request2.Request(server2, privacy_mode_, | 1060 EXPECT_EQ(OK, request2.Request(server2, version_, privacy_mode_, |
1059 /*cert_verify_flags=*/0, url2_, "GET", | 1061 /*cert_verify_flags=*/0, url2_, "GET", |
1060 net_log_, callback.callback())); | 1062 net_log_, callback.callback())); |
1061 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 1063 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
1062 EXPECT_TRUE(stream2.get()); | 1064 EXPECT_TRUE(stream2.get()); |
1063 | 1065 |
1064 EXPECT_EQ(GetActiveSession(host_port_pair_), GetActiveSession(server2)); | 1066 EXPECT_EQ(GetActiveSession(host_port_pair_), GetActiveSession(server2)); |
1065 | 1067 |
1066 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 1068 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
1067 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 1069 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
1068 } | 1070 } |
(...skipping 29 matching lines...) Expand all Loading... |
1098 | 1100 |
1099 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 1101 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
1100 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 1102 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
1101 QuicConfig config2; | 1103 QuicConfig config2; |
1102 crypto_client_stream_factory_.SetConfig(config2); | 1104 crypto_client_stream_factory_.SetConfig(config2); |
1103 | 1105 |
1104 // Create new request to cause new session creation. | 1106 // Create new request to cause new session creation. |
1105 TestCompletionCallback callback; | 1107 TestCompletionCallback callback; |
1106 QuicStreamRequest request2(factory_.get()); | 1108 QuicStreamRequest request2(factory_.get()); |
1107 EXPECT_EQ(ERR_IO_PENDING, | 1109 EXPECT_EQ(ERR_IO_PENDING, |
1108 request2.Request(server2, privacy_mode_, | 1110 request2.Request(server2, version_, privacy_mode_, |
1109 /*cert_verify_flags=*/0, url2_, "GET", net_log_, | 1111 /*cert_verify_flags=*/0, url2_, "GET", net_log_, |
1110 callback.callback())); | 1112 callback.callback())); |
1111 EXPECT_EQ(OK, callback.WaitForResult()); | 1113 EXPECT_EQ(OK, callback.WaitForResult()); |
1112 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 1114 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
1113 EXPECT_TRUE(stream2.get()); | 1115 EXPECT_TRUE(stream2.get()); |
1114 | 1116 |
1115 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 1117 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
1116 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 1118 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
1117 // EXPECT_EQ(GetActiveSession(host_port_pair_), GetActiveSession(server2)); | 1119 // EXPECT_EQ(GetActiveSession(host_port_pair_), GetActiveSession(server2)); |
1118 } | 1120 } |
(...skipping 13 matching lines...) Expand all Loading... |
1132 socket_data2.AddWrite(ConstructInitialSettingsPacket()); | 1134 socket_data2.AddWrite(ConstructInitialSettingsPacket()); |
1133 socket_data2.AddSocketDataToFactory(&socket_factory_); | 1135 socket_data2.AddSocketDataToFactory(&socket_factory_); |
1134 | 1136 |
1135 HostPortPair server2(kServer2HostName, kDefaultServerPort); | 1137 HostPortPair server2(kServer2HostName, kDefaultServerPort); |
1136 host_resolver_.set_synchronous_mode(true); | 1138 host_resolver_.set_synchronous_mode(true); |
1137 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), | 1139 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), |
1138 "192.168.0.1", ""); | 1140 "192.168.0.1", ""); |
1139 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); | 1141 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); |
1140 | 1142 |
1141 QuicStreamRequest request(factory_.get()); | 1143 QuicStreamRequest request(factory_.get()); |
1142 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_, | 1144 EXPECT_EQ(OK, request.Request(host_port_pair_, version_, privacy_mode_, |
1143 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1145 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1144 callback_.callback())); | 1146 callback_.callback())); |
1145 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 1147 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
1146 EXPECT_TRUE(stream.get()); | 1148 EXPECT_TRUE(stream.get()); |
1147 | 1149 |
1148 TestCompletionCallback callback; | 1150 TestCompletionCallback callback; |
1149 QuicStreamRequest request2(factory_.get()); | 1151 QuicStreamRequest request2(factory_.get()); |
1150 EXPECT_EQ(OK, request2.Request(server2, privacy_mode_, | 1152 EXPECT_EQ(OK, request2.Request(server2, version_, privacy_mode_, |
1151 /*cert_verify_flags=*/0, url2_, "GET", | 1153 /*cert_verify_flags=*/0, url2_, "GET", |
1152 net_log_, callback.callback())); | 1154 net_log_, callback.callback())); |
1153 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 1155 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
1154 EXPECT_TRUE(stream2.get()); | 1156 EXPECT_TRUE(stream2.get()); |
1155 | 1157 |
1156 factory_->OnSessionGoingAway(GetActiveSession(host_port_pair_)); | 1158 factory_->OnSessionGoingAway(GetActiveSession(host_port_pair_)); |
1157 EXPECT_FALSE(HasActiveSession(host_port_pair_)); | 1159 EXPECT_FALSE(HasActiveSession(host_port_pair_)); |
1158 EXPECT_FALSE(HasActiveSession(server2)); | 1160 EXPECT_FALSE(HasActiveSession(server2)); |
1159 | 1161 |
1160 TestCompletionCallback callback3; | 1162 TestCompletionCallback callback3; |
1161 QuicStreamRequest request3(factory_.get()); | 1163 QuicStreamRequest request3(factory_.get()); |
1162 EXPECT_EQ(OK, request3.Request(server2, privacy_mode_, | 1164 EXPECT_EQ(OK, request3.Request(server2, version_, privacy_mode_, |
1163 /*cert_verify_flags=*/0, url2_, "GET", | 1165 /*cert_verify_flags=*/0, url2_, "GET", |
1164 net_log_, callback3.callback())); | 1166 net_log_, callback3.callback())); |
1165 std::unique_ptr<HttpStream> stream3 = request3.CreateStream(); | 1167 std::unique_ptr<HttpStream> stream3 = request3.CreateStream(); |
1166 EXPECT_TRUE(stream3.get()); | 1168 EXPECT_TRUE(stream3.get()); |
1167 | 1169 |
1168 EXPECT_TRUE(HasActiveSession(server2)); | 1170 EXPECT_TRUE(HasActiveSession(server2)); |
1169 | 1171 |
1170 EXPECT_TRUE(socket_data1.AllReadDataConsumed()); | 1172 EXPECT_TRUE(socket_data1.AllReadDataConsumed()); |
1171 EXPECT_TRUE(socket_data1.AllWriteDataConsumed()); | 1173 EXPECT_TRUE(socket_data1.AllWriteDataConsumed()); |
1172 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); | 1174 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); |
(...skipping 12 matching lines...) Expand all Loading... |
1185 HostPortPair server2(kServer2HostName, 443); | 1187 HostPortPair server2(kServer2HostName, 443); |
1186 | 1188 |
1187 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 1189 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
1188 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 1190 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
1189 | 1191 |
1190 host_resolver_.set_synchronous_mode(true); | 1192 host_resolver_.set_synchronous_mode(true); |
1191 host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", ""); | 1193 host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", ""); |
1192 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); | 1194 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); |
1193 | 1195 |
1194 QuicStreamRequest request(factory_.get()); | 1196 QuicStreamRequest request(factory_.get()); |
1195 EXPECT_EQ(OK, request.Request(server1, privacy_mode_, | 1197 EXPECT_EQ(OK, request.Request(server1, version_, privacy_mode_, |
1196 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1198 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1197 callback_.callback())); | 1199 callback_.callback())); |
1198 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 1200 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
1199 EXPECT_TRUE(stream.get()); | 1201 EXPECT_TRUE(stream.get()); |
1200 | 1202 |
1201 TestCompletionCallback callback; | 1203 TestCompletionCallback callback; |
1202 QuicStreamRequest request2(factory_.get()); | 1204 QuicStreamRequest request2(factory_.get()); |
1203 EXPECT_EQ(OK, request2.Request(server2, privacy_mode_, | 1205 EXPECT_EQ(OK, request2.Request(server2, version_, privacy_mode_, |
1204 /*cert_verify_flags=*/0, url2_, "GET", | 1206 /*cert_verify_flags=*/0, url2_, "GET", |
1205 net_log_, callback_.callback())); | 1207 net_log_, callback_.callback())); |
1206 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 1208 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
1207 EXPECT_TRUE(stream2.get()); | 1209 EXPECT_TRUE(stream2.get()); |
1208 | 1210 |
1209 EXPECT_EQ(GetActiveSession(server1), GetActiveSession(server2)); | 1211 EXPECT_EQ(GetActiveSession(server1), GetActiveSession(server2)); |
1210 | 1212 |
1211 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 1213 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
1212 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 1214 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
1213 } | 1215 } |
(...skipping 15 matching lines...) Expand all Loading... |
1229 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 1231 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
1230 verify_details.cert_verify_result.public_key_hashes.push_back( | 1232 verify_details.cert_verify_result.public_key_hashes.push_back( |
1231 test::GetTestHashValue(primary_pin)); | 1233 test::GetTestHashValue(primary_pin)); |
1232 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 1234 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
1233 | 1235 |
1234 host_resolver_.set_synchronous_mode(true); | 1236 host_resolver_.set_synchronous_mode(true); |
1235 host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", ""); | 1237 host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", ""); |
1236 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); | 1238 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); |
1237 | 1239 |
1238 QuicStreamRequest request(factory_.get()); | 1240 QuicStreamRequest request(factory_.get()); |
1239 EXPECT_EQ(OK, request.Request(server1, privacy_mode_, | 1241 EXPECT_EQ(OK, request.Request(server1, version_, privacy_mode_, |
1240 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1242 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1241 callback_.callback())); | 1243 callback_.callback())); |
1242 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 1244 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
1243 EXPECT_TRUE(stream.get()); | 1245 EXPECT_TRUE(stream.get()); |
1244 | 1246 |
1245 TestCompletionCallback callback; | 1247 TestCompletionCallback callback; |
1246 QuicStreamRequest request2(factory_.get()); | 1248 QuicStreamRequest request2(factory_.get()); |
1247 EXPECT_EQ(OK, request2.Request(server2, privacy_mode_, | 1249 EXPECT_EQ(OK, request2.Request(server2, version_, privacy_mode_, |
1248 /*cert_verify_flags=*/0, url2_, "GET", | 1250 /*cert_verify_flags=*/0, url2_, "GET", |
1249 net_log_, callback_.callback())); | 1251 net_log_, callback_.callback())); |
1250 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 1252 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
1251 EXPECT_TRUE(stream2.get()); | 1253 EXPECT_TRUE(stream2.get()); |
1252 | 1254 |
1253 EXPECT_EQ(GetActiveSession(server1), GetActiveSession(server2)); | 1255 EXPECT_EQ(GetActiveSession(server1), GetActiveSession(server2)); |
1254 | 1256 |
1255 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 1257 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
1256 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 1258 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
1257 } | 1259 } |
(...skipping 26 matching lines...) Expand all Loading... |
1284 ProofVerifyDetailsChromium verify_details2 = DefaultProofVerifyDetails(); | 1286 ProofVerifyDetailsChromium verify_details2 = DefaultProofVerifyDetails(); |
1285 verify_details2.cert_verify_result.public_key_hashes.push_back( | 1287 verify_details2.cert_verify_result.public_key_hashes.push_back( |
1286 test::GetTestHashValue(primary_pin)); | 1288 test::GetTestHashValue(primary_pin)); |
1287 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details2); | 1289 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details2); |
1288 | 1290 |
1289 host_resolver_.set_synchronous_mode(true); | 1291 host_resolver_.set_synchronous_mode(true); |
1290 host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", ""); | 1292 host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", ""); |
1291 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); | 1293 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); |
1292 | 1294 |
1293 QuicStreamRequest request(factory_.get()); | 1295 QuicStreamRequest request(factory_.get()); |
1294 EXPECT_EQ(OK, request.Request(server1, privacy_mode_, | 1296 EXPECT_EQ(OK, request.Request(server1, version_, privacy_mode_, |
1295 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1297 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1296 callback_.callback())); | 1298 callback_.callback())); |
1297 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 1299 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
1298 EXPECT_TRUE(stream.get()); | 1300 EXPECT_TRUE(stream.get()); |
1299 | 1301 |
1300 TestCompletionCallback callback; | 1302 TestCompletionCallback callback; |
1301 QuicStreamRequest request2(factory_.get()); | 1303 QuicStreamRequest request2(factory_.get()); |
1302 EXPECT_EQ(OK, request2.Request(server2, privacy_mode_, | 1304 EXPECT_EQ(OK, request2.Request(server2, version_, privacy_mode_, |
1303 /*cert_verify_flags=*/0, url2_, "GET", | 1305 /*cert_verify_flags=*/0, url2_, "GET", |
1304 net_log_, callback_.callback())); | 1306 net_log_, callback_.callback())); |
1305 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 1307 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
1306 EXPECT_TRUE(stream2.get()); | 1308 EXPECT_TRUE(stream2.get()); |
1307 | 1309 |
1308 EXPECT_NE(GetActiveSession(server1), GetActiveSession(server2)); | 1310 EXPECT_NE(GetActiveSession(server1), GetActiveSession(server2)); |
1309 | 1311 |
1310 EXPECT_TRUE(socket_data1.AllReadDataConsumed()); | 1312 EXPECT_TRUE(socket_data1.AllReadDataConsumed()); |
1311 EXPECT_TRUE(socket_data1.AllWriteDataConsumed()); | 1313 EXPECT_TRUE(socket_data1.AllWriteDataConsumed()); |
1312 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); | 1314 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); |
(...skipping 10 matching lines...) Expand all Loading... |
1323 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 1325 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
1324 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 1326 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
1325 socket_data.AddSocketDataToFactory(&socket_factory_); | 1327 socket_data.AddSocketDataToFactory(&socket_factory_); |
1326 MockQuicData socket_data2; | 1328 MockQuicData socket_data2; |
1327 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 1329 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
1328 socket_data2.AddWrite(ConstructInitialSettingsPacket()); | 1330 socket_data2.AddWrite(ConstructInitialSettingsPacket()); |
1329 socket_data2.AddSocketDataToFactory(&socket_factory_); | 1331 socket_data2.AddSocketDataToFactory(&socket_factory_); |
1330 | 1332 |
1331 QuicStreamRequest request(factory_.get()); | 1333 QuicStreamRequest request(factory_.get()); |
1332 EXPECT_EQ(ERR_IO_PENDING, | 1334 EXPECT_EQ(ERR_IO_PENDING, |
1333 request.Request(host_port_pair_, privacy_mode_, | 1335 request.Request(host_port_pair_, version_, privacy_mode_, |
1334 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1336 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1335 callback_.callback())); | 1337 callback_.callback())); |
1336 | 1338 |
1337 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 1339 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
1338 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 1340 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
1339 EXPECT_TRUE(stream.get()); | 1341 EXPECT_TRUE(stream.get()); |
1340 | 1342 |
1341 // Mark the session as going away. Ensure that while it is still alive | 1343 // Mark the session as going away. Ensure that while it is still alive |
1342 // that it is no longer active. | 1344 // that it is no longer active. |
1343 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); | 1345 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); |
1344 factory_->OnSessionGoingAway(session); | 1346 factory_->OnSessionGoingAway(session); |
1345 EXPECT_EQ(true, | 1347 EXPECT_EQ(true, |
1346 QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session)); | 1348 QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session)); |
1347 EXPECT_FALSE(HasActiveSession(host_port_pair_)); | 1349 EXPECT_FALSE(HasActiveSession(host_port_pair_)); |
1348 | 1350 |
1349 // Create a new request for the same destination and verify that a | 1351 // Create a new request for the same destination and verify that a |
1350 // new session is created. | 1352 // new session is created. |
1351 QuicStreamRequest request2(factory_.get()); | 1353 QuicStreamRequest request2(factory_.get()); |
1352 EXPECT_EQ(ERR_IO_PENDING, | 1354 EXPECT_EQ(ERR_IO_PENDING, |
1353 request2.Request(host_port_pair_, privacy_mode_, | 1355 request2.Request(host_port_pair_, version_, privacy_mode_, |
1354 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1356 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1355 callback_.callback())); | 1357 callback_.callback())); |
1356 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 1358 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
1357 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 1359 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
1358 EXPECT_TRUE(stream2.get()); | 1360 EXPECT_TRUE(stream2.get()); |
1359 | 1361 |
1360 EXPECT_TRUE(HasActiveSession(host_port_pair_)); | 1362 EXPECT_TRUE(HasActiveSession(host_port_pair_)); |
1361 EXPECT_NE(session, GetActiveSession(host_port_pair_)); | 1363 EXPECT_NE(session, GetActiveSession(host_port_pair_)); |
1362 EXPECT_EQ(true, | 1364 EXPECT_EQ(true, |
1363 QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session)); | 1365 QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session)); |
(...skipping 21 matching lines...) Expand all Loading... |
1385 server_maker_.MakeRstPacket(1, false, stream_id, QUIC_STREAM_CANCELLED)); | 1387 server_maker_.MakeRstPacket(1, false, stream_id, QUIC_STREAM_CANCELLED)); |
1386 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 1388 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
1387 socket_data.AddSocketDataToFactory(&socket_factory_); | 1389 socket_data.AddSocketDataToFactory(&socket_factory_); |
1388 | 1390 |
1389 HttpRequestInfo request_info; | 1391 HttpRequestInfo request_info; |
1390 std::vector<std::unique_ptr<HttpStream>> streams; | 1392 std::vector<std::unique_ptr<HttpStream>> streams; |
1391 // The MockCryptoClientStream sets max_open_streams to be | 1393 // The MockCryptoClientStream sets max_open_streams to be |
1392 // kDefaultMaxStreamsPerConnection / 2. | 1394 // kDefaultMaxStreamsPerConnection / 2. |
1393 for (size_t i = 0; i < kDefaultMaxStreamsPerConnection / 2; i++) { | 1395 for (size_t i = 0; i < kDefaultMaxStreamsPerConnection / 2; i++) { |
1394 QuicStreamRequest request(factory_.get()); | 1396 QuicStreamRequest request(factory_.get()); |
1395 int rv = request.Request(host_port_pair_, privacy_mode_, | 1397 int rv = request.Request(host_port_pair_, version_, privacy_mode_, |
1396 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1398 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1397 callback_.callback()); | 1399 callback_.callback()); |
1398 if (i == 0) { | 1400 if (i == 0) { |
1399 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); | 1401 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
1400 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 1402 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
1401 } else { | 1403 } else { |
1402 EXPECT_THAT(rv, IsOk()); | 1404 EXPECT_THAT(rv, IsOk()); |
1403 } | 1405 } |
1404 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 1406 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
1405 EXPECT_TRUE(stream); | 1407 EXPECT_TRUE(stream); |
1406 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 1408 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
1407 net_log_, CompletionCallback())); | 1409 net_log_, CompletionCallback())); |
1408 streams.push_back(std::move(stream)); | 1410 streams.push_back(std::move(stream)); |
1409 } | 1411 } |
1410 | 1412 |
1411 QuicStreamRequest request(factory_.get()); | 1413 QuicStreamRequest request(factory_.get()); |
1412 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_, | 1414 EXPECT_EQ(OK, request.Request(host_port_pair_, version_, privacy_mode_, |
1413 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1415 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1414 CompletionCallback())); | 1416 CompletionCallback())); |
1415 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 1417 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
1416 EXPECT_TRUE(stream); | 1418 EXPECT_TRUE(stream); |
1417 EXPECT_EQ(ERR_IO_PENDING, | 1419 EXPECT_EQ(ERR_IO_PENDING, |
1418 stream->InitializeStream(&request_info, DEFAULT_PRIORITY, net_log_, | 1420 stream->InitializeStream(&request_info, DEFAULT_PRIORITY, net_log_, |
1419 callback_.callback())); | 1421 callback_.callback())); |
1420 | 1422 |
1421 // Close the first stream. | 1423 // Close the first stream. |
1422 streams.front()->Close(false); | 1424 streams.front()->Close(false); |
(...skipping 14 matching lines...) Expand all Loading... |
1437 | 1439 |
1438 TEST_P(QuicStreamFactoryTest, ResolutionErrorInCreate) { | 1440 TEST_P(QuicStreamFactoryTest, ResolutionErrorInCreate) { |
1439 Initialize(); | 1441 Initialize(); |
1440 MockQuicData socket_data; | 1442 MockQuicData socket_data; |
1441 socket_data.AddSocketDataToFactory(&socket_factory_); | 1443 socket_data.AddSocketDataToFactory(&socket_factory_); |
1442 | 1444 |
1443 host_resolver_.rules()->AddSimulatedFailure(kDefaultServerHostName); | 1445 host_resolver_.rules()->AddSimulatedFailure(kDefaultServerHostName); |
1444 | 1446 |
1445 QuicStreamRequest request(factory_.get()); | 1447 QuicStreamRequest request(factory_.get()); |
1446 EXPECT_EQ(ERR_IO_PENDING, | 1448 EXPECT_EQ(ERR_IO_PENDING, |
1447 request.Request(host_port_pair_, privacy_mode_, | 1449 request.Request(host_port_pair_, version_, privacy_mode_, |
1448 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1450 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1449 callback_.callback())); | 1451 callback_.callback())); |
1450 | 1452 |
1451 EXPECT_THAT(callback_.WaitForResult(), IsError(ERR_NAME_NOT_RESOLVED)); | 1453 EXPECT_THAT(callback_.WaitForResult(), IsError(ERR_NAME_NOT_RESOLVED)); |
1452 | 1454 |
1453 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 1455 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
1454 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 1456 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
1455 } | 1457 } |
1456 | 1458 |
1457 TEST_P(QuicStreamFactoryTest, ConnectErrorInCreate) { | 1459 TEST_P(QuicStreamFactoryTest, ConnectErrorInCreate) { |
1458 Initialize(); | 1460 Initialize(); |
1459 | 1461 |
1460 MockQuicData socket_data; | 1462 MockQuicData socket_data; |
1461 socket_data.AddConnect(SYNCHRONOUS, ERR_ADDRESS_IN_USE); | 1463 socket_data.AddConnect(SYNCHRONOUS, ERR_ADDRESS_IN_USE); |
1462 socket_data.AddSocketDataToFactory(&socket_factory_); | 1464 socket_data.AddSocketDataToFactory(&socket_factory_); |
1463 | 1465 |
1464 QuicStreamRequest request(factory_.get()); | 1466 QuicStreamRequest request(factory_.get()); |
1465 EXPECT_EQ(ERR_IO_PENDING, | 1467 EXPECT_EQ(ERR_IO_PENDING, |
1466 request.Request(host_port_pair_, privacy_mode_, | 1468 request.Request(host_port_pair_, version_, privacy_mode_, |
1467 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1469 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1468 callback_.callback())); | 1470 callback_.callback())); |
1469 | 1471 |
1470 EXPECT_THAT(callback_.WaitForResult(), IsError(ERR_ADDRESS_IN_USE)); | 1472 EXPECT_THAT(callback_.WaitForResult(), IsError(ERR_ADDRESS_IN_USE)); |
1471 | 1473 |
1472 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 1474 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
1473 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 1475 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
1474 } | 1476 } |
1475 | 1477 |
1476 TEST_P(QuicStreamFactoryTest, CancelCreate) { | 1478 TEST_P(QuicStreamFactoryTest, CancelCreate) { |
1477 Initialize(); | 1479 Initialize(); |
1478 MockQuicData socket_data; | 1480 MockQuicData socket_data; |
1479 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 1481 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
1480 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 1482 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
1481 socket_data.AddSocketDataToFactory(&socket_factory_); | 1483 socket_data.AddSocketDataToFactory(&socket_factory_); |
1482 { | 1484 { |
1483 QuicStreamRequest request(factory_.get()); | 1485 QuicStreamRequest request(factory_.get()); |
1484 EXPECT_EQ(ERR_IO_PENDING, | 1486 EXPECT_EQ(ERR_IO_PENDING, |
1485 request.Request(host_port_pair_, privacy_mode_, | 1487 request.Request(host_port_pair_, version_, privacy_mode_, |
1486 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1488 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1487 callback_.callback())); | 1489 callback_.callback())); |
1488 } | 1490 } |
1489 | 1491 |
1490 base::RunLoop().RunUntilIdle(); | 1492 base::RunLoop().RunUntilIdle(); |
1491 | 1493 |
1492 QuicStreamRequest request2(factory_.get()); | 1494 QuicStreamRequest request2(factory_.get()); |
1493 EXPECT_EQ(OK, request2.Request(host_port_pair_, privacy_mode_, | 1495 EXPECT_EQ(OK, request2.Request(host_port_pair_, version_, privacy_mode_, |
1494 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1496 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1495 callback_.callback())); | 1497 callback_.callback())); |
1496 std::unique_ptr<HttpStream> stream = request2.CreateStream(); | 1498 std::unique_ptr<HttpStream> stream = request2.CreateStream(); |
1497 | 1499 |
1498 EXPECT_TRUE(stream.get()); | 1500 EXPECT_TRUE(stream.get()); |
1499 stream.reset(); | 1501 stream.reset(); |
1500 | 1502 |
1501 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 1503 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
1502 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 1504 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
1503 } | 1505 } |
(...skipping 10 matching lines...) Expand all Loading... |
1514 socket_data.AddWrite(ConstructClientRstPacket(2)); | 1516 socket_data.AddWrite(ConstructClientRstPacket(2)); |
1515 socket_data.AddSocketDataToFactory(&socket_factory_); | 1517 socket_data.AddSocketDataToFactory(&socket_factory_); |
1516 | 1518 |
1517 MockQuicData socket_data2; | 1519 MockQuicData socket_data2; |
1518 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 1520 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
1519 socket_data2.AddWrite(ConstructInitialSettingsPacket()); | 1521 socket_data2.AddWrite(ConstructInitialSettingsPacket()); |
1520 socket_data2.AddSocketDataToFactory(&socket_factory_); | 1522 socket_data2.AddSocketDataToFactory(&socket_factory_); |
1521 | 1523 |
1522 QuicStreamRequest request(factory_.get()); | 1524 QuicStreamRequest request(factory_.get()); |
1523 EXPECT_EQ(ERR_IO_PENDING, | 1525 EXPECT_EQ(ERR_IO_PENDING, |
1524 request.Request(host_port_pair_, privacy_mode_, | 1526 request.Request(host_port_pair_, version_, privacy_mode_, |
1525 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1527 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1526 callback_.callback())); | 1528 callback_.callback())); |
1527 | 1529 |
1528 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 1530 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
1529 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 1531 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
1530 HttpRequestInfo request_info; | 1532 HttpRequestInfo request_info; |
1531 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 1533 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
1532 net_log_, CompletionCallback())); | 1534 net_log_, CompletionCallback())); |
1533 | 1535 |
1534 // Close the session and verify that stream saw the error. | 1536 // Close the session and verify that stream saw the error. |
1535 factory_->CloseAllSessions(ERR_INTERNET_DISCONNECTED, QUIC_INTERNAL_ERROR); | 1537 factory_->CloseAllSessions(ERR_INTERNET_DISCONNECTED, QUIC_INTERNAL_ERROR); |
1536 EXPECT_EQ(ERR_INTERNET_DISCONNECTED, | 1538 EXPECT_EQ(ERR_INTERNET_DISCONNECTED, |
1537 stream->ReadResponseHeaders(callback_.callback())); | 1539 stream->ReadResponseHeaders(callback_.callback())); |
1538 | 1540 |
1539 // Now attempting to request a stream to the same origin should create | 1541 // Now attempting to request a stream to the same origin should create |
1540 // a new session. | 1542 // a new session. |
1541 | 1543 |
1542 QuicStreamRequest request2(factory_.get()); | 1544 QuicStreamRequest request2(factory_.get()); |
1543 EXPECT_EQ(ERR_IO_PENDING, | 1545 EXPECT_EQ(ERR_IO_PENDING, |
1544 request2.Request(host_port_pair_, privacy_mode_, | 1546 request2.Request(host_port_pair_, version_, privacy_mode_, |
1545 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1547 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1546 callback_.callback())); | 1548 callback_.callback())); |
1547 | 1549 |
1548 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 1550 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
1549 stream = request2.CreateStream(); | 1551 stream = request2.CreateStream(); |
1550 stream.reset(); // Will reset stream 3. | 1552 stream.reset(); // Will reset stream 3. |
1551 | 1553 |
1552 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 1554 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
1553 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 1555 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
1554 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); | 1556 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); |
(...skipping 13 matching lines...) Expand all Loading... |
1568 | 1570 |
1569 MockQuicData socket_data; | 1571 MockQuicData socket_data; |
1570 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 1572 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
1571 // Trigger PACKET_WRITE_ERROR when sending packets in crypto connect. | 1573 // Trigger PACKET_WRITE_ERROR when sending packets in crypto connect. |
1572 socket_data.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE); | 1574 socket_data.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE); |
1573 socket_data.AddSocketDataToFactory(&socket_factory_); | 1575 socket_data.AddSocketDataToFactory(&socket_factory_); |
1574 | 1576 |
1575 // Create request, should fail after the write of the CHLO fails. | 1577 // Create request, should fail after the write of the CHLO fails. |
1576 QuicStreamRequest request(factory_.get()); | 1578 QuicStreamRequest request(factory_.get()); |
1577 EXPECT_EQ(ERR_IO_PENDING, | 1579 EXPECT_EQ(ERR_IO_PENDING, |
1578 request.Request(host_port_pair_, privacy_mode_, | 1580 request.Request(host_port_pair_, version_, privacy_mode_, |
1579 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1581 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1580 callback_.callback())); | 1582 callback_.callback())); |
1581 EXPECT_EQ(ERR_QUIC_HANDSHAKE_FAILED, callback_.WaitForResult()); | 1583 EXPECT_EQ(ERR_QUIC_HANDSHAKE_FAILED, callback_.WaitForResult()); |
1582 EXPECT_FALSE(HasActiveSession(host_port_pair_)); | 1584 EXPECT_FALSE(HasActiveSession(host_port_pair_)); |
1583 EXPECT_FALSE(HasActiveJob(host_port_pair_, privacy_mode_)); | 1585 EXPECT_FALSE(HasActiveJob(host_port_pair_, privacy_mode_)); |
1584 | 1586 |
1585 // Verify new requests can be sent normally without hanging. | 1587 // Verify new requests can be sent normally without hanging. |
1586 crypto_client_stream_factory_.set_handshake_mode( | 1588 crypto_client_stream_factory_.set_handshake_mode( |
1587 MockCryptoClientStream::COLD_START); | 1589 MockCryptoClientStream::COLD_START); |
1588 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 1590 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
1589 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 1591 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
1590 MockQuicData socket_data2; | 1592 MockQuicData socket_data2; |
1591 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 1593 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
1592 socket_data2.AddWrite(ConstructInitialSettingsPacket()); | 1594 socket_data2.AddWrite(ConstructInitialSettingsPacket()); |
1593 socket_data2.AddSocketDataToFactory(&socket_factory_); | 1595 socket_data2.AddSocketDataToFactory(&socket_factory_); |
1594 | 1596 |
1595 QuicStreamRequest request2(factory_.get()); | 1597 QuicStreamRequest request2(factory_.get()); |
1596 EXPECT_EQ(ERR_IO_PENDING, | 1598 EXPECT_EQ(ERR_IO_PENDING, |
1597 request2.Request(host_port_pair_, privacy_mode_, | 1599 request2.Request(host_port_pair_, version_, privacy_mode_, |
1598 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1600 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1599 callback_.callback())); | 1601 callback_.callback())); |
1600 EXPECT_FALSE(HasActiveSession(host_port_pair_)); | 1602 EXPECT_FALSE(HasActiveSession(host_port_pair_)); |
1601 EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_)); | 1603 EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_)); |
1602 // Run the message loop to complete host resolution. | 1604 // Run the message loop to complete host resolution. |
1603 base::RunLoop().RunUntilIdle(); | 1605 base::RunLoop().RunUntilIdle(); |
1604 | 1606 |
1605 // Complete handshake. QuicStreamFactory::Job should complete and succeed. | 1607 // Complete handshake. QuicStreamFactory::Job should complete and succeed. |
1606 crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( | 1608 crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
1607 QuicSession::HANDSHAKE_CONFIRMED); | 1609 QuicSession::HANDSHAKE_CONFIRMED); |
(...skipping 22 matching lines...) Expand all Loading... |
1630 | 1632 |
1631 MockQuicData socket_data; | 1633 MockQuicData socket_data; |
1632 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 1634 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
1633 // Trigger PACKET_WRITE_ERROR when sending packets in crypto connect. | 1635 // Trigger PACKET_WRITE_ERROR when sending packets in crypto connect. |
1634 socket_data.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE); | 1636 socket_data.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE); |
1635 socket_data.AddSocketDataToFactory(&socket_factory_); | 1637 socket_data.AddSocketDataToFactory(&socket_factory_); |
1636 | 1638 |
1637 // Create request, should fail immediately. | 1639 // Create request, should fail immediately. |
1638 QuicStreamRequest request(factory_.get()); | 1640 QuicStreamRequest request(factory_.get()); |
1639 EXPECT_EQ(ERR_QUIC_HANDSHAKE_FAILED, | 1641 EXPECT_EQ(ERR_QUIC_HANDSHAKE_FAILED, |
1640 request.Request(host_port_pair_, privacy_mode_, | 1642 request.Request(host_port_pair_, version_, privacy_mode_, |
1641 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1643 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1642 callback_.callback())); | 1644 callback_.callback())); |
1643 // Check no active session, or active jobs left for this server. | 1645 // Check no active session, or active jobs left for this server. |
1644 EXPECT_FALSE(HasActiveSession(host_port_pair_)); | 1646 EXPECT_FALSE(HasActiveSession(host_port_pair_)); |
1645 EXPECT_FALSE(HasActiveJob(host_port_pair_, privacy_mode_)); | 1647 EXPECT_FALSE(HasActiveJob(host_port_pair_, privacy_mode_)); |
1646 | 1648 |
1647 // Verify new requests can be sent normally without hanging. | 1649 // Verify new requests can be sent normally without hanging. |
1648 crypto_client_stream_factory_.set_handshake_mode( | 1650 crypto_client_stream_factory_.set_handshake_mode( |
1649 MockCryptoClientStream::COLD_START); | 1651 MockCryptoClientStream::COLD_START); |
1650 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 1652 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
1651 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 1653 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
1652 MockQuicData socket_data2; | 1654 MockQuicData socket_data2; |
1653 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 1655 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
1654 socket_data2.AddWrite(ConstructInitialSettingsPacket()); | 1656 socket_data2.AddWrite(ConstructInitialSettingsPacket()); |
1655 socket_data2.AddSocketDataToFactory(&socket_factory_); | 1657 socket_data2.AddSocketDataToFactory(&socket_factory_); |
1656 | 1658 |
1657 QuicStreamRequest request2(factory_.get()); | 1659 QuicStreamRequest request2(factory_.get()); |
1658 EXPECT_EQ(ERR_IO_PENDING, | 1660 EXPECT_EQ(ERR_IO_PENDING, |
1659 request2.Request(host_port_pair_, privacy_mode_, | 1661 request2.Request(host_port_pair_, version_, privacy_mode_, |
1660 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1662 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1661 callback_.callback())); | 1663 callback_.callback())); |
1662 EXPECT_FALSE(HasActiveSession(host_port_pair_)); | 1664 EXPECT_FALSE(HasActiveSession(host_port_pair_)); |
1663 EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_)); | 1665 EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_)); |
1664 | 1666 |
1665 // Complete handshake. | 1667 // Complete handshake. |
1666 crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( | 1668 crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( |
1667 QuicSession::HANDSHAKE_CONFIRMED); | 1669 QuicSession::HANDSHAKE_CONFIRMED); |
1668 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 1670 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
1669 EXPECT_TRUE(HasActiveSession(host_port_pair_)); | 1671 EXPECT_TRUE(HasActiveSession(host_port_pair_)); |
(...skipping 22 matching lines...) Expand all Loading... |
1692 socket_data.AddWrite(ConstructClientRstPacket(2)); | 1694 socket_data.AddWrite(ConstructClientRstPacket(2)); |
1693 socket_data.AddSocketDataToFactory(&socket_factory_); | 1695 socket_data.AddSocketDataToFactory(&socket_factory_); |
1694 | 1696 |
1695 MockQuicData socket_data2; | 1697 MockQuicData socket_data2; |
1696 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 1698 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
1697 socket_data2.AddWrite(ConstructInitialSettingsPacket()); | 1699 socket_data2.AddWrite(ConstructInitialSettingsPacket()); |
1698 socket_data2.AddSocketDataToFactory(&socket_factory_); | 1700 socket_data2.AddSocketDataToFactory(&socket_factory_); |
1699 | 1701 |
1700 QuicStreamRequest request(factory_.get()); | 1702 QuicStreamRequest request(factory_.get()); |
1701 EXPECT_EQ(ERR_IO_PENDING, | 1703 EXPECT_EQ(ERR_IO_PENDING, |
1702 request.Request(host_port_pair_, privacy_mode_, | 1704 request.Request(host_port_pair_, version_, privacy_mode_, |
1703 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1705 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1704 callback_.callback())); | 1706 callback_.callback())); |
1705 | 1707 |
1706 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 1708 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
1707 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 1709 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
1708 HttpRequestInfo request_info; | 1710 HttpRequestInfo request_info; |
1709 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 1711 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
1710 net_log_, CompletionCallback())); | 1712 net_log_, CompletionCallback())); |
1711 | 1713 |
1712 // Change the IP address and verify that stream saw the error. | 1714 // Change the IP address and verify that stream saw the error. |
1713 NotifyIPAddressChanged(); | 1715 NotifyIPAddressChanged(); |
1714 EXPECT_EQ(ERR_NETWORK_CHANGED, | 1716 EXPECT_EQ(ERR_NETWORK_CHANGED, |
1715 stream->ReadResponseHeaders(callback_.callback())); | 1717 stream->ReadResponseHeaders(callback_.callback())); |
1716 EXPECT_TRUE(factory_->require_confirmation()); | 1718 EXPECT_TRUE(factory_->require_confirmation()); |
1717 | 1719 |
1718 // Now attempting to request a stream to the same origin should create | 1720 // Now attempting to request a stream to the same origin should create |
1719 // a new session. | 1721 // a new session. |
1720 | 1722 |
1721 QuicStreamRequest request2(factory_.get()); | 1723 QuicStreamRequest request2(factory_.get()); |
1722 EXPECT_EQ(ERR_IO_PENDING, | 1724 EXPECT_EQ(ERR_IO_PENDING, |
1723 request2.Request(host_port_pair_, privacy_mode_, | 1725 request2.Request(host_port_pair_, version_, privacy_mode_, |
1724 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1726 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1725 callback_.callback())); | 1727 callback_.callback())); |
1726 | 1728 |
1727 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 1729 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
1728 stream = request2.CreateStream(); | 1730 stream = request2.CreateStream(); |
1729 stream.reset(); // Will reset stream 3. | 1731 stream.reset(); // Will reset stream 3. |
1730 | 1732 |
1731 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 1733 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
1732 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 1734 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
1733 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); | 1735 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); |
(...skipping 26 matching lines...) Expand all Loading... |
1760 &header_stream_offset)); | 1762 &header_stream_offset)); |
1761 if (async_write_before) { | 1763 if (async_write_before) { |
1762 socket_data.AddWrite(ASYNC, OK); | 1764 socket_data.AddWrite(ASYNC, OK); |
1763 packet_number++; | 1765 packet_number++; |
1764 } | 1766 } |
1765 socket_data.AddSocketDataToFactory(&socket_factory_); | 1767 socket_data.AddSocketDataToFactory(&socket_factory_); |
1766 | 1768 |
1767 // Create request and QuicHttpStream. | 1769 // Create request and QuicHttpStream. |
1768 QuicStreamRequest request(factory_.get()); | 1770 QuicStreamRequest request(factory_.get()); |
1769 EXPECT_EQ(ERR_IO_PENDING, | 1771 EXPECT_EQ(ERR_IO_PENDING, |
1770 request.Request(host_port_pair_, privacy_mode_, | 1772 request.Request(host_port_pair_, version_, privacy_mode_, |
1771 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1773 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1772 callback_.callback())); | 1774 callback_.callback())); |
1773 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 1775 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
1774 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 1776 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
1775 EXPECT_TRUE(stream.get()); | 1777 EXPECT_TRUE(stream.get()); |
1776 | 1778 |
1777 // Cause QUIC stream to be created. | 1779 // Cause QUIC stream to be created. |
1778 HttpRequestInfo request_info; | 1780 HttpRequestInfo request_info; |
1779 request_info.method = "GET"; | 1781 request_info.method = "GET"; |
1780 request_info.url = url_; | 1782 request_info.url = url_; |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1827 | 1829 |
1828 // Create a new request for the same destination and verify that a | 1830 // Create a new request for the same destination and verify that a |
1829 // new session is created. | 1831 // new session is created. |
1830 MockQuicData socket_data2; | 1832 MockQuicData socket_data2; |
1831 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 1833 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
1832 socket_data2.AddWrite(ConstructInitialSettingsPacket()); | 1834 socket_data2.AddWrite(ConstructInitialSettingsPacket()); |
1833 socket_data2.AddSocketDataToFactory(&socket_factory_); | 1835 socket_data2.AddSocketDataToFactory(&socket_factory_); |
1834 | 1836 |
1835 QuicStreamRequest request2(factory_.get()); | 1837 QuicStreamRequest request2(factory_.get()); |
1836 EXPECT_EQ(ERR_IO_PENDING, | 1838 EXPECT_EQ(ERR_IO_PENDING, |
1837 request2.Request(host_port_pair_, privacy_mode_, | 1839 request2.Request(host_port_pair_, version_, privacy_mode_, |
1838 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1840 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1839 callback_.callback())); | 1841 callback_.callback())); |
1840 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 1842 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
1841 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 1843 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
1842 EXPECT_TRUE(stream2.get()); | 1844 EXPECT_TRUE(stream2.get()); |
1843 | 1845 |
1844 EXPECT_TRUE(HasActiveSession(host_port_pair_)); | 1846 EXPECT_TRUE(HasActiveSession(host_port_pair_)); |
1845 QuicChromiumClientSession* new_session = GetActiveSession(host_port_pair_); | 1847 QuicChromiumClientSession* new_session = GetActiveSession(host_port_pair_); |
1846 EXPECT_NE(session, new_session); | 1848 EXPECT_NE(session, new_session); |
1847 | 1849 |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1890 &header_stream_offset)); | 1892 &header_stream_offset)); |
1891 if (async_write_before) { | 1893 if (async_write_before) { |
1892 socket_data.AddWrite(ASYNC, OK); | 1894 socket_data.AddWrite(ASYNC, OK); |
1893 packet_number++; | 1895 packet_number++; |
1894 } | 1896 } |
1895 socket_data.AddSocketDataToFactory(&socket_factory_); | 1897 socket_data.AddSocketDataToFactory(&socket_factory_); |
1896 | 1898 |
1897 // Create request and QuicHttpStream. | 1899 // Create request and QuicHttpStream. |
1898 QuicStreamRequest request(factory_.get()); | 1900 QuicStreamRequest request(factory_.get()); |
1899 EXPECT_EQ(ERR_IO_PENDING, | 1901 EXPECT_EQ(ERR_IO_PENDING, |
1900 request.Request(host_port_pair_, privacy_mode_, | 1902 request.Request(host_port_pair_, version_, privacy_mode_, |
1901 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1903 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1902 callback_.callback())); | 1904 callback_.callback())); |
1903 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 1905 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
1904 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 1906 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
1905 EXPECT_TRUE(stream.get()); | 1907 EXPECT_TRUE(stream.get()); |
1906 | 1908 |
1907 // Cause QUIC stream to be created. | 1909 // Cause QUIC stream to be created. |
1908 HttpRequestInfo request_info; | 1910 HttpRequestInfo request_info; |
1909 request_info.method = "GET"; | 1911 request_info.method = "GET"; |
1910 request_info.url = url_; | 1912 request_info.url = url_; |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1952 | 1954 |
1953 // Create a new request for the same destination and verify that a | 1955 // Create a new request for the same destination and verify that a |
1954 // new session is created. | 1956 // new session is created. |
1955 MockQuicData socket_data2; | 1957 MockQuicData socket_data2; |
1956 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 1958 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
1957 socket_data2.AddWrite(ConstructInitialSettingsPacket()); | 1959 socket_data2.AddWrite(ConstructInitialSettingsPacket()); |
1958 socket_data2.AddSocketDataToFactory(&socket_factory_); | 1960 socket_data2.AddSocketDataToFactory(&socket_factory_); |
1959 | 1961 |
1960 QuicStreamRequest request2(factory_.get()); | 1962 QuicStreamRequest request2(factory_.get()); |
1961 EXPECT_EQ(ERR_IO_PENDING, | 1963 EXPECT_EQ(ERR_IO_PENDING, |
1962 request2.Request(host_port_pair_, privacy_mode_, | 1964 request2.Request(host_port_pair_, version_, privacy_mode_, |
1963 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 1965 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
1964 callback_.callback())); | 1966 callback_.callback())); |
1965 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 1967 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
1966 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 1968 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
1967 EXPECT_TRUE(stream2.get()); | 1969 EXPECT_TRUE(stream2.get()); |
1968 | 1970 |
1969 EXPECT_TRUE(HasActiveSession(host_port_pair_)); | 1971 EXPECT_TRUE(HasActiveSession(host_port_pair_)); |
1970 EXPECT_NE(session, GetActiveSession(host_port_pair_)); | 1972 EXPECT_NE(session, GetActiveSession(host_port_pair_)); |
1971 EXPECT_EQ(true, | 1973 EXPECT_EQ(true, |
1972 QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session)); | 1974 QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session)); |
(...skipping 27 matching lines...) Expand all Loading... |
2000 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), runner_.get()); | 2002 QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), runner_.get()); |
2001 | 2003 |
2002 MockQuicData socket_data; | 2004 MockQuicData socket_data; |
2003 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 2005 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
2004 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 2006 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
2005 socket_data.AddSocketDataToFactory(&socket_factory_); | 2007 socket_data.AddSocketDataToFactory(&socket_factory_); |
2006 | 2008 |
2007 // Create request and QuicHttpStream. | 2009 // Create request and QuicHttpStream. |
2008 QuicStreamRequest request(factory_.get()); | 2010 QuicStreamRequest request(factory_.get()); |
2009 EXPECT_EQ(ERR_IO_PENDING, | 2011 EXPECT_EQ(ERR_IO_PENDING, |
2010 request.Request(host_port_pair_, privacy_mode_, | 2012 request.Request(host_port_pair_, version_, privacy_mode_, |
2011 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2013 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2012 callback_.callback())); | 2014 callback_.callback())); |
2013 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 2015 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
2014 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 2016 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
2015 EXPECT_TRUE(stream.get()); | 2017 EXPECT_TRUE(stream.get()); |
2016 | 2018 |
2017 // Cause QUIC stream to be created. | 2019 // Cause QUIC stream to be created. |
2018 HttpRequestInfo request_info; | 2020 HttpRequestInfo request_info; |
2019 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 2021 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
2020 net_log_, CompletionCallback())); | 2022 net_log_, CompletionCallback())); |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2058 MockQuicData socket_data; | 2060 MockQuicData socket_data; |
2059 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 2061 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
2060 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 2062 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
2061 socket_data.AddWrite(client_maker_.MakeRstPacket( | 2063 socket_data.AddWrite(client_maker_.MakeRstPacket( |
2062 2, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); | 2064 2, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); |
2063 socket_data.AddSocketDataToFactory(&socket_factory_); | 2065 socket_data.AddSocketDataToFactory(&socket_factory_); |
2064 | 2066 |
2065 // Create request and QuicHttpStream. | 2067 // Create request and QuicHttpStream. |
2066 QuicStreamRequest request(factory_.get()); | 2068 QuicStreamRequest request(factory_.get()); |
2067 EXPECT_EQ(ERR_IO_PENDING, | 2069 EXPECT_EQ(ERR_IO_PENDING, |
2068 request.Request(host_port_pair_, privacy_mode_, | 2070 request.Request(host_port_pair_, version_, privacy_mode_, |
2069 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2071 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2070 callback_.callback())); | 2072 callback_.callback())); |
2071 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 2073 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
2072 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 2074 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
2073 EXPECT_TRUE(stream.get()); | 2075 EXPECT_TRUE(stream.get()); |
2074 | 2076 |
2075 // Cause QUIC stream to be created, but marked as non-migratable. | 2077 // Cause QUIC stream to be created, but marked as non-migratable. |
2076 HttpRequestInfo request_info; | 2078 HttpRequestInfo request_info; |
2077 request_info.load_flags |= LOAD_DISABLE_CONNECTION_MIGRATION; | 2079 request_info.load_flags |= LOAD_DISABLE_CONNECTION_MIGRATION; |
2078 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 2080 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
(...skipping 28 matching lines...) Expand all Loading... |
2107 MockQuicData socket_data; | 2109 MockQuicData socket_data; |
2108 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 2110 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
2109 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 2111 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
2110 socket_data.AddWrite(client_maker_.MakeRstPacket( | 2112 socket_data.AddWrite(client_maker_.MakeRstPacket( |
2111 2, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); | 2113 2, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); |
2112 socket_data.AddSocketDataToFactory(&socket_factory_); | 2114 socket_data.AddSocketDataToFactory(&socket_factory_); |
2113 | 2115 |
2114 // Create request and QuicHttpStream. | 2116 // Create request and QuicHttpStream. |
2115 QuicStreamRequest request(factory_.get()); | 2117 QuicStreamRequest request(factory_.get()); |
2116 EXPECT_EQ(ERR_IO_PENDING, | 2118 EXPECT_EQ(ERR_IO_PENDING, |
2117 request.Request(host_port_pair_, privacy_mode_, | 2119 request.Request(host_port_pair_, version_, privacy_mode_, |
2118 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2120 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2119 callback_.callback())); | 2121 callback_.callback())); |
2120 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 2122 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
2121 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 2123 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
2122 EXPECT_TRUE(stream.get()); | 2124 EXPECT_TRUE(stream.get()); |
2123 | 2125 |
2124 // Cause QUIC stream to be created. | 2126 // Cause QUIC stream to be created. |
2125 HttpRequestInfo request_info; | 2127 HttpRequestInfo request_info; |
2126 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 2128 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
2127 net_log_, CompletionCallback())); | 2129 net_log_, CompletionCallback())); |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2159 MockQuicData socket_data; | 2161 MockQuicData socket_data; |
2160 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 2162 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
2161 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 2163 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
2162 socket_data.AddWrite(client_maker_.MakeRstPacket( | 2164 socket_data.AddWrite(client_maker_.MakeRstPacket( |
2163 2, true, GetNthClientInitiatedStreamId(0), QUIC_RST_ACKNOWLEDGEMENT)); | 2165 2, true, GetNthClientInitiatedStreamId(0), QUIC_RST_ACKNOWLEDGEMENT)); |
2164 socket_data.AddSocketDataToFactory(&socket_factory_); | 2166 socket_data.AddSocketDataToFactory(&socket_factory_); |
2165 | 2167 |
2166 // Create request and QuicHttpStream. | 2168 // Create request and QuicHttpStream. |
2167 QuicStreamRequest request(factory_.get()); | 2169 QuicStreamRequest request(factory_.get()); |
2168 EXPECT_EQ(ERR_IO_PENDING, | 2170 EXPECT_EQ(ERR_IO_PENDING, |
2169 request.Request(host_port_pair_, privacy_mode_, | 2171 request.Request(host_port_pair_, version_, privacy_mode_, |
2170 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2172 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2171 callback_.callback())); | 2173 callback_.callback())); |
2172 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 2174 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
2173 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 2175 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
2174 EXPECT_TRUE(stream.get()); | 2176 EXPECT_TRUE(stream.get()); |
2175 | 2177 |
2176 // Cause QUIC stream to be created, but marked as non-migratable. | 2178 // Cause QUIC stream to be created, but marked as non-migratable. |
2177 HttpRequestInfo request_info; | 2179 HttpRequestInfo request_info; |
2178 request_info.load_flags |= LOAD_DISABLE_CONNECTION_MIGRATION; | 2180 request_info.load_flags |= LOAD_DISABLE_CONNECTION_MIGRATION; |
2179 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 2181 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
(...skipping 27 matching lines...) Expand all Loading... |
2207 MockQuicData socket_data; | 2209 MockQuicData socket_data; |
2208 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 2210 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
2209 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 2211 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
2210 socket_data.AddWrite(client_maker_.MakeRstPacket( | 2212 socket_data.AddWrite(client_maker_.MakeRstPacket( |
2211 2, true, GetNthClientInitiatedStreamId(0), QUIC_RST_ACKNOWLEDGEMENT)); | 2213 2, true, GetNthClientInitiatedStreamId(0), QUIC_RST_ACKNOWLEDGEMENT)); |
2212 socket_data.AddSocketDataToFactory(&socket_factory_); | 2214 socket_data.AddSocketDataToFactory(&socket_factory_); |
2213 | 2215 |
2214 // Create request and QuicHttpStream. | 2216 // Create request and QuicHttpStream. |
2215 QuicStreamRequest request(factory_.get()); | 2217 QuicStreamRequest request(factory_.get()); |
2216 EXPECT_EQ(ERR_IO_PENDING, | 2218 EXPECT_EQ(ERR_IO_PENDING, |
2217 request.Request(host_port_pair_, privacy_mode_, | 2219 request.Request(host_port_pair_, version_, privacy_mode_, |
2218 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2220 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2219 callback_.callback())); | 2221 callback_.callback())); |
2220 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 2222 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
2221 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 2223 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
2222 EXPECT_TRUE(stream.get()); | 2224 EXPECT_TRUE(stream.get()); |
2223 | 2225 |
2224 // Cause QUIC stream to be created. | 2226 // Cause QUIC stream to be created. |
2225 HttpRequestInfo request_info; | 2227 HttpRequestInfo request_info; |
2226 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 2228 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
2227 net_log_, CompletionCallback())); | 2229 net_log_, CompletionCallback())); |
(...skipping 27 matching lines...) Expand all Loading... |
2255 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 2257 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
2256 | 2258 |
2257 MockQuicData socket_data; | 2259 MockQuicData socket_data; |
2258 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 2260 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
2259 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 2261 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
2260 socket_data.AddSocketDataToFactory(&socket_factory_); | 2262 socket_data.AddSocketDataToFactory(&socket_factory_); |
2261 | 2263 |
2262 // Create request and QuicHttpStream. | 2264 // Create request and QuicHttpStream. |
2263 QuicStreamRequest request(factory_.get()); | 2265 QuicStreamRequest request(factory_.get()); |
2264 EXPECT_EQ(ERR_IO_PENDING, | 2266 EXPECT_EQ(ERR_IO_PENDING, |
2265 request.Request(host_port_pair_, privacy_mode_, | 2267 request.Request(host_port_pair_, version_, privacy_mode_, |
2266 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2268 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2267 callback_.callback())); | 2269 callback_.callback())); |
2268 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 2270 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
2269 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 2271 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
2270 EXPECT_TRUE(stream.get()); | 2272 EXPECT_TRUE(stream.get()); |
2271 | 2273 |
2272 // Ensure that session is alive and active. | 2274 // Ensure that session is alive and active. |
2273 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); | 2275 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); |
2274 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session)); | 2276 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session)); |
2275 EXPECT_TRUE(HasActiveSession(host_port_pair_)); | 2277 EXPECT_TRUE(HasActiveSession(host_port_pair_)); |
(...skipping 17 matching lines...) Expand all Loading... |
2293 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 2295 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
2294 | 2296 |
2295 MockQuicData socket_data; | 2297 MockQuicData socket_data; |
2296 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 2298 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
2297 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 2299 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
2298 socket_data.AddSocketDataToFactory(&socket_factory_); | 2300 socket_data.AddSocketDataToFactory(&socket_factory_); |
2299 | 2301 |
2300 // Create request and QuicHttpStream. | 2302 // Create request and QuicHttpStream. |
2301 QuicStreamRequest request(factory_.get()); | 2303 QuicStreamRequest request(factory_.get()); |
2302 EXPECT_EQ(ERR_IO_PENDING, | 2304 EXPECT_EQ(ERR_IO_PENDING, |
2303 request.Request(host_port_pair_, privacy_mode_, | 2305 request.Request(host_port_pair_, version_, privacy_mode_, |
2304 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2306 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2305 callback_.callback())); | 2307 callback_.callback())); |
2306 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 2308 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
2307 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 2309 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
2308 EXPECT_TRUE(stream.get()); | 2310 EXPECT_TRUE(stream.get()); |
2309 | 2311 |
2310 // Ensure that session is alive and active. | 2312 // Ensure that session is alive and active. |
2311 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); | 2313 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); |
2312 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session)); | 2314 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session)); |
2313 EXPECT_TRUE(HasActiveSession(host_port_pair_)); | 2315 EXPECT_TRUE(HasActiveSession(host_port_pair_)); |
(...skipping 21 matching lines...) Expand all Loading... |
2335 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 2337 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
2336 socket_data.AddWrite( | 2338 socket_data.AddWrite( |
2337 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 2339 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
2338 socket_data.AddWrite(ConstructGetRequestPacket( | 2340 socket_data.AddWrite(ConstructGetRequestPacket( |
2339 2, GetNthClientInitiatedStreamId(0), true, true, &header_stream_offset)); | 2341 2, GetNthClientInitiatedStreamId(0), true, true, &header_stream_offset)); |
2340 socket_data.AddSocketDataToFactory(&socket_factory_); | 2342 socket_data.AddSocketDataToFactory(&socket_factory_); |
2341 | 2343 |
2342 // Create request and QuicHttpStream. | 2344 // Create request and QuicHttpStream. |
2343 QuicStreamRequest request(factory_.get()); | 2345 QuicStreamRequest request(factory_.get()); |
2344 EXPECT_EQ(ERR_IO_PENDING, | 2346 EXPECT_EQ(ERR_IO_PENDING, |
2345 request.Request(host_port_pair_, privacy_mode_, | 2347 request.Request(host_port_pair_, version_, privacy_mode_, |
2346 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2348 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2347 callback_.callback())); | 2349 callback_.callback())); |
2348 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 2350 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
2349 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 2351 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
2350 EXPECT_TRUE(stream.get()); | 2352 EXPECT_TRUE(stream.get()); |
2351 | 2353 |
2352 // Cause QUIC stream to be created. | 2354 // Cause QUIC stream to be created. |
2353 HttpRequestInfo request_info; | 2355 HttpRequestInfo request_info; |
2354 request_info.method = "GET"; | 2356 request_info.method = "GET"; |
2355 request_info.url = url_; | 2357 request_info.url = url_; |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2411 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 2413 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
2412 EXPECT_EQ(200, response.headers->response_code()); | 2414 EXPECT_EQ(200, response.headers->response_code()); |
2413 | 2415 |
2414 // Create a new request and verify that a new session is created. | 2416 // Create a new request and verify that a new session is created. |
2415 MockQuicData socket_data2; | 2417 MockQuicData socket_data2; |
2416 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 2418 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
2417 socket_data2.AddWrite(ConstructInitialSettingsPacket()); | 2419 socket_data2.AddWrite(ConstructInitialSettingsPacket()); |
2418 socket_data2.AddSocketDataToFactory(&socket_factory_); | 2420 socket_data2.AddSocketDataToFactory(&socket_factory_); |
2419 QuicStreamRequest request2(factory_.get()); | 2421 QuicStreamRequest request2(factory_.get()); |
2420 EXPECT_EQ(ERR_IO_PENDING, | 2422 EXPECT_EQ(ERR_IO_PENDING, |
2421 request2.Request(host_port_pair_, privacy_mode_, | 2423 request2.Request(host_port_pair_, version_, privacy_mode_, |
2422 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2424 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2423 callback_.callback())); | 2425 callback_.callback())); |
2424 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 2426 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
2425 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 2427 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
2426 EXPECT_TRUE(stream2.get()); | 2428 EXPECT_TRUE(stream2.get()); |
2427 | 2429 |
2428 EXPECT_TRUE(HasActiveSession(host_port_pair_)); | 2430 EXPECT_TRUE(HasActiveSession(host_port_pair_)); |
2429 EXPECT_NE(session, GetActiveSession(host_port_pair_)); | 2431 EXPECT_NE(session, GetActiveSession(host_port_pair_)); |
2430 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session)); | 2432 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session)); |
2431 | 2433 |
(...skipping 27 matching lines...) Expand all Loading... |
2459 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 2461 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
2460 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 2462 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
2461 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 2463 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
2462 | 2464 |
2463 host_resolver_.set_synchronous_mode(true); | 2465 host_resolver_.set_synchronous_mode(true); |
2464 host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", ""); | 2466 host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", ""); |
2465 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.2", ""); | 2467 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.2", ""); |
2466 | 2468 |
2467 // Create request and QuicHttpStream to create session1. | 2469 // Create request and QuicHttpStream to create session1. |
2468 QuicStreamRequest request1(factory_.get()); | 2470 QuicStreamRequest request1(factory_.get()); |
2469 EXPECT_EQ(OK, request1.Request(server1, privacy_mode_, | 2471 EXPECT_EQ(OK, request1.Request(server1, version_, privacy_mode_, |
2470 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2472 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2471 callback_.callback())); | 2473 callback_.callback())); |
2472 std::unique_ptr<HttpStream> stream1 = request1.CreateStream(); | 2474 std::unique_ptr<HttpStream> stream1 = request1.CreateStream(); |
2473 EXPECT_TRUE(stream1.get()); | 2475 EXPECT_TRUE(stream1.get()); |
2474 | 2476 |
2475 // Create request and QuicHttpStream to create session2. | 2477 // Create request and QuicHttpStream to create session2. |
2476 QuicStreamRequest request2(factory_.get()); | 2478 QuicStreamRequest request2(factory_.get()); |
2477 EXPECT_EQ(OK, request2.Request(server2, privacy_mode_, | 2479 EXPECT_EQ(OK, request2.Request(server2, version_, privacy_mode_, |
2478 /*cert_verify_flags=*/0, url2_, "GET", | 2480 /*cert_verify_flags=*/0, url2_, "GET", |
2479 net_log_, callback_.callback())); | 2481 net_log_, callback_.callback())); |
2480 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 2482 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
2481 EXPECT_TRUE(stream2.get()); | 2483 EXPECT_TRUE(stream2.get()); |
2482 | 2484 |
2483 QuicChromiumClientSession* session1 = GetActiveSession(server1); | 2485 QuicChromiumClientSession* session1 = GetActiveSession(server1); |
2484 QuicChromiumClientSession* session2 = GetActiveSession(server2); | 2486 QuicChromiumClientSession* session2 = GetActiveSession(server2); |
2485 EXPECT_NE(session1, session2); | 2487 EXPECT_NE(session1, session2); |
2486 | 2488 |
2487 // Cause QUIC stream to be created and send GET so session1 has an open | 2489 // Cause QUIC stream to be created and send GET so session1 has an open |
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2552 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 2554 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
2553 socket_data.AddWrite( | 2555 socket_data.AddWrite( |
2554 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 2556 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
2555 socket_data.AddWrite(ConstructGetRequestPacket( | 2557 socket_data.AddWrite(ConstructGetRequestPacket( |
2556 2, GetNthClientInitiatedStreamId(0), true, true, &header_stream_offset)); | 2558 2, GetNthClientInitiatedStreamId(0), true, true, &header_stream_offset)); |
2557 socket_data.AddSocketDataToFactory(&socket_factory_); | 2559 socket_data.AddSocketDataToFactory(&socket_factory_); |
2558 | 2560 |
2559 // Create request and QuicHttpStream. | 2561 // Create request and QuicHttpStream. |
2560 QuicStreamRequest request(factory_.get()); | 2562 QuicStreamRequest request(factory_.get()); |
2561 EXPECT_EQ(ERR_IO_PENDING, | 2563 EXPECT_EQ(ERR_IO_PENDING, |
2562 request.Request(host_port_pair_, privacy_mode_, | 2564 request.Request(host_port_pair_, version_, privacy_mode_, |
2563 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2565 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2564 callback_.callback())); | 2566 callback_.callback())); |
2565 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 2567 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
2566 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 2568 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
2567 EXPECT_TRUE(stream.get()); | 2569 EXPECT_TRUE(stream.get()); |
2568 | 2570 |
2569 // Cause QUIC stream to be created. | 2571 // Cause QUIC stream to be created. |
2570 HttpRequestInfo request_info; | 2572 HttpRequestInfo request_info; |
2571 request_info.method = "GET"; | 2573 request_info.method = "GET"; |
2572 request_info.url = url_; | 2574 request_info.url = url_; |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2616 | 2618 |
2617 // Create a new request for the same destination and verify that a | 2619 // Create a new request for the same destination and verify that a |
2618 // new session is created. | 2620 // new session is created. |
2619 MockQuicData socket_data2; | 2621 MockQuicData socket_data2; |
2620 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 2622 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
2621 socket_data2.AddWrite(ConstructInitialSettingsPacket()); | 2623 socket_data2.AddWrite(ConstructInitialSettingsPacket()); |
2622 socket_data2.AddSocketDataToFactory(&socket_factory_); | 2624 socket_data2.AddSocketDataToFactory(&socket_factory_); |
2623 | 2625 |
2624 QuicStreamRequest request2(factory_.get()); | 2626 QuicStreamRequest request2(factory_.get()); |
2625 EXPECT_EQ(ERR_IO_PENDING, | 2627 EXPECT_EQ(ERR_IO_PENDING, |
2626 request2.Request(host_port_pair_, privacy_mode_, | 2628 request2.Request(host_port_pair_, version_, privacy_mode_, |
2627 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2629 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2628 callback_.callback())); | 2630 callback_.callback())); |
2629 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 2631 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
2630 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 2632 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
2631 EXPECT_TRUE(stream2.get()); | 2633 EXPECT_TRUE(stream2.get()); |
2632 | 2634 |
2633 EXPECT_TRUE(HasActiveSession(host_port_pair_)); | 2635 EXPECT_TRUE(HasActiveSession(host_port_pair_)); |
2634 QuicChromiumClientSession* new_session = GetActiveSession(host_port_pair_); | 2636 QuicChromiumClientSession* new_session = GetActiveSession(host_port_pair_); |
2635 EXPECT_NE(session, new_session); | 2637 EXPECT_NE(session, new_session); |
2636 | 2638 |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2677 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 2679 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
2678 socket_data.AddWrite( | 2680 socket_data.AddWrite( |
2679 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 2681 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
2680 socket_data.AddWrite(ConstructGetRequestPacket( | 2682 socket_data.AddWrite(ConstructGetRequestPacket( |
2681 2, GetNthClientInitiatedStreamId(0), true, true, &header_stream_offset)); | 2683 2, GetNthClientInitiatedStreamId(0), true, true, &header_stream_offset)); |
2682 socket_data.AddSocketDataToFactory(&socket_factory_); | 2684 socket_data.AddSocketDataToFactory(&socket_factory_); |
2683 | 2685 |
2684 // Create request and QuicHttpStream. | 2686 // Create request and QuicHttpStream. |
2685 QuicStreamRequest request(factory_.get()); | 2687 QuicStreamRequest request(factory_.get()); |
2686 EXPECT_EQ(ERR_IO_PENDING, | 2688 EXPECT_EQ(ERR_IO_PENDING, |
2687 request.Request(host_port_pair_, privacy_mode_, | 2689 request.Request(host_port_pair_, version_, privacy_mode_, |
2688 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2690 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2689 callback_.callback())); | 2691 callback_.callback())); |
2690 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 2692 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
2691 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 2693 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
2692 EXPECT_TRUE(stream.get()); | 2694 EXPECT_TRUE(stream.get()); |
2693 | 2695 |
2694 // Cause QUIC stream to be created. | 2696 // Cause QUIC stream to be created. |
2695 HttpRequestInfo request_info; | 2697 HttpRequestInfo request_info; |
2696 request_info.method = "GET"; | 2698 request_info.method = "GET"; |
2697 request_info.url = url_; | 2699 request_info.url = url_; |
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2743 | 2745 |
2744 // Create a new request for the same destination and verify that a | 2746 // Create a new request for the same destination and verify that a |
2745 // new session is created. | 2747 // new session is created. |
2746 MockQuicData socket_data2; | 2748 MockQuicData socket_data2; |
2747 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 2749 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
2748 socket_data2.AddWrite(ConstructInitialSettingsPacket()); | 2750 socket_data2.AddWrite(ConstructInitialSettingsPacket()); |
2749 socket_data2.AddSocketDataToFactory(&socket_factory_); | 2751 socket_data2.AddSocketDataToFactory(&socket_factory_); |
2750 | 2752 |
2751 QuicStreamRequest request2(factory_.get()); | 2753 QuicStreamRequest request2(factory_.get()); |
2752 EXPECT_EQ(ERR_IO_PENDING, | 2754 EXPECT_EQ(ERR_IO_PENDING, |
2753 request2.Request(host_port_pair_, privacy_mode_, | 2755 request2.Request(host_port_pair_, version_, privacy_mode_, |
2754 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2756 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2755 callback_.callback())); | 2757 callback_.callback())); |
2756 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 2758 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
2757 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 2759 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
2758 EXPECT_TRUE(stream2.get()); | 2760 EXPECT_TRUE(stream2.get()); |
2759 | 2761 |
2760 EXPECT_TRUE(HasActiveSession(host_port_pair_)); | 2762 EXPECT_TRUE(HasActiveSession(host_port_pair_)); |
2761 QuicChromiumClientSession* new_session = GetActiveSession(host_port_pair_); | 2763 QuicChromiumClientSession* new_session = GetActiveSession(host_port_pair_); |
2762 EXPECT_NE(session, new_session); | 2764 EXPECT_NE(session, new_session); |
2763 | 2765 |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2796 MockQuicData socket_data; | 2798 MockQuicData socket_data; |
2797 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 2799 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
2798 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 2800 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
2799 socket_data.AddWrite(client_maker_.MakeRstPacket( | 2801 socket_data.AddWrite(client_maker_.MakeRstPacket( |
2800 2, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); | 2802 2, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); |
2801 socket_data.AddSocketDataToFactory(&socket_factory_); | 2803 socket_data.AddSocketDataToFactory(&socket_factory_); |
2802 | 2804 |
2803 // Create request and QuicHttpStream. | 2805 // Create request and QuicHttpStream. |
2804 QuicStreamRequest request(factory_.get()); | 2806 QuicStreamRequest request(factory_.get()); |
2805 EXPECT_EQ(ERR_IO_PENDING, | 2807 EXPECT_EQ(ERR_IO_PENDING, |
2806 request.Request(host_port_pair_, privacy_mode_, | 2808 request.Request(host_port_pair_, version_, privacy_mode_, |
2807 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2809 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2808 callback_.callback())); | 2810 callback_.callback())); |
2809 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 2811 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
2810 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 2812 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
2811 EXPECT_TRUE(stream.get()); | 2813 EXPECT_TRUE(stream.get()); |
2812 | 2814 |
2813 // Cause QUIC stream to be created. | 2815 // Cause QUIC stream to be created. |
2814 HttpRequestInfo request_info; | 2816 HttpRequestInfo request_info; |
2815 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 2817 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
2816 net_log_, CompletionCallback())); | 2818 net_log_, CompletionCallback())); |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2848 MockQuicData socket_data; | 2850 MockQuicData socket_data; |
2849 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 2851 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
2850 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 2852 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
2851 socket_data.AddWrite(client_maker_.MakeRstPacket( | 2853 socket_data.AddWrite(client_maker_.MakeRstPacket( |
2852 2, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); | 2854 2, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); |
2853 socket_data.AddSocketDataToFactory(&socket_factory_); | 2855 socket_data.AddSocketDataToFactory(&socket_factory_); |
2854 | 2856 |
2855 // Create request and QuicHttpStream. | 2857 // Create request and QuicHttpStream. |
2856 QuicStreamRequest request(factory_.get()); | 2858 QuicStreamRequest request(factory_.get()); |
2857 EXPECT_EQ(ERR_IO_PENDING, | 2859 EXPECT_EQ(ERR_IO_PENDING, |
2858 request.Request(host_port_pair_, privacy_mode_, | 2860 request.Request(host_port_pair_, version_, privacy_mode_, |
2859 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2861 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2860 callback_.callback())); | 2862 callback_.callback())); |
2861 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 2863 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
2862 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 2864 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
2863 EXPECT_TRUE(stream.get()); | 2865 EXPECT_TRUE(stream.get()); |
2864 | 2866 |
2865 // Cause QUIC stream to be created, but marked as non-migratable. | 2867 // Cause QUIC stream to be created, but marked as non-migratable. |
2866 HttpRequestInfo request_info; | 2868 HttpRequestInfo request_info; |
2867 request_info.load_flags |= LOAD_DISABLE_CONNECTION_MIGRATION; | 2869 request_info.load_flags |= LOAD_DISABLE_CONNECTION_MIGRATION; |
2868 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 2870 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2900 MockQuicData socket_data; | 2902 MockQuicData socket_data; |
2901 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 2903 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
2902 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 2904 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
2903 socket_data.AddWrite(client_maker_.MakeRstPacket( | 2905 socket_data.AddWrite(client_maker_.MakeRstPacket( |
2904 2, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); | 2906 2, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); |
2905 socket_data.AddSocketDataToFactory(&socket_factory_); | 2907 socket_data.AddSocketDataToFactory(&socket_factory_); |
2906 | 2908 |
2907 // Create request and QuicHttpStream. | 2909 // Create request and QuicHttpStream. |
2908 QuicStreamRequest request(factory_.get()); | 2910 QuicStreamRequest request(factory_.get()); |
2909 EXPECT_EQ(ERR_IO_PENDING, | 2911 EXPECT_EQ(ERR_IO_PENDING, |
2910 request.Request(host_port_pair_, privacy_mode_, | 2912 request.Request(host_port_pair_, version_, privacy_mode_, |
2911 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2913 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2912 callback_.callback())); | 2914 callback_.callback())); |
2913 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 2915 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
2914 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 2916 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
2915 EXPECT_TRUE(stream.get()); | 2917 EXPECT_TRUE(stream.get()); |
2916 | 2918 |
2917 // Cause QUIC stream to be created. | 2919 // Cause QUIC stream to be created. |
2918 HttpRequestInfo request_info; | 2920 HttpRequestInfo request_info; |
2919 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 2921 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
2920 net_log_, CompletionCallback())); | 2922 net_log_, CompletionCallback())); |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2958 QuicStreamOffset header_stream_offset = 0; | 2960 QuicStreamOffset header_stream_offset = 0; |
2959 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 2961 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
2960 socket_data.AddWrite( | 2962 socket_data.AddWrite( |
2961 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 2963 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
2962 socket_data.AddWrite(write_error_mode, ERR_ADDRESS_UNREACHABLE); | 2964 socket_data.AddWrite(write_error_mode, ERR_ADDRESS_UNREACHABLE); |
2963 socket_data.AddSocketDataToFactory(&socket_factory_); | 2965 socket_data.AddSocketDataToFactory(&socket_factory_); |
2964 | 2966 |
2965 // Create request and QuicHttpStream. | 2967 // Create request and QuicHttpStream. |
2966 QuicStreamRequest request(factory_.get()); | 2968 QuicStreamRequest request(factory_.get()); |
2967 EXPECT_EQ(ERR_IO_PENDING, | 2969 EXPECT_EQ(ERR_IO_PENDING, |
2968 request.Request(host_port_pair_, privacy_mode_, | 2970 request.Request(host_port_pair_, version_, privacy_mode_, |
2969 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 2971 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
2970 callback_.callback())); | 2972 callback_.callback())); |
2971 EXPECT_EQ(OK, callback_.WaitForResult()); | 2973 EXPECT_EQ(OK, callback_.WaitForResult()); |
2972 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 2974 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
2973 EXPECT_TRUE(stream.get()); | 2975 EXPECT_TRUE(stream.get()); |
2974 | 2976 |
2975 // Cause QUIC stream to be created. | 2977 // Cause QUIC stream to be created. |
2976 HttpRequestInfo request_info; | 2978 HttpRequestInfo request_info; |
2977 request_info.method = "GET"; | 2979 request_info.method = "GET"; |
2978 request_info.url = GURL("https://www.example.org/"); | 2980 request_info.url = GURL("https://www.example.org/"); |
(...skipping 68 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3047 | 3049 |
3048 MockQuicData socket_data; | 3050 MockQuicData socket_data; |
3049 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 3051 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
3050 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 3052 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
3051 socket_data.AddWrite(write_error_mode, ERR_ADDRESS_UNREACHABLE); | 3053 socket_data.AddWrite(write_error_mode, ERR_ADDRESS_UNREACHABLE); |
3052 socket_data.AddSocketDataToFactory(&socket_factory_); | 3054 socket_data.AddSocketDataToFactory(&socket_factory_); |
3053 | 3055 |
3054 // Create request and QuicHttpStream. | 3056 // Create request and QuicHttpStream. |
3055 QuicStreamRequest request(factory_.get()); | 3057 QuicStreamRequest request(factory_.get()); |
3056 EXPECT_EQ(ERR_IO_PENDING, | 3058 EXPECT_EQ(ERR_IO_PENDING, |
3057 request.Request(host_port_pair_, privacy_mode_, | 3059 request.Request(host_port_pair_, version_, privacy_mode_, |
3058 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 3060 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
3059 callback_.callback())); | 3061 callback_.callback())); |
3060 EXPECT_EQ(OK, callback_.WaitForResult()); | 3062 EXPECT_EQ(OK, callback_.WaitForResult()); |
3061 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 3063 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
3062 EXPECT_TRUE(stream.get()); | 3064 EXPECT_TRUE(stream.get()); |
3063 | 3065 |
3064 // Cause QUIC stream to be created. | 3066 // Cause QUIC stream to be created. |
3065 HttpRequestInfo request_info; | 3067 HttpRequestInfo request_info; |
3066 request_info.method = "GET"; | 3068 request_info.method = "GET"; |
3067 request_info.url = GURL("https://www.example.org/"); | 3069 request_info.url = GURL("https://www.example.org/"); |
(...skipping 68 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3136 | 3138 |
3137 MockQuicData socket_data; | 3139 MockQuicData socket_data; |
3138 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 3140 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
3139 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 3141 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
3140 socket_data.AddWrite(write_error_mode, ERR_ADDRESS_UNREACHABLE); | 3142 socket_data.AddWrite(write_error_mode, ERR_ADDRESS_UNREACHABLE); |
3141 socket_data.AddSocketDataToFactory(&socket_factory_); | 3143 socket_data.AddSocketDataToFactory(&socket_factory_); |
3142 | 3144 |
3143 // Create request and QuicHttpStream. | 3145 // Create request and QuicHttpStream. |
3144 QuicStreamRequest request(factory_.get()); | 3146 QuicStreamRequest request(factory_.get()); |
3145 EXPECT_EQ(ERR_IO_PENDING, | 3147 EXPECT_EQ(ERR_IO_PENDING, |
3146 request.Request(host_port_pair_, privacy_mode_, | 3148 request.Request(host_port_pair_, version_, privacy_mode_, |
3147 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 3149 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
3148 callback_.callback())); | 3150 callback_.callback())); |
3149 EXPECT_EQ(OK, callback_.WaitForResult()); | 3151 EXPECT_EQ(OK, callback_.WaitForResult()); |
3150 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 3152 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
3151 EXPECT_TRUE(stream.get()); | 3153 EXPECT_TRUE(stream.get()); |
3152 | 3154 |
3153 // Cause QUIC stream to be created, but marked as non-migratable. | 3155 // Cause QUIC stream to be created, but marked as non-migratable. |
3154 HttpRequestInfo request_info; | 3156 HttpRequestInfo request_info; |
3155 request_info.load_flags |= LOAD_DISABLE_CONNECTION_MIGRATION; | 3157 request_info.load_flags |= LOAD_DISABLE_CONNECTION_MIGRATION; |
3156 request_info.method = "GET"; | 3158 request_info.method = "GET"; |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3200 | 3202 |
3201 MockQuicData socket_data; | 3203 MockQuicData socket_data; |
3202 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 3204 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
3203 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 3205 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
3204 socket_data.AddWrite(write_error_mode, ERR_ADDRESS_UNREACHABLE); | 3206 socket_data.AddWrite(write_error_mode, ERR_ADDRESS_UNREACHABLE); |
3205 socket_data.AddSocketDataToFactory(&socket_factory_); | 3207 socket_data.AddSocketDataToFactory(&socket_factory_); |
3206 | 3208 |
3207 // Create request and QuicHttpStream. | 3209 // Create request and QuicHttpStream. |
3208 QuicStreamRequest request(factory_.get()); | 3210 QuicStreamRequest request(factory_.get()); |
3209 EXPECT_EQ(ERR_IO_PENDING, | 3211 EXPECT_EQ(ERR_IO_PENDING, |
3210 request.Request(host_port_pair_, privacy_mode_, | 3212 request.Request(host_port_pair_, version_, privacy_mode_, |
3211 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 3213 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
3212 callback_.callback())); | 3214 callback_.callback())); |
3213 EXPECT_EQ(OK, callback_.WaitForResult()); | 3215 EXPECT_EQ(OK, callback_.WaitForResult()); |
3214 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 3216 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
3215 EXPECT_TRUE(stream.get()); | 3217 EXPECT_TRUE(stream.get()); |
3216 | 3218 |
3217 // Cause QUIC stream to be created. | 3219 // Cause QUIC stream to be created. |
3218 HttpRequestInfo request_info; | 3220 HttpRequestInfo request_info; |
3219 request_info.method = "GET"; | 3221 request_info.method = "GET"; |
3220 request_info.url = GURL("https://www.example.org/"); | 3222 request_info.url = GURL("https://www.example.org/"); |
(...skipping 58 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3279 socket_data[i].AddWrite( | 3281 socket_data[i].AddWrite( |
3280 (i % 2 == 0) ? first_write_error_mode : second_write_error_mode, | 3282 (i % 2 == 0) ? first_write_error_mode : second_write_error_mode, |
3281 ERR_FAILED); | 3283 ERR_FAILED); |
3282 } | 3284 } |
3283 socket_data[i].AddSocketDataToFactory(&socket_factory_); | 3285 socket_data[i].AddSocketDataToFactory(&socket_factory_); |
3284 } | 3286 } |
3285 | 3287 |
3286 // Create request and QuicHttpStream. | 3288 // Create request and QuicHttpStream. |
3287 QuicStreamRequest request(factory_.get()); | 3289 QuicStreamRequest request(factory_.get()); |
3288 EXPECT_EQ(ERR_IO_PENDING, | 3290 EXPECT_EQ(ERR_IO_PENDING, |
3289 request.Request(host_port_pair_, privacy_mode_, | 3291 request.Request(host_port_pair_, version_, privacy_mode_, |
3290 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 3292 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
3291 callback_.callback())); | 3293 callback_.callback())); |
3292 EXPECT_EQ(OK, callback_.WaitForResult()); | 3294 EXPECT_EQ(OK, callback_.WaitForResult()); |
3293 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 3295 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
3294 EXPECT_TRUE(stream.get()); | 3296 EXPECT_TRUE(stream.get()); |
3295 | 3297 |
3296 // Cause QUIC stream to be created. | 3298 // Cause QUIC stream to be created. |
3297 HttpRequestInfo request_info; | 3299 HttpRequestInfo request_info; |
3298 request_info.method = "GET"; | 3300 request_info.method = "GET"; |
3299 request_info.url = GURL("https://www.example.org/"); | 3301 request_info.url = GURL("https://www.example.org/"); |
(...skipping 59 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3359 QuicStreamOffset header_stream_offset = 0; | 3361 QuicStreamOffset header_stream_offset = 0; |
3360 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 3362 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
3361 socket_data.AddWrite( | 3363 socket_data.AddWrite( |
3362 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 3364 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
3363 socket_data.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE); | 3365 socket_data.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE); |
3364 socket_data.AddSocketDataToFactory(&socket_factory_); | 3366 socket_data.AddSocketDataToFactory(&socket_factory_); |
3365 | 3367 |
3366 // Create request and QuicHttpStream. | 3368 // Create request and QuicHttpStream. |
3367 QuicStreamRequest request(factory_.get()); | 3369 QuicStreamRequest request(factory_.get()); |
3368 EXPECT_EQ(ERR_IO_PENDING, | 3370 EXPECT_EQ(ERR_IO_PENDING, |
3369 request.Request(host_port_pair_, privacy_mode_, | 3371 request.Request(host_port_pair_, version_, privacy_mode_, |
3370 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 3372 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
3371 callback_.callback())); | 3373 callback_.callback())); |
3372 EXPECT_EQ(OK, callback_.WaitForResult()); | 3374 EXPECT_EQ(OK, callback_.WaitForResult()); |
3373 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 3375 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
3374 EXPECT_TRUE(stream.get()); | 3376 EXPECT_TRUE(stream.get()); |
3375 | 3377 |
3376 // Cause QUIC stream to be created. | 3378 // Cause QUIC stream to be created. |
3377 HttpRequestInfo request_info; | 3379 HttpRequestInfo request_info; |
3378 request_info.method = "GET"; | 3380 request_info.method = "GET"; |
3379 request_info.url = GURL("https://www.example.org/"); | 3381 request_info.url = GURL("https://www.example.org/"); |
(...skipping 77 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3457 QuicStreamOffset header_stream_offset = 0; | 3459 QuicStreamOffset header_stream_offset = 0; |
3458 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 3460 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
3459 socket_data.AddWrite( | 3461 socket_data.AddWrite( |
3460 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 3462 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
3461 socket_data.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE); | 3463 socket_data.AddWrite(SYNCHRONOUS, ERR_ADDRESS_UNREACHABLE); |
3462 socket_data.AddSocketDataToFactory(&socket_factory_); | 3464 socket_data.AddSocketDataToFactory(&socket_factory_); |
3463 | 3465 |
3464 // Create request and QuicHttpStream. | 3466 // Create request and QuicHttpStream. |
3465 QuicStreamRequest request(factory_.get()); | 3467 QuicStreamRequest request(factory_.get()); |
3466 EXPECT_EQ(ERR_IO_PENDING, | 3468 EXPECT_EQ(ERR_IO_PENDING, |
3467 request.Request(host_port_pair_, privacy_mode_, | 3469 request.Request(host_port_pair_, version_, privacy_mode_, |
3468 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 3470 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
3469 callback_.callback())); | 3471 callback_.callback())); |
3470 EXPECT_EQ(OK, callback_.WaitForResult()); | 3472 EXPECT_EQ(OK, callback_.WaitForResult()); |
3471 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 3473 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
3472 EXPECT_TRUE(stream.get()); | 3474 EXPECT_TRUE(stream.get()); |
3473 | 3475 |
3474 // Cause QUIC stream to be created. | 3476 // Cause QUIC stream to be created. |
3475 HttpRequestInfo request_info; | 3477 HttpRequestInfo request_info; |
3476 request_info.method = "GET"; | 3478 request_info.method = "GET"; |
3477 request_info.url = GURL("https://www.example.org/"); | 3479 request_info.url = GURL("https://www.example.org/"); |
(...skipping 78 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3556 QuicStreamOffset header_stream_offset = 0; | 3558 QuicStreamOffset header_stream_offset = 0; |
3557 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 3559 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
3558 socket_data.AddWrite( | 3560 socket_data.AddWrite( |
3559 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 3561 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
3560 socket_data.AddWrite(SYNCHRONOUS, ERR_FAILED); | 3562 socket_data.AddWrite(SYNCHRONOUS, ERR_FAILED); |
3561 socket_data.AddSocketDataToFactory(&socket_factory_); | 3563 socket_data.AddSocketDataToFactory(&socket_factory_); |
3562 | 3564 |
3563 // Create request and QuicHttpStream. | 3565 // Create request and QuicHttpStream. |
3564 QuicStreamRequest request(factory_.get()); | 3566 QuicStreamRequest request(factory_.get()); |
3565 EXPECT_EQ(ERR_IO_PENDING, | 3567 EXPECT_EQ(ERR_IO_PENDING, |
3566 request.Request(host_port_pair_, privacy_mode_, | 3568 request.Request(host_port_pair_, version_, privacy_mode_, |
3567 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 3569 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
3568 callback_.callback())); | 3570 callback_.callback())); |
3569 EXPECT_EQ(OK, callback_.WaitForResult()); | 3571 EXPECT_EQ(OK, callback_.WaitForResult()); |
3570 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 3572 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
3571 EXPECT_TRUE(stream.get()); | 3573 EXPECT_TRUE(stream.get()); |
3572 | 3574 |
3573 // Cause QUIC stream to be created. | 3575 // Cause QUIC stream to be created. |
3574 HttpRequestInfo request_info; | 3576 HttpRequestInfo request_info; |
3575 request_info.method = "GET"; | 3577 request_info.method = "GET"; |
3576 request_info.url = GURL("https://www.example.org/"); | 3578 request_info.url = GURL("https://www.example.org/"); |
(...skipping 60 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3637 | 3639 |
3638 // Create a new request for the same destination and verify that a | 3640 // Create a new request for the same destination and verify that a |
3639 // new session is created. | 3641 // new session is created. |
3640 MockQuicData socket_data2; | 3642 MockQuicData socket_data2; |
3641 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 3643 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
3642 socket_data2.AddWrite(ConstructInitialSettingsPacket()); | 3644 socket_data2.AddWrite(ConstructInitialSettingsPacket()); |
3643 socket_data2.AddSocketDataToFactory(&socket_factory_); | 3645 socket_data2.AddSocketDataToFactory(&socket_factory_); |
3644 | 3646 |
3645 QuicStreamRequest request2(factory_.get()); | 3647 QuicStreamRequest request2(factory_.get()); |
3646 EXPECT_EQ(ERR_IO_PENDING, | 3648 EXPECT_EQ(ERR_IO_PENDING, |
3647 request2.Request(host_port_pair_, privacy_mode_, | 3649 request2.Request(host_port_pair_, version_, privacy_mode_, |
3648 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 3650 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
3649 callback_.callback())); | 3651 callback_.callback())); |
3650 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 3652 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
3651 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 3653 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
3652 EXPECT_TRUE(stream2.get()); | 3654 EXPECT_TRUE(stream2.get()); |
3653 | 3655 |
3654 EXPECT_TRUE(HasActiveSession(host_port_pair_)); | 3656 EXPECT_TRUE(HasActiveSession(host_port_pair_)); |
3655 QuicChromiumClientSession* new_session = GetActiveSession(host_port_pair_); | 3657 QuicChromiumClientSession* new_session = GetActiveSession(host_port_pair_); |
3656 EXPECT_NE(session, new_session); | 3658 EXPECT_NE(session, new_session); |
3657 | 3659 |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3689 QuicStreamOffset header_stream_offset = 0; | 3691 QuicStreamOffset header_stream_offset = 0; |
3690 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 3692 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
3691 socket_data.AddWrite( | 3693 socket_data.AddWrite( |
3692 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 3694 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
3693 socket_data.AddWrite(SYNCHRONOUS, ERR_FAILED); | 3695 socket_data.AddWrite(SYNCHRONOUS, ERR_FAILED); |
3694 socket_data.AddSocketDataToFactory(&socket_factory_); | 3696 socket_data.AddSocketDataToFactory(&socket_factory_); |
3695 | 3697 |
3696 // Create request and QuicHttpStream. | 3698 // Create request and QuicHttpStream. |
3697 QuicStreamRequest request(factory_.get()); | 3699 QuicStreamRequest request(factory_.get()); |
3698 EXPECT_EQ(ERR_IO_PENDING, | 3700 EXPECT_EQ(ERR_IO_PENDING, |
3699 request.Request(host_port_pair_, privacy_mode_, | 3701 request.Request(host_port_pair_, version_, privacy_mode_, |
3700 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 3702 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
3701 callback_.callback())); | 3703 callback_.callback())); |
3702 EXPECT_EQ(OK, callback_.WaitForResult()); | 3704 EXPECT_EQ(OK, callback_.WaitForResult()); |
3703 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 3705 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
3704 EXPECT_TRUE(stream.get()); | 3706 EXPECT_TRUE(stream.get()); |
3705 | 3707 |
3706 // Cause QUIC stream to be created. | 3708 // Cause QUIC stream to be created. |
3707 HttpRequestInfo request_info; | 3709 HttpRequestInfo request_info; |
3708 request_info.method = "GET"; | 3710 request_info.method = "GET"; |
3709 request_info.url = GURL("https://www.example.org/"); | 3711 request_info.url = GURL("https://www.example.org/"); |
(...skipping 68 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3778 | 3780 |
3779 // Create a new request for the same destination and verify that a | 3781 // Create a new request for the same destination and verify that a |
3780 // new session is created. | 3782 // new session is created. |
3781 MockQuicData socket_data2; | 3783 MockQuicData socket_data2; |
3782 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 3784 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
3783 socket_data2.AddWrite(ConstructInitialSettingsPacket()); | 3785 socket_data2.AddWrite(ConstructInitialSettingsPacket()); |
3784 socket_data2.AddSocketDataToFactory(&socket_factory_); | 3786 socket_data2.AddSocketDataToFactory(&socket_factory_); |
3785 | 3787 |
3786 QuicStreamRequest request2(factory_.get()); | 3788 QuicStreamRequest request2(factory_.get()); |
3787 EXPECT_EQ(ERR_IO_PENDING, | 3789 EXPECT_EQ(ERR_IO_PENDING, |
3788 request2.Request(host_port_pair_, privacy_mode_, | 3790 request2.Request(host_port_pair_, version_, privacy_mode_, |
3789 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 3791 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
3790 callback_.callback())); | 3792 callback_.callback())); |
3791 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 3793 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
3792 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 3794 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
3793 EXPECT_TRUE(stream2.get()); | 3795 EXPECT_TRUE(stream2.get()); |
3794 | 3796 |
3795 EXPECT_TRUE(HasActiveSession(host_port_pair_)); | 3797 EXPECT_TRUE(HasActiveSession(host_port_pair_)); |
3796 QuicChromiumClientSession* new_session = GetActiveSession(host_port_pair_); | 3798 QuicChromiumClientSession* new_session = GetActiveSession(host_port_pair_); |
3797 EXPECT_NE(session, new_session); | 3799 EXPECT_NE(session, new_session); |
3798 | 3800 |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3843 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 3845 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
3844 socket_data.AddWrite( | 3846 socket_data.AddWrite( |
3845 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 3847 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
3846 socket_data.AddWrite(ConstructGetRequestPacket( | 3848 socket_data.AddWrite(ConstructGetRequestPacket( |
3847 2, GetNthClientInitiatedStreamId(0), true, true, &header_stream_offset)); | 3849 2, GetNthClientInitiatedStreamId(0), true, true, &header_stream_offset)); |
3848 socket_data.AddSocketDataToFactory(&socket_factory_); | 3850 socket_data.AddSocketDataToFactory(&socket_factory_); |
3849 | 3851 |
3850 // Create request and QuicHttpStream. | 3852 // Create request and QuicHttpStream. |
3851 QuicStreamRequest request(factory_.get()); | 3853 QuicStreamRequest request(factory_.get()); |
3852 EXPECT_EQ(ERR_IO_PENDING, | 3854 EXPECT_EQ(ERR_IO_PENDING, |
3853 request.Request(host_port_pair_, privacy_mode_, | 3855 request.Request(host_port_pair_, version_, privacy_mode_, |
3854 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 3856 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
3855 callback_.callback())); | 3857 callback_.callback())); |
3856 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 3858 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
3857 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 3859 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
3858 EXPECT_TRUE(stream.get()); | 3860 EXPECT_TRUE(stream.get()); |
3859 | 3861 |
3860 // Cause QUIC stream to be created. | 3862 // Cause QUIC stream to be created. |
3861 HttpRequestInfo request_info; | 3863 HttpRequestInfo request_info; |
3862 request_info.method = "GET"; | 3864 request_info.method = "GET"; |
3863 request_info.url = url_; | 3865 request_info.url = url_; |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3906 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 3908 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
3907 socket_data1.AddWrite( | 3909 socket_data1.AddWrite( |
3908 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 3910 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
3909 socket_data1.AddWrite(ConstructGetRequestPacket( | 3911 socket_data1.AddWrite(ConstructGetRequestPacket( |
3910 2, GetNthClientInitiatedStreamId(0), true, true, &header_stream_offset)); | 3912 2, GetNthClientInitiatedStreamId(0), true, true, &header_stream_offset)); |
3911 socket_data1.AddSocketDataToFactory(&socket_factory_); | 3913 socket_data1.AddSocketDataToFactory(&socket_factory_); |
3912 | 3914 |
3913 // Create request and QuicHttpStream. | 3915 // Create request and QuicHttpStream. |
3914 QuicStreamRequest request(factory_.get()); | 3916 QuicStreamRequest request(factory_.get()); |
3915 EXPECT_EQ(ERR_IO_PENDING, | 3917 EXPECT_EQ(ERR_IO_PENDING, |
3916 request.Request(host_port_pair_, privacy_mode_, | 3918 request.Request(host_port_pair_, version_, privacy_mode_, |
3917 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 3919 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
3918 callback_.callback())); | 3920 callback_.callback())); |
3919 EXPECT_EQ(OK, callback_.WaitForResult()); | 3921 EXPECT_EQ(OK, callback_.WaitForResult()); |
3920 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 3922 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
3921 EXPECT_TRUE(stream.get()); | 3923 EXPECT_TRUE(stream.get()); |
3922 | 3924 |
3923 // Cause QUIC stream to be created. | 3925 // Cause QUIC stream to be created. |
3924 HttpRequestInfo request_info; | 3926 HttpRequestInfo request_info; |
3925 request_info.method = "GET"; | 3927 request_info.method = "GET"; |
3926 request_info.url = GURL("https://www.example.org/"); | 3928 request_info.url = GURL("https://www.example.org/"); |
(...skipping 121 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4048 MockQuicData socket_data1; | 4050 MockQuicData socket_data1; |
4049 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 4051 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
4050 socket_data1.AddWrite(ConstructInitialSettingsPacket()); | 4052 socket_data1.AddWrite(ConstructInitialSettingsPacket()); |
4051 socket_data1.AddWrite(client_maker_.MakeRstPacket( | 4053 socket_data1.AddWrite(client_maker_.MakeRstPacket( |
4052 2, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); | 4054 2, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); |
4053 socket_data1.AddSocketDataToFactory(&socket_factory_); | 4055 socket_data1.AddSocketDataToFactory(&socket_factory_); |
4054 | 4056 |
4055 // Create request and QuicHttpStream. | 4057 // Create request and QuicHttpStream. |
4056 QuicStreamRequest request(factory_.get()); | 4058 QuicStreamRequest request(factory_.get()); |
4057 EXPECT_EQ(ERR_IO_PENDING, | 4059 EXPECT_EQ(ERR_IO_PENDING, |
4058 request.Request(host_port_pair_, privacy_mode_, | 4060 request.Request(host_port_pair_, version_, privacy_mode_, |
4059 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4061 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4060 callback_.callback())); | 4062 callback_.callback())); |
4061 EXPECT_EQ(OK, callback_.WaitForResult()); | 4063 EXPECT_EQ(OK, callback_.WaitForResult()); |
4062 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 4064 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
4063 EXPECT_TRUE(stream.get()); | 4065 EXPECT_TRUE(stream.get()); |
4064 | 4066 |
4065 // Cause QUIC stream to be created. | 4067 // Cause QUIC stream to be created. |
4066 HttpRequestInfo request_info; | 4068 HttpRequestInfo request_info; |
4067 request_info.method = "GET"; | 4069 request_info.method = "GET"; |
4068 request_info.url = GURL("https://www.example.org/"); | 4070 request_info.url = GURL("https://www.example.org/"); |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4102 socket_data.AddWrite(ConstructClientRstPacket(2)); | 4104 socket_data.AddWrite(ConstructClientRstPacket(2)); |
4103 socket_data.AddSocketDataToFactory(&socket_factory_); | 4105 socket_data.AddSocketDataToFactory(&socket_factory_); |
4104 | 4106 |
4105 MockQuicData socket_data2; | 4107 MockQuicData socket_data2; |
4106 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 4108 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
4107 socket_data2.AddWrite(ConstructInitialSettingsPacket(1, nullptr)); | 4109 socket_data2.AddWrite(ConstructInitialSettingsPacket(1, nullptr)); |
4108 socket_data2.AddSocketDataToFactory(&socket_factory_); | 4110 socket_data2.AddSocketDataToFactory(&socket_factory_); |
4109 | 4111 |
4110 QuicStreamRequest request(factory_.get()); | 4112 QuicStreamRequest request(factory_.get()); |
4111 EXPECT_EQ(ERR_IO_PENDING, | 4113 EXPECT_EQ(ERR_IO_PENDING, |
4112 request.Request(host_port_pair_, privacy_mode_, | 4114 request.Request(host_port_pair_, version_, privacy_mode_, |
4113 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4115 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4114 callback_.callback())); | 4116 callback_.callback())); |
4115 | 4117 |
4116 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 4118 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
4117 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 4119 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
4118 HttpRequestInfo request_info; | 4120 HttpRequestInfo request_info; |
4119 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 4121 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
4120 net_log_, CompletionCallback())); | 4122 net_log_, CompletionCallback())); |
4121 | 4123 |
4122 ssl_config_service_->NotifySSLConfigChange(); | 4124 ssl_config_service_->NotifySSLConfigChange(); |
4123 EXPECT_EQ(ERR_CERT_DATABASE_CHANGED, | 4125 EXPECT_EQ(ERR_CERT_DATABASE_CHANGED, |
4124 stream->ReadResponseHeaders(callback_.callback())); | 4126 stream->ReadResponseHeaders(callback_.callback())); |
4125 EXPECT_FALSE(factory_->require_confirmation()); | 4127 EXPECT_FALSE(factory_->require_confirmation()); |
4126 | 4128 |
4127 // Now attempting to request a stream to the same origin should create | 4129 // Now attempting to request a stream to the same origin should create |
4128 // a new session. | 4130 // a new session. |
4129 | 4131 |
4130 QuicStreamRequest request2(factory_.get()); | 4132 QuicStreamRequest request2(factory_.get()); |
4131 EXPECT_EQ(ERR_IO_PENDING, | 4133 EXPECT_EQ(ERR_IO_PENDING, |
4132 request2.Request(host_port_pair_, privacy_mode_, | 4134 request2.Request(host_port_pair_, version_, privacy_mode_, |
4133 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4135 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4134 callback_.callback())); | 4136 callback_.callback())); |
4135 | 4137 |
4136 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 4138 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
4137 stream = request2.CreateStream(); | 4139 stream = request2.CreateStream(); |
4138 stream.reset(); // Will reset stream 3. | 4140 stream.reset(); // Will reset stream 3. |
4139 | 4141 |
4140 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 4142 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
4141 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 4143 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
4142 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); | 4144 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); |
(...skipping 12 matching lines...) Expand all Loading... |
4155 socket_data.AddWrite(ConstructClientRstPacket(2)); | 4157 socket_data.AddWrite(ConstructClientRstPacket(2)); |
4156 socket_data.AddSocketDataToFactory(&socket_factory_); | 4158 socket_data.AddSocketDataToFactory(&socket_factory_); |
4157 | 4159 |
4158 MockQuicData socket_data2; | 4160 MockQuicData socket_data2; |
4159 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 4161 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
4160 socket_data2.AddWrite(ConstructInitialSettingsPacket(1, nullptr)); | 4162 socket_data2.AddWrite(ConstructInitialSettingsPacket(1, nullptr)); |
4161 socket_data2.AddSocketDataToFactory(&socket_factory_); | 4163 socket_data2.AddSocketDataToFactory(&socket_factory_); |
4162 | 4164 |
4163 QuicStreamRequest request(factory_.get()); | 4165 QuicStreamRequest request(factory_.get()); |
4164 EXPECT_EQ(ERR_IO_PENDING, | 4166 EXPECT_EQ(ERR_IO_PENDING, |
4165 request.Request(host_port_pair_, privacy_mode_, | 4167 request.Request(host_port_pair_, version_, privacy_mode_, |
4166 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4168 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4167 callback_.callback())); | 4169 callback_.callback())); |
4168 | 4170 |
4169 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 4171 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
4170 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 4172 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
4171 HttpRequestInfo request_info; | 4173 HttpRequestInfo request_info; |
4172 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, | 4174 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, |
4173 net_log_, CompletionCallback())); | 4175 net_log_, CompletionCallback())); |
4174 | 4176 |
4175 // Change the CA cert and verify that stream saw the event. | 4177 // Change the CA cert and verify that stream saw the event. |
4176 factory_->OnCertDBChanged(); | 4178 factory_->OnCertDBChanged(); |
4177 EXPECT_EQ(ERR_CERT_DATABASE_CHANGED, | 4179 EXPECT_EQ(ERR_CERT_DATABASE_CHANGED, |
4178 stream->ReadResponseHeaders(callback_.callback())); | 4180 stream->ReadResponseHeaders(callback_.callback())); |
4179 EXPECT_FALSE(factory_->require_confirmation()); | 4181 EXPECT_FALSE(factory_->require_confirmation()); |
4180 | 4182 |
4181 // Now attempting to request a stream to the same origin should create | 4183 // Now attempting to request a stream to the same origin should create |
4182 // a new session. | 4184 // a new session. |
4183 | 4185 |
4184 QuicStreamRequest request2(factory_.get()); | 4186 QuicStreamRequest request2(factory_.get()); |
4185 EXPECT_EQ(ERR_IO_PENDING, | 4187 EXPECT_EQ(ERR_IO_PENDING, |
4186 request2.Request(host_port_pair_, privacy_mode_, | 4188 request2.Request(host_port_pair_, version_, privacy_mode_, |
4187 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4189 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4188 callback_.callback())); | 4190 callback_.callback())); |
4189 | 4191 |
4190 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 4192 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
4191 stream = request2.CreateStream(); | 4193 stream = request2.CreateStream(); |
4192 stream.reset(); // Will reset stream 3. | 4194 stream.reset(); // Will reset stream 3. |
4193 | 4195 |
4194 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 4196 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
4195 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); | 4197 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); |
4196 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); | 4198 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); |
(...skipping 83 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4280 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 4282 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
4281 socket_data.AddSocketDataToFactory(&socket_factory_); | 4283 socket_data.AddSocketDataToFactory(&socket_factory_); |
4282 | 4284 |
4283 crypto_client_stream_factory_.set_handshake_mode( | 4285 crypto_client_stream_factory_.set_handshake_mode( |
4284 MockCryptoClientStream::ZERO_RTT); | 4286 MockCryptoClientStream::ZERO_RTT); |
4285 host_resolver_.set_synchronous_mode(true); | 4287 host_resolver_.set_synchronous_mode(true); |
4286 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), | 4288 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), |
4287 "192.168.0.1", ""); | 4289 "192.168.0.1", ""); |
4288 | 4290 |
4289 QuicStreamRequest request(factory_.get()); | 4291 QuicStreamRequest request(factory_.get()); |
4290 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_, | 4292 EXPECT_EQ(OK, request.Request(host_port_pair_, version_, privacy_mode_, |
4291 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4293 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4292 callback_.callback())); | 4294 callback_.callback())); |
4293 | 4295 |
4294 // If we are waiting for disk cache, we would have posted a task. Verify that | 4296 // If we are waiting for disk cache, we would have posted a task. Verify that |
4295 // the CancelWaitForDataReady task hasn't been posted. | 4297 // the CancelWaitForDataReady task hasn't been posted. |
4296 ASSERT_EQ(0u, runner_->GetPostedTasks().size()); | 4298 ASSERT_EQ(0u, runner_->GetPostedTasks().size()); |
4297 | 4299 |
4298 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 4300 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
4299 EXPECT_TRUE(stream.get()); | 4301 EXPECT_TRUE(stream.get()); |
4300 EXPECT_TRUE(socket_data.AllReadDataConsumed()); | 4302 EXPECT_TRUE(socket_data.AllReadDataConsumed()); |
(...skipping 26 matching lines...) Expand all Loading... |
4327 host_resolver_.set_synchronous_mode(true); | 4329 host_resolver_.set_synchronous_mode(true); |
4328 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), | 4330 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), |
4329 "192.168.0.1", ""); | 4331 "192.168.0.1", ""); |
4330 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); | 4332 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); |
4331 | 4333 |
4332 // Quic should use default PING timeout when no previous connection times out | 4334 // Quic should use default PING timeout when no previous connection times out |
4333 // with open stream. | 4335 // with open stream. |
4334 EXPECT_EQ(QuicTime::Delta::FromSeconds(kPingTimeoutSecs), | 4336 EXPECT_EQ(QuicTime::Delta::FromSeconds(kPingTimeoutSecs), |
4335 QuicStreamFactoryPeer::GetPingTimeout(factory_.get())); | 4337 QuicStreamFactoryPeer::GetPingTimeout(factory_.get())); |
4336 QuicStreamRequest request(factory_.get()); | 4338 QuicStreamRequest request(factory_.get()); |
4337 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_, | 4339 EXPECT_EQ(OK, request.Request(host_port_pair_, version_, privacy_mode_, |
4338 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4340 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4339 callback_.callback())); | 4341 callback_.callback())); |
4340 | 4342 |
4341 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); | 4343 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); |
4342 EXPECT_EQ(QuicTime::Delta::FromSeconds(kPingTimeoutSecs), | 4344 EXPECT_EQ(QuicTime::Delta::FromSeconds(kPingTimeoutSecs), |
4343 session->connection()->ping_timeout()); | 4345 session->connection()->ping_timeout()); |
4344 | 4346 |
4345 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 4347 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
4346 EXPECT_TRUE(stream.get()); | 4348 EXPECT_TRUE(stream.get()); |
4347 HttpRequestInfo request_info; | 4349 HttpRequestInfo request_info; |
(...skipping 11 matching lines...) Expand all Loading... |
4359 | 4361 |
4360 // The first connection times out with open stream, QUIC should reduce initial | 4362 // The first connection times out with open stream, QUIC should reduce initial |
4361 // PING time for subsequent connections. | 4363 // PING time for subsequent connections. |
4362 EXPECT_EQ(QuicTime::Delta::FromSeconds(10), | 4364 EXPECT_EQ(QuicTime::Delta::FromSeconds(10), |
4363 QuicStreamFactoryPeer::GetPingTimeout(factory_.get())); | 4365 QuicStreamFactoryPeer::GetPingTimeout(factory_.get())); |
4364 | 4366 |
4365 // Test two-in-a-row timeouts with open streams. | 4367 // Test two-in-a-row timeouts with open streams. |
4366 DVLOG(1) << "Create 2nd session and timeout with open stream"; | 4368 DVLOG(1) << "Create 2nd session and timeout with open stream"; |
4367 TestCompletionCallback callback2; | 4369 TestCompletionCallback callback2; |
4368 QuicStreamRequest request2(factory_.get()); | 4370 QuicStreamRequest request2(factory_.get()); |
4369 EXPECT_EQ(OK, request2.Request(server2, privacy_mode_, | 4371 EXPECT_EQ(OK, request2.Request(server2, version_, privacy_mode_, |
4370 /*cert_verify_flags=*/0, url2_, "GET", | 4372 /*cert_verify_flags=*/0, url2_, "GET", |
4371 net_log_, callback2.callback())); | 4373 net_log_, callback2.callback())); |
4372 QuicChromiumClientSession* session2 = GetActiveSession(server2); | 4374 QuicChromiumClientSession* session2 = GetActiveSession(server2); |
4373 EXPECT_EQ(QuicTime::Delta::FromSeconds(10), | 4375 EXPECT_EQ(QuicTime::Delta::FromSeconds(10), |
4374 session2->connection()->ping_timeout()); | 4376 session2->connection()->ping_timeout()); |
4375 | 4377 |
4376 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 4378 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
4377 EXPECT_TRUE(stream2.get()); | 4379 EXPECT_TRUE(stream2.get()); |
4378 EXPECT_EQ(OK, stream2->InitializeStream(&request_info, DEFAULT_PRIORITY, | 4380 EXPECT_EQ(OK, stream2->InitializeStream(&request_info, DEFAULT_PRIORITY, |
4379 net_log_, CompletionCallback())); | 4381 net_log_, CompletionCallback())); |
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4425 while (HasActiveCertVerifierJob(quic_server_id)) { | 4427 while (HasActiveCertVerifierJob(quic_server_id)) { |
4426 base::RunLoop().RunUntilIdle(); | 4428 base::RunLoop().RunUntilIdle(); |
4427 } | 4429 } |
4428 } | 4430 } |
4429 // Verify CertVerifierJob has finished. | 4431 // Verify CertVerifierJob has finished. |
4430 EXPECT_FALSE(HasActiveCertVerifierJob(quic_server_id)); | 4432 EXPECT_FALSE(HasActiveCertVerifierJob(quic_server_id)); |
4431 | 4433 |
4432 // Start a QUIC request. | 4434 // Start a QUIC request. |
4433 QuicStreamRequest request(factory_.get()); | 4435 QuicStreamRequest request(factory_.get()); |
4434 EXPECT_EQ(ERR_IO_PENDING, | 4436 EXPECT_EQ(ERR_IO_PENDING, |
4435 request.Request(host_port_pair_, privacy_mode_, | 4437 request.Request(host_port_pair_, version_, privacy_mode_, |
4436 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4438 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4437 callback_.callback())); | 4439 callback_.callback())); |
4438 | 4440 |
4439 EXPECT_EQ(OK, callback_.WaitForResult()); | 4441 EXPECT_EQ(OK, callback_.WaitForResult()); |
4440 | 4442 |
4441 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 4443 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
4442 EXPECT_TRUE(stream.get()); | 4444 EXPECT_TRUE(stream.get()); |
4443 | 4445 |
4444 // Restore |race_cert_verification|. | 4446 // Restore |race_cert_verification|. |
4445 QuicStreamFactoryPeer::SetRaceCertVerification(factory_.get(), | 4447 QuicStreamFactoryPeer::SetRaceCertVerification(factory_.get(), |
(...skipping 24 matching lines...) Expand all Loading... |
4470 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), | 4472 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), |
4471 "192.168.0.1", ""); | 4473 "192.168.0.1", ""); |
4472 | 4474 |
4473 // Set up the TaskObserver to verify QuicChromiumPacketReader::StartReading | 4475 // Set up the TaskObserver to verify QuicChromiumPacketReader::StartReading |
4474 // posts a task. | 4476 // posts a task. |
4475 // TODO(rtenneti): Change SpdySessionTestTaskObserver to NetTestTaskObserver?? | 4477 // TODO(rtenneti): Change SpdySessionTestTaskObserver to NetTestTaskObserver?? |
4476 SpdySessionTestTaskObserver observer("quic_chromium_packet_reader.cc", | 4478 SpdySessionTestTaskObserver observer("quic_chromium_packet_reader.cc", |
4477 "StartReading"); | 4479 "StartReading"); |
4478 | 4480 |
4479 QuicStreamRequest request(factory_.get()); | 4481 QuicStreamRequest request(factory_.get()); |
4480 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_, | 4482 EXPECT_EQ(OK, request.Request(host_port_pair_, version_, privacy_mode_, |
4481 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4483 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4482 callback_.callback())); | 4484 callback_.callback())); |
4483 | 4485 |
4484 // Call run_loop so that QuicChromiumPacketReader::OnReadComplete() gets | 4486 // Call run_loop so that QuicChromiumPacketReader::OnReadComplete() gets |
4485 // called. | 4487 // called. |
4486 base::RunLoop run_loop; | 4488 base::RunLoop run_loop; |
4487 run_loop.RunUntilIdle(); | 4489 run_loop.RunUntilIdle(); |
4488 | 4490 |
4489 // Verify task that the observer's executed_count is 1, which indicates | 4491 // Verify task that the observer's executed_count is 1, which indicates |
4490 // QuicChromiumPacketReader::StartReading() has posted only one task and | 4492 // QuicChromiumPacketReader::StartReading() has posted only one task and |
(...skipping 24 matching lines...) Expand all Loading... |
4515 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), | 4517 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), |
4516 "192.168.0.1", ""); | 4518 "192.168.0.1", ""); |
4517 | 4519 |
4518 // Set up the TaskObserver to verify QuicChromiumPacketReader::StartReading | 4520 // Set up the TaskObserver to verify QuicChromiumPacketReader::StartReading |
4519 // posts a task. | 4521 // posts a task. |
4520 // TODO(rtenneti): Change SpdySessionTestTaskObserver to NetTestTaskObserver?? | 4522 // TODO(rtenneti): Change SpdySessionTestTaskObserver to NetTestTaskObserver?? |
4521 SpdySessionTestTaskObserver observer("quic_chromium_packet_reader.cc", | 4523 SpdySessionTestTaskObserver observer("quic_chromium_packet_reader.cc", |
4522 "StartReading"); | 4524 "StartReading"); |
4523 | 4525 |
4524 QuicStreamRequest request(factory_.get()); | 4526 QuicStreamRequest request(factory_.get()); |
4525 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_, | 4527 EXPECT_EQ(OK, request.Request(host_port_pair_, version_, privacy_mode_, |
4526 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4528 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4527 callback_.callback())); | 4529 callback_.callback())); |
4528 | 4530 |
4529 // Call run_loop so that QuicChromiumPacketReader::OnReadComplete() gets | 4531 // Call run_loop so that QuicChromiumPacketReader::OnReadComplete() gets |
4530 // called. | 4532 // called. |
4531 base::RunLoop run_loop; | 4533 base::RunLoop run_loop; |
4532 run_loop.RunUntilIdle(); | 4534 run_loop.RunUntilIdle(); |
4533 | 4535 |
4534 // Verify task that the observer's executed_count is 1, which indicates | 4536 // Verify task that the observer's executed_count is 1, which indicates |
4535 // QuicChromiumPacketReader::StartReading() has posted only one task and | 4537 // QuicChromiumPacketReader::StartReading() has posted only one task and |
(...skipping 11 matching lines...) Expand all Loading... |
4547 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 4549 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
4548 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 4550 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
4549 | 4551 |
4550 MockQuicData socket_data; | 4552 MockQuicData socket_data; |
4551 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 4553 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
4552 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 4554 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
4553 socket_data.AddSocketDataToFactory(&socket_factory_); | 4555 socket_data.AddSocketDataToFactory(&socket_factory_); |
4554 | 4556 |
4555 QuicStreamRequest request(factory_.get()); | 4557 QuicStreamRequest request(factory_.get()); |
4556 EXPECT_EQ(ERR_IO_PENDING, | 4558 EXPECT_EQ(ERR_IO_PENDING, |
4557 request.Request(host_port_pair_, privacy_mode_, | 4559 request.Request(host_port_pair_, version_, privacy_mode_, |
4558 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4560 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4559 callback_.callback())); | 4561 callback_.callback())); |
4560 | 4562 |
4561 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 4563 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
4562 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 4564 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
4563 EXPECT_TRUE(stream.get()); | 4565 EXPECT_TRUE(stream.get()); |
4564 | 4566 |
4565 EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumPushStreamsCreated(factory_.get())); | 4567 EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumPushStreamsCreated(factory_.get())); |
4566 | 4568 |
4567 string url = "https://www.example.org/"; | 4569 string url = "https://www.example.org/"; |
4568 | 4570 |
4569 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); | 4571 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); |
4570 | 4572 |
4571 QuicClientPromisedInfo promised(session, GetNthServerInitiatedStreamId(0), | 4573 QuicClientPromisedInfo promised(session, GetNthServerInitiatedStreamId(0), |
4572 kDefaultUrl); | 4574 kDefaultUrl); |
4573 (*QuicStreamFactoryPeer::GetPushPromiseIndex(factory_.get()) | 4575 (*QuicStreamFactoryPeer::GetPushPromiseIndex(factory_.get()) |
4574 ->promised_by_url())[kDefaultUrl] = &promised; | 4576 ->promised_by_url())[kDefaultUrl] = &promised; |
4575 | 4577 |
4576 QuicStreamRequest request2(factory_.get()); | 4578 QuicStreamRequest request2(factory_.get()); |
4577 EXPECT_EQ(OK, request2.Request(host_port_pair_, privacy_mode_, | 4579 EXPECT_EQ(OK, request2.Request(host_port_pair_, version_, privacy_mode_, |
4578 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4580 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4579 callback_.callback())); | 4581 callback_.callback())); |
4580 | 4582 |
4581 EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumPushStreamsCreated(factory_.get())); | 4583 EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumPushStreamsCreated(factory_.get())); |
4582 } | 4584 } |
4583 | 4585 |
4584 TEST_P(QuicStreamFactoryTest, ServerPushPrivacyModeMismatch) { | 4586 TEST_P(QuicStreamFactoryTest, ServerPushPrivacyModeMismatch) { |
4585 Initialize(); | 4587 Initialize(); |
4586 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 4588 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
4587 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 4589 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
4588 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 4590 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
4589 | 4591 |
4590 MockQuicData socket_data1; | 4592 MockQuicData socket_data1; |
4591 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 4593 socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
4592 socket_data1.AddWrite(ConstructInitialSettingsPacket()); | 4594 socket_data1.AddWrite(ConstructInitialSettingsPacket()); |
4593 socket_data1.AddWrite(client_maker_.MakeRstPacket( | 4595 socket_data1.AddWrite(client_maker_.MakeRstPacket( |
4594 2, true, GetNthServerInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); | 4596 2, true, GetNthServerInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); |
4595 socket_data1.AddSocketDataToFactory(&socket_factory_); | 4597 socket_data1.AddSocketDataToFactory(&socket_factory_); |
4596 | 4598 |
4597 MockQuicData socket_data2; | 4599 MockQuicData socket_data2; |
4598 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 4600 socket_data2.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
4599 socket_data2.AddWrite(ConstructInitialSettingsPacket()); | 4601 socket_data2.AddWrite(ConstructInitialSettingsPacket()); |
4600 socket_data2.AddSocketDataToFactory(&socket_factory_); | 4602 socket_data2.AddSocketDataToFactory(&socket_factory_); |
4601 | 4603 |
4602 QuicStreamRequest request(factory_.get()); | 4604 QuicStreamRequest request(factory_.get()); |
4603 EXPECT_EQ(ERR_IO_PENDING, | 4605 EXPECT_EQ(ERR_IO_PENDING, |
4604 request.Request(host_port_pair_, privacy_mode_, | 4606 request.Request(host_port_pair_, version_, privacy_mode_, |
4605 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4607 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4606 callback_.callback())); | 4608 callback_.callback())); |
4607 | 4609 |
4608 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 4610 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
4609 std::unique_ptr<HttpStream> stream = request.CreateStream(); | 4611 std::unique_ptr<HttpStream> stream = request.CreateStream(); |
4610 EXPECT_TRUE(stream.get()); | 4612 EXPECT_TRUE(stream.get()); |
4611 | 4613 |
4612 EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumPushStreamsCreated(factory_.get())); | 4614 EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumPushStreamsCreated(factory_.get())); |
4613 | 4615 |
4614 string url = "https://www.example.org/"; | 4616 string url = "https://www.example.org/"; |
4615 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); | 4617 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); |
4616 | 4618 |
4617 QuicClientPromisedInfo promised(session, GetNthServerInitiatedStreamId(0), | 4619 QuicClientPromisedInfo promised(session, GetNthServerInitiatedStreamId(0), |
4618 kDefaultUrl); | 4620 kDefaultUrl); |
4619 | 4621 |
4620 QuicClientPushPromiseIndex* index = | 4622 QuicClientPushPromiseIndex* index = |
4621 QuicStreamFactoryPeer::GetPushPromiseIndex(factory_.get()); | 4623 QuicStreamFactoryPeer::GetPushPromiseIndex(factory_.get()); |
4622 | 4624 |
4623 (*index->promised_by_url())[kDefaultUrl] = &promised; | 4625 (*index->promised_by_url())[kDefaultUrl] = &promised; |
4624 EXPECT_EQ(index->GetPromised(kDefaultUrl), &promised); | 4626 EXPECT_EQ(index->GetPromised(kDefaultUrl), &promised); |
4625 | 4627 |
4626 // Doing the request should not use the push stream, but rather | 4628 // Doing the request should not use the push stream, but rather |
4627 // cancel it because the privacy modes do not match. | 4629 // cancel it because the privacy modes do not match. |
4628 QuicStreamRequest request2(factory_.get()); | 4630 QuicStreamRequest request2(factory_.get()); |
4629 EXPECT_EQ(ERR_IO_PENDING, | 4631 EXPECT_EQ(ERR_IO_PENDING, |
4630 request2.Request(host_port_pair_, PRIVACY_MODE_ENABLED, | 4632 request2.Request(host_port_pair_, version_, PRIVACY_MODE_ENABLED, |
4631 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4633 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4632 callback_.callback())); | 4634 callback_.callback())); |
4633 | 4635 |
4634 EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumPushStreamsCreated(factory_.get())); | 4636 EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumPushStreamsCreated(factory_.get())); |
4635 EXPECT_EQ(index->GetPromised(kDefaultUrl), nullptr); | 4637 EXPECT_EQ(index->GetPromised(kDefaultUrl), nullptr); |
4636 | 4638 |
4637 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 4639 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
4638 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 4640 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
4639 EXPECT_TRUE(stream2.get()); | 4641 EXPECT_TRUE(stream2.get()); |
4640 | 4642 |
(...skipping 14 matching lines...) Expand all Loading... |
4655 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 4657 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
4656 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 4658 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
4657 | 4659 |
4658 MockQuicData socket_data; | 4660 MockQuicData socket_data; |
4659 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 4661 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
4660 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 4662 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
4661 socket_data.AddSocketDataToFactory(&socket_factory_); | 4663 socket_data.AddSocketDataToFactory(&socket_factory_); |
4662 | 4664 |
4663 QuicStreamRequest request1(factory_.get()); | 4665 QuicStreamRequest request1(factory_.get()); |
4664 EXPECT_EQ(ERR_IO_PENDING, | 4666 EXPECT_EQ(ERR_IO_PENDING, |
4665 request1.Request(destination1, privacy_mode_, | 4667 request1.Request(destination1, version_, privacy_mode_, |
4666 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4668 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4667 callback_.callback())); | 4669 callback_.callback())); |
4668 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 4670 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
4669 std::unique_ptr<HttpStream> stream1 = request1.CreateStream(); | 4671 std::unique_ptr<HttpStream> stream1 = request1.CreateStream(); |
4670 EXPECT_TRUE(stream1.get()); | 4672 EXPECT_TRUE(stream1.get()); |
4671 EXPECT_TRUE(HasActiveSession(host_port_pair_)); | 4673 EXPECT_TRUE(HasActiveSession(host_port_pair_)); |
4672 | 4674 |
4673 // Second request returns synchronously because it pools to existing session. | 4675 // Second request returns synchronously because it pools to existing session. |
4674 TestCompletionCallback callback2; | 4676 TestCompletionCallback callback2; |
4675 QuicStreamRequest request2(factory_.get()); | 4677 QuicStreamRequest request2(factory_.get()); |
4676 EXPECT_EQ(OK, request2.Request(destination2, privacy_mode_, | 4678 EXPECT_EQ(OK, request2.Request(destination2, version_, privacy_mode_, |
4677 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4679 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4678 callback2.callback())); | 4680 callback2.callback())); |
4679 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 4681 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
4680 EXPECT_TRUE(stream2.get()); | 4682 EXPECT_TRUE(stream2.get()); |
4681 | 4683 |
4682 QuicChromiumClientSession::Handle* session1 = | 4684 QuicChromiumClientSession::Handle* session1 = |
4683 QuicHttpStreamPeer::GetSessionHandle(stream1.get()); | 4685 QuicHttpStreamPeer::GetSessionHandle(stream1.get()); |
4684 QuicChromiumClientSession::Handle* session2 = | 4686 QuicChromiumClientSession::Handle* session2 = |
4685 QuicHttpStreamPeer::GetSessionHandle(stream2.get()); | 4687 QuicHttpStreamPeer::GetSessionHandle(stream2.get()); |
4686 EXPECT_TRUE(session1->SharesSameSession(*session2)); | 4688 EXPECT_TRUE(session1->SharesSameSession(*session2)); |
(...skipping 11 matching lines...) Expand all Loading... |
4698 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); | 4700 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); |
4699 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 4701 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
4700 | 4702 |
4701 MockQuicData socket_data; | 4703 MockQuicData socket_data; |
4702 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 4704 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
4703 socket_data.AddWrite(ConstructInitialSettingsPacket()); | 4705 socket_data.AddWrite(ConstructInitialSettingsPacket()); |
4704 socket_data.AddSocketDataToFactory(&socket_factory_); | 4706 socket_data.AddSocketDataToFactory(&socket_factory_); |
4705 | 4707 |
4706 QuicStreamRequest request(factory_.get()); | 4708 QuicStreamRequest request(factory_.get()); |
4707 EXPECT_EQ(ERR_IO_PENDING, | 4709 EXPECT_EQ(ERR_IO_PENDING, |
4708 request.Request(host_port_pair_, privacy_mode_, | 4710 request.Request(host_port_pair_, version_, privacy_mode_, |
4709 /*cert_verify_flags=*/0, url_, "GET", net_log_, | 4711 /*cert_verify_flags=*/0, url_, "GET", net_log_, |
4710 callback_.callback())); | 4712 callback_.callback())); |
4711 | 4713 |
4712 EXPECT_EQ(OK, callback_.WaitForResult()); | 4714 EXPECT_EQ(OK, callback_.WaitForResult()); |
4713 | 4715 |
4714 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); | 4716 QuicChromiumClientSession* session = GetActiveSession(host_port_pair_); |
4715 if (session->connection()->version() == QUIC_VERSION_36) { | 4717 if (session->connection()->version() == QUIC_VERSION_36) { |
4716 EXPECT_TRUE(session->force_hol_blocking()); | 4718 EXPECT_TRUE(session->force_hol_blocking()); |
4717 } else { | 4719 } else { |
4718 EXPECT_FALSE(session->force_hol_blocking()); | 4720 EXPECT_FALSE(session->force_hol_blocking()); |
(...skipping 75 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4794 ASSERT_TRUE(cert->VerifyNameMatch(origin2_.host(), false)); | 4796 ASSERT_TRUE(cert->VerifyNameMatch(origin2_.host(), false)); |
4795 | 4797 |
4796 ProofVerifyDetailsChromium verify_details; | 4798 ProofVerifyDetailsChromium verify_details; |
4797 verify_details.cert_verify_result.verified_cert = cert; | 4799 verify_details.cert_verify_result.verified_cert = cert; |
4798 verify_details.cert_verify_result.is_issued_by_known_root = true; | 4800 verify_details.cert_verify_result.is_issued_by_known_root = true; |
4799 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 4801 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
4800 | 4802 |
4801 AddHangingSocketData(); | 4803 AddHangingSocketData(); |
4802 | 4804 |
4803 QuicStreamRequest request(factory_.get()); | 4805 QuicStreamRequest request(factory_.get()); |
4804 EXPECT_EQ(ERR_IO_PENDING, request.Request(destination, privacy_mode_, | 4806 EXPECT_EQ(ERR_IO_PENDING, |
4805 /*cert_verify_flags=*/0, url, "GET", | 4807 request.Request(destination, version_, privacy_mode_, |
4806 net_log_, callback_.callback())); | 4808 /*cert_verify_flags=*/0, url, "GET", net_log_, |
| 4809 callback_.callback())); |
4807 | 4810 |
4808 EXPECT_THAT(callback_.WaitForResult(), IsError(ERR_QUIC_HANDSHAKE_FAILED)); | 4811 EXPECT_THAT(callback_.WaitForResult(), IsError(ERR_QUIC_HANDSHAKE_FAILED)); |
4809 | 4812 |
4810 EXPECT_TRUE(AllDataConsumed()); | 4813 EXPECT_TRUE(AllDataConsumed()); |
4811 } | 4814 } |
4812 | 4815 |
4813 // QuicStreamRequest is pooled based on |destination| if certificate matches. | 4816 // QuicStreamRequest is pooled based on |destination| if certificate matches. |
4814 TEST_P(QuicStreamFactoryWithDestinationTest, SharedCertificate) { | 4817 TEST_P(QuicStreamFactoryWithDestinationTest, SharedCertificate) { |
4815 Initialize(); | 4818 Initialize(); |
4816 | 4819 |
(...skipping 20 matching lines...) Expand all Loading... |
4837 client_maker_.MakeInitialSettingsPacket(1, nullptr)); | 4840 client_maker_.MakeInitialSettingsPacket(1, nullptr)); |
4838 MockWrite writes[] = {MockWrite(SYNCHRONOUS, settings_packet->data(), | 4841 MockWrite writes[] = {MockWrite(SYNCHRONOUS, settings_packet->data(), |
4839 settings_packet->length(), 1)}; | 4842 settings_packet->length(), 1)}; |
4840 std::unique_ptr<SequencedSocketData> sequenced_socket_data( | 4843 std::unique_ptr<SequencedSocketData> sequenced_socket_data( |
4841 new SequencedSocketData(reads, 1, writes, arraysize(writes))); | 4844 new SequencedSocketData(reads, 1, writes, arraysize(writes))); |
4842 socket_factory_.AddSocketDataProvider(sequenced_socket_data.get()); | 4845 socket_factory_.AddSocketDataProvider(sequenced_socket_data.get()); |
4843 sequenced_socket_data_vector_.push_back(std::move(sequenced_socket_data)); | 4846 sequenced_socket_data_vector_.push_back(std::move(sequenced_socket_data)); |
4844 | 4847 |
4845 QuicStreamRequest request1(factory_.get()); | 4848 QuicStreamRequest request1(factory_.get()); |
4846 EXPECT_EQ(ERR_IO_PENDING, | 4849 EXPECT_EQ(ERR_IO_PENDING, |
4847 request1.Request(destination, privacy_mode_, | 4850 request1.Request(destination, version_, privacy_mode_, |
4848 /*cert_verify_flags=*/0, url1, "GET", net_log_, | 4851 /*cert_verify_flags=*/0, url1, "GET", net_log_, |
4849 callback_.callback())); | 4852 callback_.callback())); |
4850 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 4853 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
4851 | 4854 |
4852 std::unique_ptr<HttpStream> stream1 = request1.CreateStream(); | 4855 std::unique_ptr<HttpStream> stream1 = request1.CreateStream(); |
4853 EXPECT_TRUE(stream1.get()); | 4856 EXPECT_TRUE(stream1.get()); |
4854 EXPECT_TRUE(HasActiveSession(origin1_)); | 4857 EXPECT_TRUE(HasActiveSession(origin1_)); |
4855 | 4858 |
4856 // Second request returns synchronously because it pools to existing session. | 4859 // Second request returns synchronously because it pools to existing session. |
4857 TestCompletionCallback callback2; | 4860 TestCompletionCallback callback2; |
4858 QuicStreamRequest request2(factory_.get()); | 4861 QuicStreamRequest request2(factory_.get()); |
4859 EXPECT_EQ(OK, request2.Request(destination, privacy_mode_, | 4862 EXPECT_EQ(OK, request2.Request(destination, version_, privacy_mode_, |
4860 /*cert_verify_flags=*/0, url2, "GET", net_log_, | 4863 /*cert_verify_flags=*/0, url2, "GET", net_log_, |
4861 callback2.callback())); | 4864 callback2.callback())); |
4862 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 4865 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
4863 EXPECT_TRUE(stream2.get()); | 4866 EXPECT_TRUE(stream2.get()); |
4864 | 4867 |
4865 QuicChromiumClientSession::Handle* session1 = | 4868 QuicChromiumClientSession::Handle* session1 = |
4866 QuicHttpStreamPeer::GetSessionHandle(stream1.get()); | 4869 QuicHttpStreamPeer::GetSessionHandle(stream1.get()); |
4867 QuicChromiumClientSession::Handle* session2 = | 4870 QuicChromiumClientSession::Handle* session2 = |
4868 QuicHttpStreamPeer::GetSessionHandle(stream2.get()); | 4871 QuicHttpStreamPeer::GetSessionHandle(stream2.get()); |
4869 EXPECT_TRUE(session1->SharesSameSession(*session2)); | 4872 EXPECT_TRUE(session1->SharesSameSession(*session2)); |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4909 new SequencedSocketData(reads, 1, writes, arraysize(writes))); | 4912 new SequencedSocketData(reads, 1, writes, arraysize(writes))); |
4910 socket_factory_.AddSocketDataProvider(sequenced_socket_data.get()); | 4913 socket_factory_.AddSocketDataProvider(sequenced_socket_data.get()); |
4911 sequenced_socket_data_vector_.push_back(std::move(sequenced_socket_data)); | 4914 sequenced_socket_data_vector_.push_back(std::move(sequenced_socket_data)); |
4912 std::unique_ptr<SequencedSocketData> sequenced_socket_data1( | 4915 std::unique_ptr<SequencedSocketData> sequenced_socket_data1( |
4913 new SequencedSocketData(reads, 1, writes, arraysize(writes))); | 4916 new SequencedSocketData(reads, 1, writes, arraysize(writes))); |
4914 socket_factory_.AddSocketDataProvider(sequenced_socket_data1.get()); | 4917 socket_factory_.AddSocketDataProvider(sequenced_socket_data1.get()); |
4915 sequenced_socket_data_vector_.push_back(std::move(sequenced_socket_data1)); | 4918 sequenced_socket_data_vector_.push_back(std::move(sequenced_socket_data1)); |
4916 | 4919 |
4917 QuicStreamRequest request1(factory_.get()); | 4920 QuicStreamRequest request1(factory_.get()); |
4918 EXPECT_EQ(ERR_IO_PENDING, | 4921 EXPECT_EQ(ERR_IO_PENDING, |
4919 request1.Request(destination, PRIVACY_MODE_DISABLED, | 4922 request1.Request(destination, version_, PRIVACY_MODE_DISABLED, |
4920 /*cert_verify_flags=*/0, url1, "GET", net_log_, | 4923 /*cert_verify_flags=*/0, url1, "GET", net_log_, |
4921 callback_.callback())); | 4924 callback_.callback())); |
4922 EXPECT_EQ(OK, callback_.WaitForResult()); | 4925 EXPECT_EQ(OK, callback_.WaitForResult()); |
4923 std::unique_ptr<HttpStream> stream1 = request1.CreateStream(); | 4926 std::unique_ptr<HttpStream> stream1 = request1.CreateStream(); |
4924 EXPECT_TRUE(stream1.get()); | 4927 EXPECT_TRUE(stream1.get()); |
4925 EXPECT_TRUE(HasActiveSession(origin1_)); | 4928 EXPECT_TRUE(HasActiveSession(origin1_)); |
4926 | 4929 |
4927 TestCompletionCallback callback2; | 4930 TestCompletionCallback callback2; |
4928 QuicStreamRequest request2(factory_.get()); | 4931 QuicStreamRequest request2(factory_.get()); |
4929 EXPECT_EQ(ERR_IO_PENDING, | 4932 EXPECT_EQ(ERR_IO_PENDING, |
4930 request2.Request(destination, PRIVACY_MODE_ENABLED, | 4933 request2.Request(destination, version_, PRIVACY_MODE_ENABLED, |
4931 /*cert_verify_flags=*/0, url2, "GET", net_log_, | 4934 /*cert_verify_flags=*/0, url2, "GET", net_log_, |
4932 callback2.callback())); | 4935 callback2.callback())); |
4933 EXPECT_EQ(OK, callback2.WaitForResult()); | 4936 EXPECT_EQ(OK, callback2.WaitForResult()); |
4934 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 4937 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
4935 EXPECT_TRUE(stream2.get()); | 4938 EXPECT_TRUE(stream2.get()); |
4936 | 4939 |
4937 // |request2| does not pool to the first session, because PrivacyMode does not | 4940 // |request2| does not pool to the first session, because PrivacyMode does not |
4938 // match. Instead, another session is opened to the same destination, but | 4941 // match. Instead, another session is opened to the same destination, but |
4939 // with a different QuicServerId. | 4942 // with a different QuicServerId. |
4940 QuicChromiumClientSession::Handle* session1 = | 4943 QuicChromiumClientSession::Handle* session1 = |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4992 new SequencedSocketData(reads, 1, writes, arraysize(writes))); | 4995 new SequencedSocketData(reads, 1, writes, arraysize(writes))); |
4993 socket_factory_.AddSocketDataProvider(sequenced_socket_data.get()); | 4996 socket_factory_.AddSocketDataProvider(sequenced_socket_data.get()); |
4994 sequenced_socket_data_vector_.push_back(std::move(sequenced_socket_data)); | 4997 sequenced_socket_data_vector_.push_back(std::move(sequenced_socket_data)); |
4995 std::unique_ptr<SequencedSocketData> sequenced_socket_data1( | 4998 std::unique_ptr<SequencedSocketData> sequenced_socket_data1( |
4996 new SequencedSocketData(reads, 1, writes, arraysize(writes))); | 4999 new SequencedSocketData(reads, 1, writes, arraysize(writes))); |
4997 socket_factory_.AddSocketDataProvider(sequenced_socket_data1.get()); | 5000 socket_factory_.AddSocketDataProvider(sequenced_socket_data1.get()); |
4998 sequenced_socket_data_vector_.push_back(std::move(sequenced_socket_data1)); | 5001 sequenced_socket_data_vector_.push_back(std::move(sequenced_socket_data1)); |
4999 | 5002 |
5000 QuicStreamRequest request1(factory_.get()); | 5003 QuicStreamRequest request1(factory_.get()); |
5001 EXPECT_EQ(ERR_IO_PENDING, | 5004 EXPECT_EQ(ERR_IO_PENDING, |
5002 request1.Request(destination, privacy_mode_, | 5005 request1.Request(destination, version_, privacy_mode_, |
5003 /*cert_verify_flags=*/0, url1, "GET", net_log_, | 5006 /*cert_verify_flags=*/0, url1, "GET", net_log_, |
5004 callback_.callback())); | 5007 callback_.callback())); |
5005 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 5008 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
5006 std::unique_ptr<HttpStream> stream1 = request1.CreateStream(); | 5009 std::unique_ptr<HttpStream> stream1 = request1.CreateStream(); |
5007 EXPECT_TRUE(stream1.get()); | 5010 EXPECT_TRUE(stream1.get()); |
5008 EXPECT_TRUE(HasActiveSession(origin1_)); | 5011 EXPECT_TRUE(HasActiveSession(origin1_)); |
5009 | 5012 |
5010 TestCompletionCallback callback2; | 5013 TestCompletionCallback callback2; |
5011 QuicStreamRequest request2(factory_.get()); | 5014 QuicStreamRequest request2(factory_.get()); |
5012 EXPECT_EQ(ERR_IO_PENDING, | 5015 EXPECT_EQ(ERR_IO_PENDING, |
5013 request2.Request(destination, privacy_mode_, | 5016 request2.Request(destination, version_, privacy_mode_, |
5014 /*cert_verify_flags=*/0, url2, "GET", net_log_, | 5017 /*cert_verify_flags=*/0, url2, "GET", net_log_, |
5015 callback2.callback())); | 5018 callback2.callback())); |
5016 EXPECT_THAT(callback2.WaitForResult(), IsOk()); | 5019 EXPECT_THAT(callback2.WaitForResult(), IsOk()); |
5017 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); | 5020 std::unique_ptr<HttpStream> stream2 = request2.CreateStream(); |
5018 EXPECT_TRUE(stream2.get()); | 5021 EXPECT_TRUE(stream2.get()); |
5019 | 5022 |
5020 // |request2| does not pool to the first session, because the certificate does | 5023 // |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 | 5024 // not match. Instead, another session is opened to the same destination, but |
5022 // with a different QuicServerId. | 5025 // with a different QuicServerId. |
5023 QuicChromiumClientSession::Handle* session1 = | 5026 QuicChromiumClientSession::Handle* session1 = |
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5074 // Clear all cached states. | 5077 // Clear all cached states. |
5075 factory_->ClearCachedStatesInCryptoConfig( | 5078 factory_->ClearCachedStatesInCryptoConfig( |
5076 base::Callback<bool(const GURL&)>()); | 5079 base::Callback<bool(const GURL&)>()); |
5077 EXPECT_TRUE(test_cases[0].state->certs().empty()); | 5080 EXPECT_TRUE(test_cases[0].state->certs().empty()); |
5078 EXPECT_TRUE(test_cases[1].state->certs().empty()); | 5081 EXPECT_TRUE(test_cases[1].state->certs().empty()); |
5079 EXPECT_TRUE(test_cases[2].state->certs().empty()); | 5082 EXPECT_TRUE(test_cases[2].state->certs().empty()); |
5080 } | 5083 } |
5081 | 5084 |
5082 } // namespace test | 5085 } // namespace test |
5083 } // namespace net | 5086 } // namespace net |
OLD | NEW |