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