Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(19)

Side by Side Diff: net/quic/chromium/quic_stream_factory_test.cc

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

Powered by Google App Engine
This is Rietveld 408576698