OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include <memory> | 5 #include <memory> |
6 #include <ostream> | 6 #include <ostream> |
7 #include <string> | 7 #include <string> |
8 #include <utility> | 8 #include <utility> |
9 #include <vector> | 9 #include <vector> |
10 | 10 |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
47 #include "net/quic/chromium/quic_test_packet_maker.h" | 47 #include "net/quic/chromium/quic_test_packet_maker.h" |
48 #include "net/quic/chromium/test_task_runner.h" | 48 #include "net/quic/chromium/test_task_runner.h" |
49 #include "net/quic/core/crypto/quic_decrypter.h" | 49 #include "net/quic/core/crypto/quic_decrypter.h" |
50 #include "net/quic/core/crypto/quic_encrypter.h" | 50 #include "net/quic/core/crypto/quic_encrypter.h" |
51 #include "net/quic/core/quic_framer.h" | 51 #include "net/quic/core/quic_framer.h" |
52 #include "net/quic/platform/api/quic_string_piece.h" | 52 #include "net/quic/platform/api/quic_string_piece.h" |
53 #include "net/quic/platform/impl/quic_test_impl.h" | 53 #include "net/quic/platform/impl/quic_test_impl.h" |
54 #include "net/quic/test_tools/crypto_test_utils.h" | 54 #include "net/quic/test_tools/crypto_test_utils.h" |
55 #include "net/quic/test_tools/mock_clock.h" | 55 #include "net/quic/test_tools/mock_clock.h" |
56 #include "net/quic/test_tools/mock_random.h" | 56 #include "net/quic/test_tools/mock_random.h" |
57 #include "net/quic/test_tools/quic_spdy_session_peer.h" | |
58 #include "net/quic/test_tools/quic_test_utils.h" | 57 #include "net/quic/test_tools/quic_test_utils.h" |
59 #include "net/socket/client_socket_factory.h" | 58 #include "net/socket/client_socket_factory.h" |
60 #include "net/socket/mock_client_socket_pool_manager.h" | 59 #include "net/socket/mock_client_socket_pool_manager.h" |
61 #include "net/socket/next_proto.h" | 60 #include "net/socket/next_proto.h" |
62 #include "net/socket/socket_performance_watcher.h" | 61 #include "net/socket/socket_performance_watcher.h" |
63 #include "net/socket/socket_performance_watcher_factory.h" | 62 #include "net/socket/socket_performance_watcher_factory.h" |
64 #include "net/socket/socket_test_util.h" | 63 #include "net/socket/socket_test_util.h" |
65 #include "net/spdy/core/spdy_frame_builder.h" | 64 #include "net/spdy/core/spdy_frame_builder.h" |
66 #include "net/spdy/core/spdy_framer.h" | 65 #include "net/spdy/core/spdy_framer.h" |
67 #include "net/ssl/ssl_config_service_defaults.h" | 66 #include "net/ssl/ssl_config_service_defaults.h" |
(...skipping 642 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
710 EXPECT_TRUE(session_->proxy_service()->proxy_retry_info().empty()); | 709 EXPECT_TRUE(session_->proxy_service()->proxy_retry_info().empty()); |
711 | 710 |
712 // The alternative proxy server should no longer be in use. | 711 // The alternative proxy server should no longer be in use. |
713 EXPECT_FALSE(test_proxy_delegate.alternative_proxy_server().is_valid()); | 712 EXPECT_FALSE(test_proxy_delegate.alternative_proxy_server().is_valid()); |
714 | 713 |
715 // Verify that the second request completes successfully, and the | 714 // Verify that the second request completes successfully, and the |
716 // alternative proxy server job is not started. | 715 // alternative proxy server job is not started. |
717 SendRequestAndExpectHttpResponseFromProxy("hello from http", true, 443); | 716 SendRequestAndExpectHttpResponseFromProxy("hello from http", true, 443); |
718 } | 717 } |
719 | 718 |
720 QuicStreamId GetNthClientInitiatedStreamId(int n) { | |
721 return test::GetNthClientInitiatedStreamId(version_, n); | |
722 } | |
723 | |
724 QuicStreamId GetNthServerInitiatedStreamId(int n) { | |
725 return test::GetNthServerInitiatedStreamId(version_, n); | |
726 } | |
727 | |
728 const QuicVersion version_; | 719 const QuicVersion version_; |
729 QuicFlagSaver flags_; // Save/restore all QUIC flag values. | 720 QuicFlagSaver flags_; // Save/restore all QUIC flag values. |
730 MockClock clock_; | 721 MockClock clock_; |
731 QuicTestPacketMaker client_maker_; | 722 QuicTestPacketMaker client_maker_; |
732 QuicTestPacketMaker server_maker_; | 723 QuicTestPacketMaker server_maker_; |
733 std::unique_ptr<HttpNetworkSession> session_; | 724 std::unique_ptr<HttpNetworkSession> session_; |
734 MockClientSocketFactory socket_factory_; | 725 MockClientSocketFactory socket_factory_; |
735 ProofVerifyDetailsChromium verify_details_; | 726 ProofVerifyDetailsChromium verify_details_; |
736 MockCryptoClientStreamFactory crypto_client_stream_factory_; | 727 MockCryptoClientStreamFactory crypto_client_stream_factory_; |
737 MockHostResolver host_resolver_; | 728 MockHostResolver host_resolver_; |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
780 | 771 |
781 TEST_P(QuicNetworkTransactionTest, SocketWatcherEnabled) { | 772 TEST_P(QuicNetworkTransactionTest, SocketWatcherEnabled) { |
782 params_.origins_to_force_quic_on.insert( | 773 params_.origins_to_force_quic_on.insert( |
783 HostPortPair::FromString("mail.example.org:443")); | 774 HostPortPair::FromString("mail.example.org:443")); |
784 | 775 |
785 MockQuicData mock_quic_data; | 776 MockQuicData mock_quic_data; |
786 QuicStreamOffset header_stream_offset = 0; | 777 QuicStreamOffset header_stream_offset = 0; |
787 mock_quic_data.AddWrite( | 778 mock_quic_data.AddWrite( |
788 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 779 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
789 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 780 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
790 2, GetNthClientInitiatedStreamId(0), true, true, | 781 2, kClientDataStreamId1, true, true, |
791 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); | 782 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
792 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 783 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
793 1, GetNthClientInitiatedStreamId(0), false, false, | 784 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"))); |
794 GetResponseHeaders("200 OK"))); | 785 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1, |
795 mock_quic_data.AddRead(ConstructServerDataPacket( | 786 false, true, 0, "hello!")); |
796 2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!")); | |
797 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); | 787 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); |
798 mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read | 788 mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
799 | 789 |
800 mock_quic_data.AddSocketDataToFactory(&socket_factory_); | 790 mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
801 | 791 |
802 CreateSession(); | 792 CreateSession(); |
803 test_socket_performance_watcher_factory_.set_should_notify_updated_rtt(true); | 793 test_socket_performance_watcher_factory_.set_should_notify_updated_rtt(true); |
804 | 794 |
805 EXPECT_FALSE( | 795 EXPECT_FALSE( |
806 test_socket_performance_watcher_factory_.rtt_notification_received()); | 796 test_socket_performance_watcher_factory_.rtt_notification_received()); |
807 SendRequestAndExpectQuicResponse("hello!"); | 797 SendRequestAndExpectQuicResponse("hello!"); |
808 EXPECT_TRUE( | 798 EXPECT_TRUE( |
809 test_socket_performance_watcher_factory_.rtt_notification_received()); | 799 test_socket_performance_watcher_factory_.rtt_notification_received()); |
810 } | 800 } |
811 | 801 |
812 TEST_P(QuicNetworkTransactionTest, SocketWatcherDisabled) { | 802 TEST_P(QuicNetworkTransactionTest, SocketWatcherDisabled) { |
813 params_.origins_to_force_quic_on.insert( | 803 params_.origins_to_force_quic_on.insert( |
814 HostPortPair::FromString("mail.example.org:443")); | 804 HostPortPair::FromString("mail.example.org:443")); |
815 | 805 |
816 MockQuicData mock_quic_data; | 806 MockQuicData mock_quic_data; |
817 QuicStreamOffset header_stream_offset = 0; | 807 QuicStreamOffset header_stream_offset = 0; |
818 mock_quic_data.AddWrite( | 808 mock_quic_data.AddWrite( |
819 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 809 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
820 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 810 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
821 2, GetNthClientInitiatedStreamId(0), true, true, | 811 2, kClientDataStreamId1, true, true, |
822 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); | 812 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
823 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 813 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
824 1, GetNthClientInitiatedStreamId(0), false, false, | 814 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"))); |
825 GetResponseHeaders("200 OK"))); | 815 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1, |
826 mock_quic_data.AddRead(ConstructServerDataPacket( | 816 false, true, 0, "hello!")); |
827 2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!")); | |
828 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); | 817 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); |
829 mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read | 818 mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
830 | 819 |
831 mock_quic_data.AddSocketDataToFactory(&socket_factory_); | 820 mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
832 | 821 |
833 CreateSession(); | 822 CreateSession(); |
834 test_socket_performance_watcher_factory_.set_should_notify_updated_rtt(false); | 823 test_socket_performance_watcher_factory_.set_should_notify_updated_rtt(false); |
835 | 824 |
836 EXPECT_FALSE( | 825 EXPECT_FALSE( |
837 test_socket_performance_watcher_factory_.rtt_notification_received()); | 826 test_socket_performance_watcher_factory_.rtt_notification_received()); |
838 SendRequestAndExpectQuicResponse("hello!"); | 827 SendRequestAndExpectQuicResponse("hello!"); |
839 EXPECT_FALSE( | 828 EXPECT_FALSE( |
840 test_socket_performance_watcher_factory_.rtt_notification_received()); | 829 test_socket_performance_watcher_factory_.rtt_notification_received()); |
841 } | 830 } |
842 | 831 |
843 TEST_P(QuicNetworkTransactionTest, ForceQuic) { | 832 TEST_P(QuicNetworkTransactionTest, ForceQuic) { |
844 params_.origins_to_force_quic_on.insert( | 833 params_.origins_to_force_quic_on.insert( |
845 HostPortPair::FromString("mail.example.org:443")); | 834 HostPortPair::FromString("mail.example.org:443")); |
846 | 835 |
847 MockQuicData mock_quic_data; | 836 MockQuicData mock_quic_data; |
848 QuicStreamOffset header_stream_offset = 0; | 837 QuicStreamOffset header_stream_offset = 0; |
849 mock_quic_data.AddWrite( | 838 mock_quic_data.AddWrite( |
850 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 839 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
851 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 840 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
852 2, GetNthClientInitiatedStreamId(0), true, true, | 841 2, kClientDataStreamId1, true, true, |
853 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); | 842 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
854 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 843 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
855 1, GetNthClientInitiatedStreamId(0), false, false, | 844 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"))); |
856 GetResponseHeaders("200 OK"))); | 845 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1, |
857 mock_quic_data.AddRead(ConstructServerDataPacket( | 846 false, true, 0, "hello!")); |
858 2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!")); | |
859 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); | 847 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); |
860 mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read | 848 mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
861 | 849 |
862 mock_quic_data.AddSocketDataToFactory(&socket_factory_); | 850 mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
863 | 851 |
864 CreateSession(); | 852 CreateSession(); |
865 | 853 |
866 SendRequestAndExpectQuicResponse("hello!"); | 854 SendRequestAndExpectQuicResponse("hello!"); |
867 | 855 |
868 // Check that the NetLog was filled reasonably. | 856 // Check that the NetLog was filled reasonably. |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
907 TEST_P(QuicNetworkTransactionTest, ForceQuicForAll) { | 895 TEST_P(QuicNetworkTransactionTest, ForceQuicForAll) { |
908 params_.origins_to_force_quic_on.insert(HostPortPair()); | 896 params_.origins_to_force_quic_on.insert(HostPortPair()); |
909 | 897 |
910 AddQuicAlternateProtocolMapping(MockCryptoClientStream::CONFIRM_HANDSHAKE); | 898 AddQuicAlternateProtocolMapping(MockCryptoClientStream::CONFIRM_HANDSHAKE); |
911 | 899 |
912 MockQuicData mock_quic_data; | 900 MockQuicData mock_quic_data; |
913 QuicStreamOffset header_stream_offset = 0; | 901 QuicStreamOffset header_stream_offset = 0; |
914 mock_quic_data.AddWrite( | 902 mock_quic_data.AddWrite( |
915 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 903 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
916 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 904 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
917 2, GetNthClientInitiatedStreamId(0), true, true, | 905 2, kClientDataStreamId1, true, true, |
918 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); | 906 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
919 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 907 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
920 1, GetNthClientInitiatedStreamId(0), false, false, | 908 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"))); |
921 GetResponseHeaders("200 OK"))); | 909 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1, |
922 mock_quic_data.AddRead(ConstructServerDataPacket( | 910 false, true, 0, "hello!")); |
923 2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!")); | |
924 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); | 911 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); |
925 mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read | 912 mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
926 | 913 |
927 mock_quic_data.AddSocketDataToFactory(&socket_factory_); | 914 mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
928 | 915 |
929 CreateSession(); | 916 CreateSession(); |
930 | 917 |
931 SendRequestAndExpectQuicResponse("hello!"); | 918 SendRequestAndExpectQuicResponse("hello!"); |
932 EXPECT_TRUE( | 919 EXPECT_TRUE( |
933 test_socket_performance_watcher_factory_.rtt_notification_received()); | 920 test_socket_performance_watcher_factory_.rtt_notification_received()); |
934 } | 921 } |
935 | 922 |
936 TEST_P(QuicNetworkTransactionTest, QuicProxy) { | 923 TEST_P(QuicNetworkTransactionTest, QuicProxy) { |
937 params_.enable_quic = true; | 924 params_.enable_quic = true; |
938 proxy_service_ = | 925 proxy_service_ = |
939 ProxyService::CreateFixedFromPacResult("QUIC mail.example.org:70"); | 926 ProxyService::CreateFixedFromPacResult("QUIC mail.example.org:70"); |
940 | 927 |
941 MockQuicData mock_quic_data; | 928 MockQuicData mock_quic_data; |
942 QuicStreamOffset header_stream_offset = 0; | 929 QuicStreamOffset header_stream_offset = 0; |
943 mock_quic_data.AddWrite( | 930 mock_quic_data.AddWrite( |
944 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 931 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
945 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 932 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
946 2, GetNthClientInitiatedStreamId(0), true, true, | 933 2, kClientDataStreamId1, true, true, |
947 GetRequestHeaders("GET", "http", "/"), &header_stream_offset)); | 934 GetRequestHeaders("GET", "http", "/"), &header_stream_offset)); |
948 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 935 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
949 1, GetNthClientInitiatedStreamId(0), false, false, | 936 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"))); |
950 GetResponseHeaders("200 OK"))); | 937 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1, |
951 mock_quic_data.AddRead(ConstructServerDataPacket( | 938 false, true, 0, "hello!")); |
952 2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!")); | |
953 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); | 939 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); |
954 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read | 940 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
955 mock_quic_data.AddRead(ASYNC, 0); // EOF | 941 mock_quic_data.AddRead(ASYNC, 0); // EOF |
956 | 942 |
957 mock_quic_data.AddSocketDataToFactory(&socket_factory_); | 943 mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
958 | 944 |
959 EXPECT_FALSE( | 945 EXPECT_FALSE( |
960 test_socket_performance_watcher_factory_.rtt_notification_received()); | 946 test_socket_performance_watcher_factory_.rtt_notification_received()); |
961 // There is no need to set up an alternate protocol job, because | 947 // There is no need to set up an alternate protocol job, because |
962 // no attempt will be made to speak to the proxy over TCP. | 948 // no attempt will be made to speak to the proxy over TCP. |
(...skipping 16 matching lines...) Expand all Loading... |
979 params_.enable_quic = true; | 965 params_.enable_quic = true; |
980 proxy_service_ = | 966 proxy_service_ = |
981 ProxyService::CreateFixedFromPacResult("QUIC " + proxy_host + ":70"); | 967 ProxyService::CreateFixedFromPacResult("QUIC " + proxy_host + ":70"); |
982 | 968 |
983 client_maker_.set_hostname(origin_host); | 969 client_maker_.set_hostname(origin_host); |
984 MockQuicData mock_quic_data; | 970 MockQuicData mock_quic_data; |
985 QuicStreamOffset header_stream_offset = 0; | 971 QuicStreamOffset header_stream_offset = 0; |
986 mock_quic_data.AddWrite( | 972 mock_quic_data.AddWrite( |
987 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 973 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
988 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 974 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
989 2, GetNthClientInitiatedStreamId(0), true, true, | 975 2, kClientDataStreamId1, true, true, |
990 GetRequestHeaders("GET", "http", "/"), &header_stream_offset)); | 976 GetRequestHeaders("GET", "http", "/"), &header_stream_offset)); |
991 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 977 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
992 1, GetNthClientInitiatedStreamId(0), false, false, | 978 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"))); |
993 GetResponseHeaders("200 OK"))); | 979 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1, |
994 mock_quic_data.AddRead(ConstructServerDataPacket( | 980 false, true, 0, "hello!")); |
995 2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!")); | |
996 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); | 981 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); |
997 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read | 982 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
998 mock_quic_data.AddRead(ASYNC, 0); | 983 mock_quic_data.AddRead(ASYNC, 0); |
999 mock_quic_data.AddSocketDataToFactory(&socket_factory_); | 984 mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
1000 | 985 |
1001 scoped_refptr<X509Certificate> cert( | 986 scoped_refptr<X509Certificate> cert( |
1002 ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem")); | 987 ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem")); |
1003 ASSERT_TRUE(cert.get()); | 988 ASSERT_TRUE(cert.get()); |
1004 // This certificate is valid for the proxy, but not for the origin. | 989 // This certificate is valid for the proxy, but not for the origin. |
1005 EXPECT_TRUE(cert->VerifyNameMatch(proxy_host, false)); | 990 EXPECT_TRUE(cert->VerifyNameMatch(proxy_host, false)); |
(...skipping 27 matching lines...) Expand all Loading... |
1033 ProofVerifyDetailsChromium verify_details; | 1018 ProofVerifyDetailsChromium verify_details; |
1034 verify_details.cert_verify_result.verified_cert = cert; | 1019 verify_details.cert_verify_result.verified_cert = cert; |
1035 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); | 1020 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); |
1036 | 1021 |
1037 client_maker_.set_hostname(origin.host()); | 1022 client_maker_.set_hostname(origin.host()); |
1038 MockQuicData mock_quic_data; | 1023 MockQuicData mock_quic_data; |
1039 QuicStreamOffset header_stream_offset = 0; | 1024 QuicStreamOffset header_stream_offset = 0; |
1040 mock_quic_data.AddWrite( | 1025 mock_quic_data.AddWrite( |
1041 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 1026 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
1042 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 1027 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
1043 2, GetNthClientInitiatedStreamId(0), true, true, | 1028 2, kClientDataStreamId1, true, true, |
1044 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); | 1029 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
1045 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 1030 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
1046 1, GetNthClientInitiatedStreamId(0), false, false, | 1031 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"))); |
1047 GetResponseHeaders("200 OK"))); | 1032 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1, |
1048 mock_quic_data.AddRead(ConstructServerDataPacket( | 1033 false, true, 0, "hello!")); |
1049 2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!")); | |
1050 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); | 1034 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); |
1051 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read | 1035 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
1052 mock_quic_data.AddRead(ASYNC, 0); | 1036 mock_quic_data.AddRead(ASYNC, 0); |
1053 mock_quic_data.AddSocketDataToFactory(&socket_factory_); | 1037 mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
1054 | 1038 |
1055 request_.url = GURL("https://" + origin.host()); | 1039 request_.url = GURL("https://" + origin.host()); |
1056 AddQuicRemoteAlternativeServiceMapping( | 1040 AddQuicRemoteAlternativeServiceMapping( |
1057 MockCryptoClientStream::CONFIRM_HANDSHAKE, alternative); | 1041 MockCryptoClientStream::CONFIRM_HANDSHAKE, alternative); |
1058 AddHangingNonAlternateProtocolSocketData(); | 1042 AddHangingNonAlternateProtocolSocketData(); |
1059 CreateSession(); | 1043 CreateSession(); |
(...skipping 16 matching lines...) Expand all Loading... |
1076 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); | 1060 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
1077 http_server_properties_.SetAlternativeService(server, alternative_service, | 1061 http_server_properties_.SetAlternativeService(server, alternative_service, |
1078 expiration); | 1062 expiration); |
1079 | 1063 |
1080 // First try: alternative job uses QUIC, gets 421 Misdirected Request error. | 1064 // First try: alternative job uses QUIC, gets 421 Misdirected Request error. |
1081 MockQuicData mock_quic_data; | 1065 MockQuicData mock_quic_data; |
1082 QuicStreamOffset request_header_offset = 0; | 1066 QuicStreamOffset request_header_offset = 0; |
1083 mock_quic_data.AddWrite( | 1067 mock_quic_data.AddWrite( |
1084 ConstructInitialSettingsPacket(1, &request_header_offset)); | 1068 ConstructInitialSettingsPacket(1, &request_header_offset)); |
1085 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 1069 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
1086 2, GetNthClientInitiatedStreamId(0), true, true, | 1070 2, kClientDataStreamId1, true, true, |
1087 GetRequestHeaders("GET", "https", "/"), &request_header_offset)); | 1071 GetRequestHeaders("GET", "https", "/"), &request_header_offset)); |
1088 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 1072 mock_quic_data.AddRead( |
1089 1, GetNthClientInitiatedStreamId(0), false, true, | 1073 ConstructServerResponseHeadersPacket(1, kClientDataStreamId1, false, true, |
1090 GetResponseHeaders("421"), nullptr)); | 1074 GetResponseHeaders("421"), nullptr)); |
1091 mock_quic_data.AddWrite(ConstructClientAckAndRstPacket( | 1075 mock_quic_data.AddWrite(ConstructClientAckAndRstPacket( |
1092 3, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED, 1, 1, 1)); | 1076 3, kClientDataStreamId1, QUIC_STREAM_CANCELLED, 1, 1, 1)); |
1093 mock_quic_data.AddRead(ASYNC, OK); | 1077 mock_quic_data.AddRead(ASYNC, OK); |
1094 mock_quic_data.AddSocketDataToFactory(&socket_factory_); | 1078 mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
1095 | 1079 |
1096 // First try: main job uses TCP, connection fails. | 1080 // First try: main job uses TCP, connection fails. |
1097 // (A hanging connection would not work here, because the main Job on the | 1081 // (A hanging connection would not work here, because the main Job on the |
1098 // second try would pool to that socket and hang.) | 1082 // second try would pool to that socket and hang.) |
1099 StaticSocketDataProvider failing_data; | 1083 StaticSocketDataProvider failing_data; |
1100 MockConnect failing_connect(SYNCHRONOUS, ERR_CONNECTION_CLOSED); | 1084 MockConnect failing_connect(SYNCHRONOUS, ERR_CONNECTION_CLOSED); |
1101 failing_data.set_connect_data(failing_connect); | 1085 failing_data.set_connect_data(failing_connect); |
1102 socket_factory_.AddSocketDataProvider(&failing_data); | 1086 socket_factory_.AddSocketDataProvider(&failing_data); |
(...skipping 84 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1187 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr, | 1171 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr, |
1188 0); | 1172 0); |
1189 socket_factory_.AddSocketDataProvider(&http_data); | 1173 socket_factory_.AddSocketDataProvider(&http_data); |
1190 socket_factory_.AddSSLSocketDataProvider(&ssl_data_); | 1174 socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
1191 | 1175 |
1192 MockQuicData mock_quic_data; | 1176 MockQuicData mock_quic_data; |
1193 QuicStreamOffset header_stream_offset = 0; | 1177 QuicStreamOffset header_stream_offset = 0; |
1194 mock_quic_data.AddWrite( | 1178 mock_quic_data.AddWrite( |
1195 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 1179 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
1196 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 1180 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
1197 2, GetNthClientInitiatedStreamId(0), true, true, | 1181 2, kClientDataStreamId1, true, true, |
1198 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); | 1182 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
1199 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 1183 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
1200 1, GetNthClientInitiatedStreamId(0), false, false, | 1184 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"))); |
1201 GetResponseHeaders("200 OK"))); | 1185 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1, |
1202 mock_quic_data.AddRead(ConstructServerDataPacket( | 1186 false, true, 0, "hello!")); |
1203 2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!")); | |
1204 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); | 1187 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); |
1205 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read | 1188 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
1206 mock_quic_data.AddRead(ASYNC, 0); // EOF | 1189 mock_quic_data.AddRead(ASYNC, 0); // EOF |
1207 | 1190 |
1208 mock_quic_data.AddSocketDataToFactory(&socket_factory_); | 1191 mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
1209 | 1192 |
1210 AddHangingNonAlternateProtocolSocketData(); | 1193 AddHangingNonAlternateProtocolSocketData(); |
1211 CreateSession(); | 1194 CreateSession(); |
1212 | 1195 |
1213 SendRequestAndExpectHttpResponse("hello world"); | 1196 SendRequestAndExpectHttpResponse("hello world"); |
(...skipping 12 matching lines...) Expand all Loading... |
1226 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr, | 1209 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr, |
1227 0); | 1210 0); |
1228 socket_factory_.AddSocketDataProvider(&http_data); | 1211 socket_factory_.AddSocketDataProvider(&http_data); |
1229 socket_factory_.AddSSLSocketDataProvider(&ssl_data_); | 1212 socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
1230 | 1213 |
1231 MockQuicData mock_quic_data; | 1214 MockQuicData mock_quic_data; |
1232 QuicStreamOffset header_stream_offset = 0; | 1215 QuicStreamOffset header_stream_offset = 0; |
1233 mock_quic_data.AddWrite( | 1216 mock_quic_data.AddWrite( |
1234 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 1217 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
1235 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 1218 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
1236 2, GetNthClientInitiatedStreamId(0), true, true, | 1219 2, kClientDataStreamId1, true, true, |
1237 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); | 1220 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
1238 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 1221 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
1239 1, GetNthClientInitiatedStreamId(0), false, false, | 1222 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"))); |
1240 GetResponseHeaders("200 OK"))); | 1223 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1, |
1241 mock_quic_data.AddRead(ConstructServerDataPacket( | 1224 false, true, 0, "hello!")); |
1242 2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!")); | |
1243 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); | 1225 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); |
1244 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read | 1226 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
1245 mock_quic_data.AddRead(ASYNC, 0); // EOF | 1227 mock_quic_data.AddRead(ASYNC, 0); // EOF |
1246 | 1228 |
1247 mock_quic_data.AddSocketDataToFactory(&socket_factory_); | 1229 mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
1248 | 1230 |
1249 AddHangingNonAlternateProtocolSocketData(); | 1231 AddHangingNonAlternateProtocolSocketData(); |
1250 CreateSession(); | 1232 CreateSession(); |
1251 | 1233 |
1252 SendRequestAndExpectHttpResponse("hello world"); | 1234 SendRequestAndExpectHttpResponse("hello world"); |
(...skipping 78 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1331 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr, | 1313 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr, |
1332 0); | 1314 0); |
1333 socket_factory_.AddSocketDataProvider(&http_data); | 1315 socket_factory_.AddSocketDataProvider(&http_data); |
1334 socket_factory_.AddSSLSocketDataProvider(&ssl_data_); | 1316 socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
1335 | 1317 |
1336 MockQuicData mock_quic_data; | 1318 MockQuicData mock_quic_data; |
1337 QuicStreamOffset header_stream_offset = 0; | 1319 QuicStreamOffset header_stream_offset = 0; |
1338 mock_quic_data.AddWrite( | 1320 mock_quic_data.AddWrite( |
1339 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 1321 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
1340 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 1322 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
1341 2, GetNthClientInitiatedStreamId(0), true, true, | 1323 2, kClientDataStreamId1, true, true, |
1342 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); | 1324 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
1343 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 1325 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
1344 1, GetNthClientInitiatedStreamId(0), false, false, | 1326 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"))); |
1345 GetResponseHeaders("200 OK"))); | 1327 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1, |
1346 mock_quic_data.AddRead(ConstructServerDataPacket( | 1328 false, true, 0, "hello!")); |
1347 2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!")); | |
1348 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); | 1329 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); |
1349 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read | 1330 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
1350 mock_quic_data.AddRead(ASYNC, 0); // EOF | 1331 mock_quic_data.AddRead(ASYNC, 0); // EOF |
1351 | 1332 |
1352 mock_quic_data.AddSocketDataToFactory(&socket_factory_); | 1333 mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
1353 | 1334 |
1354 AddHangingNonAlternateProtocolSocketData(); | 1335 AddHangingNonAlternateProtocolSocketData(); |
1355 CreateSession(); | 1336 CreateSession(); |
1356 | 1337 |
1357 SendRequestAndExpectHttpResponse("hello world"); | 1338 SendRequestAndExpectHttpResponse("hello world"); |
1358 SendRequestAndExpectQuicResponse("hello!"); | 1339 SendRequestAndExpectQuicResponse("hello!"); |
1359 } | 1340 } |
1360 | 1341 |
1361 TEST_P(QuicNetworkTransactionTest, GoAwayWithConnectionMigrationOnPortsOnly) { | 1342 TEST_P(QuicNetworkTransactionTest, GoAwayWithConnectionMigrationOnPortsOnly) { |
1362 MockQuicData mock_quic_data; | 1343 MockQuicData mock_quic_data; |
1363 QuicStreamOffset header_stream_offset = 0; | 1344 QuicStreamOffset header_stream_offset = 0; |
1364 mock_quic_data.AddWrite( | 1345 mock_quic_data.AddWrite( |
1365 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 1346 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
1366 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 1347 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
1367 2, GetNthClientInitiatedStreamId(0), true, true, | 1348 2, kClientDataStreamId1, true, true, |
1368 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); | 1349 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
1369 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 1350 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
1370 1, GetNthClientInitiatedStreamId(0), false, false, | 1351 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"))); |
1371 GetResponseHeaders("200 OK"))); | |
1372 // Read a GoAway packet with | 1352 // Read a GoAway packet with |
1373 // QuicErrorCode: QUIC_ERROR_MIGRATING_PORT from the peer. | 1353 // QuicErrorCode: QUIC_ERROR_MIGRATING_PORT from the peer. |
1374 mock_quic_data.AddSynchronousRead(ConstructServerGoAwayPacket( | 1354 mock_quic_data.AddSynchronousRead(ConstructServerGoAwayPacket( |
1375 2, QUIC_ERROR_MIGRATING_PORT, | 1355 2, QUIC_ERROR_MIGRATING_PORT, |
1376 "connection migration with port change only")); | 1356 "connection migration with port change only")); |
1377 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); | 1357 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); |
1378 mock_quic_data.AddSynchronousRead(ConstructServerDataPacket( | 1358 mock_quic_data.AddSynchronousRead(ConstructServerDataPacket( |
1379 3, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!")); | 1359 3, kClientDataStreamId1, false, true, 0, "hello!")); |
1380 mock_quic_data.AddWrite(ConstructClientAckAndRstPacket( | 1360 mock_quic_data.AddWrite(ConstructClientAckAndRstPacket( |
1381 4, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED, 3, 3, 1)); | 1361 4, kClientDataStreamId1, QUIC_STREAM_CANCELLED, 3, 3, 1)); |
1382 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read | 1362 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
1383 mock_quic_data.AddRead(ASYNC, 0); // EOF | 1363 mock_quic_data.AddRead(ASYNC, 0); // EOF |
1384 | 1364 |
1385 mock_quic_data.AddSocketDataToFactory(&socket_factory_); | 1365 mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
1386 | 1366 |
1387 // The non-alternate protocol job needs to hang in order to guarantee that | 1367 // The non-alternate protocol job needs to hang in order to guarantee that |
1388 // the alternate-protocol job will "win". | 1368 // the alternate-protocol job will "win". |
1389 AddHangingNonAlternateProtocolSocketData(); | 1369 AddHangingNonAlternateProtocolSocketData(); |
1390 | 1370 |
1391 // In order for a new QUIC session to be established via alternate-protocol | 1371 // In order for a new QUIC session to be established via alternate-protocol |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1429 params_.quic_idle_connection_timeout_seconds = 5; | 1409 params_.quic_idle_connection_timeout_seconds = 5; |
1430 | 1410 |
1431 // The request will initially go out over QUIC. | 1411 // The request will initially go out over QUIC. |
1432 MockQuicData quic_data; | 1412 MockQuicData quic_data; |
1433 QuicStreamOffset header_stream_offset = 0; | 1413 QuicStreamOffset header_stream_offset = 0; |
1434 SpdyPriority priority = | 1414 SpdyPriority priority = |
1435 ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); | 1415 ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); |
1436 | 1416 |
1437 std::string request_data; | 1417 std::string request_data; |
1438 quic_data.AddWrite(client_maker_.MakeRequestHeadersPacketAndSaveData( | 1418 quic_data.AddWrite(client_maker_.MakeRequestHeadersPacketAndSaveData( |
1439 1, GetNthClientInitiatedStreamId(0), true, true, priority, | 1419 1, kClientDataStreamId1, true, true, priority, |
1440 GetRequestHeaders("GET", "https", "/"), nullptr, &header_stream_offset, | 1420 GetRequestHeaders("GET", "https", "/"), nullptr, &header_stream_offset, |
1441 &request_data)); | 1421 &request_data)); |
1442 | 1422 |
1443 std::string settings_data; | 1423 std::string settings_data; |
1444 QuicStreamOffset settings_offset = header_stream_offset; | 1424 QuicStreamOffset settings_offset = header_stream_offset; |
1445 quic_data.AddWrite(client_maker_.MakeInitialSettingsPacketAndSaveData( | 1425 quic_data.AddWrite(client_maker_.MakeInitialSettingsPacketAndSaveData( |
1446 2, &header_stream_offset, &settings_data)); | 1426 2, &header_stream_offset, &settings_data)); |
1447 // TLP 1 | 1427 // TLP 1 |
1448 quic_data.AddWrite(client_maker_.MakeDataPacket(3, kHeadersStreamId, true, | 1428 quic_data.AddWrite(client_maker_.MakeDataPacket(3, kHeadersStreamId, true, |
1449 false, 0, request_data)); | 1429 false, 0, request_data)); |
(...skipping 69 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1519 params_.quic_connection_options.push_back(k5RTO); | 1499 params_.quic_connection_options.push_back(k5RTO); |
1520 | 1500 |
1521 // The request will initially go out over QUIC. | 1501 // The request will initially go out over QUIC. |
1522 MockQuicData quic_data; | 1502 MockQuicData quic_data; |
1523 QuicStreamOffset header_stream_offset = 0; | 1503 QuicStreamOffset header_stream_offset = 0; |
1524 SpdyPriority priority = | 1504 SpdyPriority priority = |
1525 ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); | 1505 ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); |
1526 | 1506 |
1527 std::string request_data; | 1507 std::string request_data; |
1528 quic_data.AddWrite(client_maker_.MakeRequestHeadersPacketAndSaveData( | 1508 quic_data.AddWrite(client_maker_.MakeRequestHeadersPacketAndSaveData( |
1529 1, GetNthClientInitiatedStreamId(0), true, true, priority, | 1509 1, kClientDataStreamId1, true, true, priority, |
1530 GetRequestHeaders("GET", "https", "/"), nullptr, &header_stream_offset, | 1510 GetRequestHeaders("GET", "https", "/"), nullptr, &header_stream_offset, |
1531 &request_data)); | 1511 &request_data)); |
1532 | 1512 |
1533 std::string settings_data; | 1513 std::string settings_data; |
1534 QuicStreamOffset settings_offset = header_stream_offset; | 1514 QuicStreamOffset settings_offset = header_stream_offset; |
1535 quic_data.AddWrite(client_maker_.MakeInitialSettingsPacketAndSaveData( | 1515 quic_data.AddWrite(client_maker_.MakeInitialSettingsPacketAndSaveData( |
1536 2, &header_stream_offset, &settings_data)); | 1516 2, &header_stream_offset, &settings_data)); |
1537 // TLP 1 | 1517 // TLP 1 |
1538 quic_data.AddWrite(client_maker_.MakeDataPacket(3, kHeadersStreamId, true, | 1518 quic_data.AddWrite(client_maker_.MakeDataPacket(3, kHeadersStreamId, true, |
1539 false, 0, request_data)); | 1519 false, 0, request_data)); |
(...skipping 78 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1618 params_.quic_connection_options.push_back(k5RTO); | 1598 params_.quic_connection_options.push_back(k5RTO); |
1619 | 1599 |
1620 // The request will initially go out over QUIC. | 1600 // The request will initially go out over QUIC. |
1621 MockQuicData quic_data; | 1601 MockQuicData quic_data; |
1622 QuicStreamOffset header_stream_offset = 0; | 1602 QuicStreamOffset header_stream_offset = 0; |
1623 SpdyPriority priority = | 1603 SpdyPriority priority = |
1624 ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); | 1604 ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); |
1625 | 1605 |
1626 std::string request_data; | 1606 std::string request_data; |
1627 quic_data.AddWrite(client_maker_.MakeRequestHeadersPacketAndSaveData( | 1607 quic_data.AddWrite(client_maker_.MakeRequestHeadersPacketAndSaveData( |
1628 1, GetNthClientInitiatedStreamId(0), true, true, priority, | 1608 1, kClientDataStreamId1, true, true, priority, |
1629 GetRequestHeaders("GET", "https", "/"), nullptr, &header_stream_offset, | 1609 GetRequestHeaders("GET", "https", "/"), nullptr, &header_stream_offset, |
1630 &request_data)); | 1610 &request_data)); |
1631 | 1611 |
1632 std::string settings_data; | 1612 std::string settings_data; |
1633 QuicStreamOffset settings_offset = header_stream_offset; | 1613 QuicStreamOffset settings_offset = header_stream_offset; |
1634 quic_data.AddWrite(client_maker_.MakeInitialSettingsPacketAndSaveData( | 1614 quic_data.AddWrite(client_maker_.MakeInitialSettingsPacketAndSaveData( |
1635 2, &header_stream_offset, &settings_data)); | 1615 2, &header_stream_offset, &settings_data)); |
1636 | 1616 |
1637 quic_data.AddWrite(client_maker_.MakeRstPacket( | 1617 quic_data.AddWrite(client_maker_.MakeRstPacket(3, true, kClientDataStreamId1, |
1638 3, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); | 1618 QUIC_STREAM_CANCELLED)); |
1639 // TLP 1 | 1619 // TLP 1 |
1640 quic_data.AddWrite(client_maker_.MakeDataPacket(4, kHeadersStreamId, true, | 1620 quic_data.AddWrite(client_maker_.MakeDataPacket(4, kHeadersStreamId, true, |
1641 false, 0, request_data)); | 1621 false, 0, request_data)); |
1642 // TLP 2 | 1622 // TLP 2 |
1643 quic_data.AddWrite(client_maker_.MakeDataPacket( | 1623 quic_data.AddWrite(client_maker_.MakeDataPacket( |
1644 5, kHeadersStreamId, true, false, settings_offset, settings_data)); | 1624 5, kHeadersStreamId, true, false, settings_offset, settings_data)); |
1645 // RTO 1 | 1625 // RTO 1 |
1646 quic_data.AddWrite(client_maker_.MakeRstPacket( | 1626 quic_data.AddWrite(client_maker_.MakeRstPacket(6, true, kClientDataStreamId1, |
1647 6, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); | 1627 QUIC_STREAM_CANCELLED)); |
1648 quic_data.AddWrite(client_maker_.MakeDataPacket(7, kHeadersStreamId, true, | 1628 quic_data.AddWrite(client_maker_.MakeDataPacket(7, kHeadersStreamId, true, |
1649 false, 0, request_data)); | 1629 false, 0, request_data)); |
1650 // RTO 2 | 1630 // RTO 2 |
1651 quic_data.AddWrite(client_maker_.MakeDataPacket( | 1631 quic_data.AddWrite(client_maker_.MakeDataPacket( |
1652 8, kHeadersStreamId, true, false, settings_offset, settings_data)); | 1632 8, kHeadersStreamId, true, false, settings_offset, settings_data)); |
1653 quic_data.AddWrite(client_maker_.MakeRstPacket( | 1633 quic_data.AddWrite(client_maker_.MakeRstPacket(9, true, kClientDataStreamId1, |
1654 9, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); | 1634 QUIC_STREAM_CANCELLED)); |
1655 // RTO 3 | 1635 // RTO 3 |
1656 quic_data.AddWrite(client_maker_.MakeDataPacket(10, kHeadersStreamId, true, | 1636 quic_data.AddWrite(client_maker_.MakeDataPacket(10, kHeadersStreamId, true, |
1657 false, 0, request_data)); | 1637 false, 0, request_data)); |
1658 quic_data.AddWrite(client_maker_.MakeDataPacket( | 1638 quic_data.AddWrite(client_maker_.MakeDataPacket( |
1659 11, kHeadersStreamId, true, false, settings_offset, settings_data)); | 1639 11, kHeadersStreamId, true, false, settings_offset, settings_data)); |
1660 // RTO 4 | 1640 // RTO 4 |
1661 quic_data.AddWrite(client_maker_.MakeRstPacket( | 1641 quic_data.AddWrite(client_maker_.MakeRstPacket(12, true, kClientDataStreamId1, |
1662 12, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); | 1642 QUIC_STREAM_CANCELLED)); |
1663 quic_data.AddWrite(client_maker_.MakeDataPacket(13, kHeadersStreamId, true, | 1643 quic_data.AddWrite(client_maker_.MakeDataPacket(13, kHeadersStreamId, true, |
1664 false, 0, request_data)); | 1644 false, 0, request_data)); |
1665 // RTO 5 | 1645 // RTO 5 |
1666 quic_data.AddWrite(client_maker_.MakeAckAndConnectionClosePacket( | 1646 quic_data.AddWrite(client_maker_.MakeAckAndConnectionClosePacket( |
1667 14, true, QuicTime::Delta::Infinite(), 0, 1, 1, QUIC_TOO_MANY_RTOS, | 1647 14, true, QuicTime::Delta::Infinite(), 0, 1, 1, QUIC_TOO_MANY_RTOS, |
1668 "5 consecutive retransmission timeouts")); | 1648 "5 consecutive retransmission timeouts")); |
1669 | 1649 |
1670 quic_data.AddRead(ASYNC, OK); | 1650 quic_data.AddRead(ASYNC, OK); |
1671 quic_data.AddSocketDataToFactory(&socket_factory_); | 1651 quic_data.AddSocketDataToFactory(&socket_factory_); |
1672 | 1652 |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1717 ASSERT_TRUE(quic_data.AllWriteDataConsumed()); | 1697 ASSERT_TRUE(quic_data.AllWriteDataConsumed()); |
1718 } | 1698 } |
1719 | 1699 |
1720 // Verify that if a QUIC protocol error occurs after the handshake is confirmed | 1700 // Verify that if a QUIC protocol error occurs after the handshake is confirmed |
1721 // the request fails with QUIC_PROTOCOL_ERROR. | 1701 // the request fails with QUIC_PROTOCOL_ERROR. |
1722 TEST_P(QuicNetworkTransactionTest, ProtocolErrorAfterHandshakeConfirmed) { | 1702 TEST_P(QuicNetworkTransactionTest, ProtocolErrorAfterHandshakeConfirmed) { |
1723 // The request will initially go out over QUIC. | 1703 // The request will initially go out over QUIC. |
1724 MockQuicData quic_data; | 1704 MockQuicData quic_data; |
1725 QuicStreamOffset header_stream_offset = 0; | 1705 QuicStreamOffset header_stream_offset = 0; |
1726 quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 1706 quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
1727 1, GetNthClientInitiatedStreamId(0), true, true, | 1707 1, kClientDataStreamId1, true, true, |
1728 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); | 1708 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
1729 quic_data.AddWrite(ConstructInitialSettingsPacket(2, &header_stream_offset)); | 1709 quic_data.AddWrite(ConstructInitialSettingsPacket(2, &header_stream_offset)); |
1730 // Peer sending data from an non-existing stream causes this end to raise | 1710 // Peer sending data from an non-existing stream causes this end to raise |
1731 // error and close connection. | 1711 // error and close connection. |
1732 quic_data.AddRead( | 1712 quic_data.AddRead( |
1733 ConstructServerRstPacket(1, false, 99, QUIC_STREAM_LAST_ERROR)); | 1713 ConstructServerRstPacket(1, false, 99, QUIC_STREAM_LAST_ERROR)); |
1734 std::string quic_error_details = "Data for nonexistent stream"; | 1714 std::string quic_error_details = "Data for nonexistent stream"; |
1735 quic_data.AddWrite(ConstructClientAckAndConnectionClosePacket( | 1715 quic_data.AddWrite(ConstructClientAckAndConnectionClosePacket( |
1736 3, QuicTime::Delta::Zero(), 1, 1, 1, QUIC_INVALID_STREAM_ID, | 1716 3, QuicTime::Delta::Zero(), 1, 1, 1, QUIC_INVALID_STREAM_ID, |
1737 quic_error_details)); | 1717 quic_error_details)); |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1786 params_.quic_idle_connection_timeout_seconds = 5; | 1766 params_.quic_idle_connection_timeout_seconds = 5; |
1787 | 1767 |
1788 // The request will initially go out over QUIC. | 1768 // The request will initially go out over QUIC. |
1789 MockQuicData quic_data; | 1769 MockQuicData quic_data; |
1790 QuicStreamOffset header_stream_offset = 0; | 1770 QuicStreamOffset header_stream_offset = 0; |
1791 SpdyPriority priority = | 1771 SpdyPriority priority = |
1792 ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); | 1772 ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); |
1793 | 1773 |
1794 std::string request_data; | 1774 std::string request_data; |
1795 quic_data.AddWrite(client_maker_.MakeRequestHeadersPacketAndSaveData( | 1775 quic_data.AddWrite(client_maker_.MakeRequestHeadersPacketAndSaveData( |
1796 1, GetNthClientInitiatedStreamId(0), true, true, priority, | 1776 1, kClientDataStreamId1, true, true, priority, |
1797 GetRequestHeaders("GET", "https", "/"), nullptr, &header_stream_offset, | 1777 GetRequestHeaders("GET", "https", "/"), nullptr, &header_stream_offset, |
1798 &request_data)); | 1778 &request_data)); |
1799 | 1779 |
1800 std::string settings_data; | 1780 std::string settings_data; |
1801 QuicStreamOffset settings_offset = header_stream_offset; | 1781 QuicStreamOffset settings_offset = header_stream_offset; |
1802 quic_data.AddWrite(client_maker_.MakeInitialSettingsPacketAndSaveData( | 1782 quic_data.AddWrite(client_maker_.MakeInitialSettingsPacketAndSaveData( |
1803 2, &header_stream_offset, &settings_data)); | 1783 2, &header_stream_offset, &settings_data)); |
1804 // TLP 1 | 1784 // TLP 1 |
1805 quic_data.AddWrite(client_maker_.MakeDataPacket(3, kHeadersStreamId, true, | 1785 quic_data.AddWrite(client_maker_.MakeDataPacket(3, kHeadersStreamId, true, |
1806 false, 0, request_data)); | 1786 false, 0, request_data)); |
(...skipping 96 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1903 params_.quic_idle_connection_timeout_seconds = 5; | 1883 params_.quic_idle_connection_timeout_seconds = 5; |
1904 | 1884 |
1905 // The request will initially go out over QUIC. | 1885 // The request will initially go out over QUIC. |
1906 MockQuicData quic_data; | 1886 MockQuicData quic_data; |
1907 QuicStreamOffset header_stream_offset = 0; | 1887 QuicStreamOffset header_stream_offset = 0; |
1908 SpdyPriority priority = | 1888 SpdyPriority priority = |
1909 ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); | 1889 ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); |
1910 | 1890 |
1911 std::string request_data; | 1891 std::string request_data; |
1912 quic_data.AddWrite(client_maker_.MakeRequestHeadersPacketAndSaveData( | 1892 quic_data.AddWrite(client_maker_.MakeRequestHeadersPacketAndSaveData( |
1913 1, GetNthClientInitiatedStreamId(0), true, true, priority, | 1893 1, kClientDataStreamId1, true, true, priority, |
1914 GetRequestHeaders("GET", "https", "/"), nullptr, &header_stream_offset, | 1894 GetRequestHeaders("GET", "https", "/"), nullptr, &header_stream_offset, |
1915 &request_data)); | 1895 &request_data)); |
1916 | 1896 |
1917 std::string settings_data; | 1897 std::string settings_data; |
1918 QuicStreamOffset settings_offset = header_stream_offset; | 1898 QuicStreamOffset settings_offset = header_stream_offset; |
1919 quic_data.AddWrite(client_maker_.MakeInitialSettingsPacketAndSaveData( | 1899 quic_data.AddWrite(client_maker_.MakeInitialSettingsPacketAndSaveData( |
1920 2, &header_stream_offset, &settings_data)); | 1900 2, &header_stream_offset, &settings_data)); |
1921 // TLP 1 | 1901 // TLP 1 |
1922 quic_data.AddWrite(client_maker_.MakeDataPacket(3, kHeadersStreamId, true, | 1902 quic_data.AddWrite(client_maker_.MakeDataPacket(3, kHeadersStreamId, true, |
1923 false, 0, request_data)); | 1903 false, 0, request_data)); |
(...skipping 99 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2023 params_.quic_idle_connection_timeout_seconds = 5; | 2003 params_.quic_idle_connection_timeout_seconds = 5; |
2024 | 2004 |
2025 // The request will initially go out over QUIC. | 2005 // The request will initially go out over QUIC. |
2026 MockQuicData quic_data; | 2006 MockQuicData quic_data; |
2027 QuicStreamOffset header_stream_offset = 0; | 2007 QuicStreamOffset header_stream_offset = 0; |
2028 SpdyPriority priority = | 2008 SpdyPriority priority = |
2029 ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); | 2009 ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); |
2030 | 2010 |
2031 std::string request_data; | 2011 std::string request_data; |
2032 quic_data.AddWrite(client_maker_.MakeRequestHeadersPacketAndSaveData( | 2012 quic_data.AddWrite(client_maker_.MakeRequestHeadersPacketAndSaveData( |
2033 1, GetNthClientInitiatedStreamId(0), true, true, priority, | 2013 1, kClientDataStreamId1, true, true, priority, |
2034 GetRequestHeaders("GET", "https", "/"), nullptr, &header_stream_offset, | 2014 GetRequestHeaders("GET", "https", "/"), nullptr, &header_stream_offset, |
2035 &request_data)); | 2015 &request_data)); |
2036 | 2016 |
2037 std::string settings_data; | 2017 std::string settings_data; |
2038 QuicStreamOffset settings_offset = header_stream_offset; | 2018 QuicStreamOffset settings_offset = header_stream_offset; |
2039 quic_data.AddWrite(client_maker_.MakeInitialSettingsPacketAndSaveData( | 2019 quic_data.AddWrite(client_maker_.MakeInitialSettingsPacketAndSaveData( |
2040 2, &header_stream_offset, &settings_data)); | 2020 2, &header_stream_offset, &settings_data)); |
2041 | 2021 |
2042 quic_data.AddRead(ConstructServerResponseHeadersPacket( | 2022 quic_data.AddRead(ConstructServerResponseHeadersPacket( |
2043 1, GetNthClientInitiatedStreamId(0), false, false, | 2023 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"))); |
2044 GetResponseHeaders("200 OK"))); | |
2045 // quic_data.AddWrite(ConstructClientAckPacket(3, 1, 1)); | 2024 // quic_data.AddWrite(ConstructClientAckPacket(3, 1, 1)); |
2046 quic_data.AddWrite(ConstructClientAckPacket( | 2025 quic_data.AddWrite(ConstructClientAckPacket( |
2047 3, 1, 1, 1, QuicTime::Delta::FromMilliseconds(25))); | 2026 3, 1, 1, 1, QuicTime::Delta::FromMilliseconds(25))); |
2048 | 2027 |
2049 // TLP 1 | 2028 // TLP 1 |
2050 quic_data.AddWrite(client_maker_.MakeDataPacket(4, kHeadersStreamId, false, | 2029 quic_data.AddWrite(client_maker_.MakeDataPacket(4, kHeadersStreamId, false, |
2051 false, 0, request_data)); | 2030 false, 0, request_data)); |
2052 // TLP 2 | 2031 // TLP 2 |
2053 quic_data.AddWrite(client_maker_.MakeDataPacket( | 2032 quic_data.AddWrite(client_maker_.MakeDataPacket( |
2054 5, kHeadersStreamId, false, false, settings_offset, settings_data)); | 2033 5, kHeadersStreamId, false, false, settings_offset, settings_data)); |
(...skipping 80 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2135 params_.quic_connection_options.push_back(k5RTO); | 2114 params_.quic_connection_options.push_back(k5RTO); |
2136 | 2115 |
2137 // The request will initially go out over QUIC. | 2116 // The request will initially go out over QUIC. |
2138 MockQuicData quic_data; | 2117 MockQuicData quic_data; |
2139 QuicStreamOffset header_stream_offset = 0; | 2118 QuicStreamOffset header_stream_offset = 0; |
2140 SpdyPriority priority = | 2119 SpdyPriority priority = |
2141 ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); | 2120 ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); |
2142 | 2121 |
2143 std::string request_data; | 2122 std::string request_data; |
2144 quic_data.AddWrite(client_maker_.MakeRequestHeadersPacketAndSaveData( | 2123 quic_data.AddWrite(client_maker_.MakeRequestHeadersPacketAndSaveData( |
2145 1, GetNthClientInitiatedStreamId(0), true, true, priority, | 2124 1, kClientDataStreamId1, true, true, priority, |
2146 GetRequestHeaders("GET", "https", "/"), nullptr, &header_stream_offset, | 2125 GetRequestHeaders("GET", "https", "/"), nullptr, &header_stream_offset, |
2147 &request_data)); | 2126 &request_data)); |
2148 | 2127 |
2149 std::string settings_data; | 2128 std::string settings_data; |
2150 QuicStreamOffset settings_offset = header_stream_offset; | 2129 QuicStreamOffset settings_offset = header_stream_offset; |
2151 quic_data.AddWrite(client_maker_.MakeInitialSettingsPacketAndSaveData( | 2130 quic_data.AddWrite(client_maker_.MakeInitialSettingsPacketAndSaveData( |
2152 2, &header_stream_offset, &settings_data)); | 2131 2, &header_stream_offset, &settings_data)); |
2153 // TLP 1 | 2132 // TLP 1 |
2154 quic_data.AddWrite(client_maker_.MakeDataPacket(3, kHeadersStreamId, true, | 2133 quic_data.AddWrite(client_maker_.MakeDataPacket(3, kHeadersStreamId, true, |
2155 false, 0, request_data)); | 2134 false, 0, request_data)); |
(...skipping 104 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2260 params_.quic_connection_options.push_back(k5RTO); | 2239 params_.quic_connection_options.push_back(k5RTO); |
2261 | 2240 |
2262 // The request will initially go out over QUIC. | 2241 // The request will initially go out over QUIC. |
2263 MockQuicData quic_data; | 2242 MockQuicData quic_data; |
2264 QuicStreamOffset header_stream_offset = 0; | 2243 QuicStreamOffset header_stream_offset = 0; |
2265 SpdyPriority priority = | 2244 SpdyPriority priority = |
2266 ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); | 2245 ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY); |
2267 | 2246 |
2268 std::string request_data; | 2247 std::string request_data; |
2269 quic_data.AddWrite(client_maker_.MakeRequestHeadersPacketAndSaveData( | 2248 quic_data.AddWrite(client_maker_.MakeRequestHeadersPacketAndSaveData( |
2270 1, GetNthClientInitiatedStreamId(0), true, true, priority, | 2249 1, kClientDataStreamId1, true, true, priority, |
2271 GetRequestHeaders("GET", "https", "/"), nullptr, &header_stream_offset, | 2250 GetRequestHeaders("GET", "https", "/"), nullptr, &header_stream_offset, |
2272 &request_data)); | 2251 &request_data)); |
2273 | 2252 |
2274 std::string settings_data; | 2253 std::string settings_data; |
2275 QuicStreamOffset settings_offset = header_stream_offset; | 2254 QuicStreamOffset settings_offset = header_stream_offset; |
2276 quic_data.AddWrite(client_maker_.MakeInitialSettingsPacketAndSaveData( | 2255 quic_data.AddWrite(client_maker_.MakeInitialSettingsPacketAndSaveData( |
2277 2, &header_stream_offset, &settings_data)); | 2256 2, &header_stream_offset, &settings_data)); |
2278 | 2257 |
2279 quic_data.AddWrite(client_maker_.MakeRstPacket( | 2258 quic_data.AddWrite(client_maker_.MakeRstPacket(3, true, kClientDataStreamId1, |
2280 3, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); | 2259 QUIC_STREAM_CANCELLED)); |
2281 // TLP 1 | 2260 // TLP 1 |
2282 quic_data.AddWrite(client_maker_.MakeDataPacket(4, kHeadersStreamId, true, | 2261 quic_data.AddWrite(client_maker_.MakeDataPacket(4, kHeadersStreamId, true, |
2283 false, 0, request_data)); | 2262 false, 0, request_data)); |
2284 // TLP 2 | 2263 // TLP 2 |
2285 quic_data.AddWrite(client_maker_.MakeDataPacket( | 2264 quic_data.AddWrite(client_maker_.MakeDataPacket( |
2286 5, kHeadersStreamId, true, false, settings_offset, settings_data)); | 2265 5, kHeadersStreamId, true, false, settings_offset, settings_data)); |
2287 // RTO 1 | 2266 // RTO 1 |
2288 quic_data.AddWrite(client_maker_.MakeRstPacket( | 2267 quic_data.AddWrite(client_maker_.MakeRstPacket(6, true, kClientDataStreamId1, |
2289 6, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); | 2268 QUIC_STREAM_CANCELLED)); |
2290 quic_data.AddWrite(client_maker_.MakeDataPacket(7, kHeadersStreamId, true, | 2269 quic_data.AddWrite(client_maker_.MakeDataPacket(7, kHeadersStreamId, true, |
2291 false, 0, request_data)); | 2270 false, 0, request_data)); |
2292 // RTO 2 | 2271 // RTO 2 |
2293 quic_data.AddWrite(client_maker_.MakeDataPacket( | 2272 quic_data.AddWrite(client_maker_.MakeDataPacket( |
2294 8, kHeadersStreamId, true, false, settings_offset, settings_data)); | 2273 8, kHeadersStreamId, true, false, settings_offset, settings_data)); |
2295 quic_data.AddWrite(client_maker_.MakeRstPacket( | 2274 quic_data.AddWrite(client_maker_.MakeRstPacket(9, true, kClientDataStreamId1, |
2296 9, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); | 2275 QUIC_STREAM_CANCELLED)); |
2297 // RTO 3 | 2276 // RTO 3 |
2298 quic_data.AddWrite(client_maker_.MakeDataPacket(10, kHeadersStreamId, true, | 2277 quic_data.AddWrite(client_maker_.MakeDataPacket(10, kHeadersStreamId, true, |
2299 false, 0, request_data)); | 2278 false, 0, request_data)); |
2300 quic_data.AddWrite(client_maker_.MakeDataPacket( | 2279 quic_data.AddWrite(client_maker_.MakeDataPacket( |
2301 11, kHeadersStreamId, true, false, settings_offset, settings_data)); | 2280 11, kHeadersStreamId, true, false, settings_offset, settings_data)); |
2302 // RTO 4 | 2281 // RTO 4 |
2303 quic_data.AddWrite(client_maker_.MakeRstPacket( | 2282 quic_data.AddWrite(client_maker_.MakeRstPacket(12, true, kClientDataStreamId1, |
2304 12, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); | 2283 QUIC_STREAM_CANCELLED)); |
2305 quic_data.AddWrite(client_maker_.MakeDataPacket(13, kHeadersStreamId, true, | 2284 quic_data.AddWrite(client_maker_.MakeDataPacket(13, kHeadersStreamId, true, |
2306 false, 0, request_data)); | 2285 false, 0, request_data)); |
2307 // RTO 5 | 2286 // RTO 5 |
2308 quic_data.AddWrite(client_maker_.MakeAckAndConnectionClosePacket( | 2287 quic_data.AddWrite(client_maker_.MakeAckAndConnectionClosePacket( |
2309 14, true, QuicTime::Delta::Infinite(), 0, 1, 1, QUIC_TOO_MANY_RTOS, | 2288 14, true, QuicTime::Delta::Infinite(), 0, 1, 1, QUIC_TOO_MANY_RTOS, |
2310 "5 consecutive retransmission timeouts")); | 2289 "5 consecutive retransmission timeouts")); |
2311 | 2290 |
2312 quic_data.AddRead(ASYNC, OK); | 2291 quic_data.AddRead(ASYNC, OK); |
2313 quic_data.AddSocketDataToFactory(&socket_factory_); | 2292 quic_data.AddSocketDataToFactory(&socket_factory_); |
2314 | 2293 |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2364 // retried over TCP and the QUIC will be marked as broken. | 2343 // retried over TCP and the QUIC will be marked as broken. |
2365 TEST_P(QuicNetworkTransactionTest, | 2344 TEST_P(QuicNetworkTransactionTest, |
2366 ProtocolErrorAfterHandshakeConfirmedThenBroken) { | 2345 ProtocolErrorAfterHandshakeConfirmedThenBroken) { |
2367 params_.retry_without_alt_svc_on_quic_errors = true; | 2346 params_.retry_without_alt_svc_on_quic_errors = true; |
2368 params_.quic_idle_connection_timeout_seconds = 5; | 2347 params_.quic_idle_connection_timeout_seconds = 5; |
2369 | 2348 |
2370 // The request will initially go out over QUIC. | 2349 // The request will initially go out over QUIC. |
2371 MockQuicData quic_data; | 2350 MockQuicData quic_data; |
2372 QuicStreamOffset header_stream_offset = 0; | 2351 QuicStreamOffset header_stream_offset = 0; |
2373 quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 2352 quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
2374 1, GetNthClientInitiatedStreamId(0), true, true, | 2353 1, kClientDataStreamId1, true, true, |
2375 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); | 2354 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
2376 quic_data.AddWrite(ConstructInitialSettingsPacket(2, &header_stream_offset)); | 2355 quic_data.AddWrite(ConstructInitialSettingsPacket(2, &header_stream_offset)); |
2377 // Peer sending data from an non-existing stream causes this end to raise | 2356 // Peer sending data from an non-existing stream causes this end to raise |
2378 // error and close connection. | 2357 // error and close connection. |
2379 quic_data.AddRead( | 2358 quic_data.AddRead( |
2380 ConstructServerRstPacket(1, false, 99, QUIC_STREAM_LAST_ERROR)); | 2359 ConstructServerRstPacket(1, false, 99, QUIC_STREAM_LAST_ERROR)); |
2381 std::string quic_error_details = "Data for nonexistent stream"; | 2360 std::string quic_error_details = "Data for nonexistent stream"; |
2382 quic_data.AddWrite(ConstructClientAckAndConnectionClosePacket( | 2361 quic_data.AddWrite(ConstructClientAckAndConnectionClosePacket( |
2383 3, QuicTime::Delta::Zero(), 1, 1, 1, QUIC_INVALID_STREAM_ID, | 2362 3, QuicTime::Delta::Zero(), 1, 1, 1, QUIC_INVALID_STREAM_ID, |
2384 quic_error_details)); | 2363 quic_error_details)); |
(...skipping 105 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2490 | 2469 |
2491 QuicStreamOffset request_header_offset = 0; | 2470 QuicStreamOffset request_header_offset = 0; |
2492 QuicStreamOffset response_header_offset = 0; | 2471 QuicStreamOffset response_header_offset = 0; |
2493 // First QUIC request data. | 2472 // First QUIC request data. |
2494 // Open a session to foo.example.org:443 using the first entry of the | 2473 // Open a session to foo.example.org:443 using the first entry of the |
2495 // alternative service list. | 2474 // alternative service list. |
2496 MockQuicData mock_quic_data; | 2475 MockQuicData mock_quic_data; |
2497 mock_quic_data.AddWrite( | 2476 mock_quic_data.AddWrite( |
2498 ConstructInitialSettingsPacket(1, &request_header_offset)); | 2477 ConstructInitialSettingsPacket(1, &request_header_offset)); |
2499 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 2478 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
2500 2, GetNthClientInitiatedStreamId(0), true, true, | 2479 2, kClientDataStreamId1, true, true, |
2501 GetRequestHeaders("GET", "https", "/"), &request_header_offset)); | 2480 GetRequestHeaders("GET", "https", "/"), &request_header_offset)); |
2502 | 2481 |
2503 std::string alt_svc_list = | 2482 std::string alt_svc_list = |
2504 "quic=\"mail.example.org:444\", quic=\"foo.example.org:443\", " | 2483 "quic=\"mail.example.org:444\", quic=\"foo.example.org:443\", " |
2505 "quic=\"bar.example.org:445\""; | 2484 "quic=\"bar.example.org:445\""; |
2506 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 2485 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
2507 1, GetNthClientInitiatedStreamId(0), false, false, | 2486 1, kClientDataStreamId1, false, false, |
2508 GetResponseHeaders("200 OK", alt_svc_list), &response_header_offset)); | 2487 GetResponseHeaders("200 OK", alt_svc_list), &response_header_offset)); |
2509 mock_quic_data.AddRead(ConstructServerDataPacket( | 2488 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1, |
2510 2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!")); | 2489 false, true, 0, "hello!")); |
2511 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); | 2490 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); |
2512 | 2491 |
2513 // Second QUIC request data. | 2492 // Second QUIC request data. |
2514 // Connection pooling, using existing session, no need to include version | 2493 // Connection pooling, using existing session, no need to include version |
2515 // as version negotiation has been completed. | 2494 // as version negotiation has been completed. |
2516 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 2495 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
2517 4, GetNthClientInitiatedStreamId(1), false, true, | 2496 4, kClientDataStreamId2, false, true, |
2518 GetRequestHeaders("GET", "https", "/"), &request_header_offset)); | 2497 GetRequestHeaders("GET", "https", "/"), &request_header_offset)); |
2519 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 2498 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
2520 3, GetNthClientInitiatedStreamId(1), false, false, | 2499 3, kClientDataStreamId2, false, false, GetResponseHeaders("200 OK"), |
2521 GetResponseHeaders("200 OK"), &response_header_offset)); | 2500 &response_header_offset)); |
2522 mock_quic_data.AddRead(ConstructServerDataPacket( | 2501 mock_quic_data.AddRead(ConstructServerDataPacket(4, kClientDataStreamId2, |
2523 4, GetNthClientInitiatedStreamId(1), false, true, 0, "hello!")); | 2502 false, true, 0, "hello!")); |
2524 mock_quic_data.AddWrite( | 2503 mock_quic_data.AddWrite( |
2525 ConstructClientAckAndConnectionClosePacket(5, 4, 3, 1)); | 2504 ConstructClientAckAndConnectionClosePacket(5, 4, 3, 1)); |
2526 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read | 2505 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
2527 mock_quic_data.AddRead(ASYNC, 0); // EOF | 2506 mock_quic_data.AddRead(ASYNC, 0); // EOF |
2528 | 2507 |
2529 mock_quic_data.AddSocketDataToFactory(&socket_factory_); | 2508 mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
2530 | 2509 |
2531 AddHangingNonAlternateProtocolSocketData(); | 2510 AddHangingNonAlternateProtocolSocketData(); |
2532 CreateSession(); | 2511 CreateSession(); |
2533 | 2512 |
(...skipping 10 matching lines...) Expand all Loading... |
2544 | 2523 |
2545 QuicStreamOffset request_header_offset = 0; | 2524 QuicStreamOffset request_header_offset = 0; |
2546 QuicStreamOffset response_header_offset = 0; | 2525 QuicStreamOffset response_header_offset = 0; |
2547 // First QUIC request data. | 2526 // First QUIC request data. |
2548 // Open a session to foo.example.org:443 using the first entry of the | 2527 // Open a session to foo.example.org:443 using the first entry of the |
2549 // alternative service list. | 2528 // alternative service list. |
2550 MockQuicData mock_quic_data; | 2529 MockQuicData mock_quic_data; |
2551 mock_quic_data.AddWrite( | 2530 mock_quic_data.AddWrite( |
2552 ConstructInitialSettingsPacket(1, &request_header_offset)); | 2531 ConstructInitialSettingsPacket(1, &request_header_offset)); |
2553 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 2532 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
2554 2, GetNthClientInitiatedStreamId(0), true, true, | 2533 2, kClientDataStreamId1, true, true, |
2555 GetRequestHeaders("GET", "http", "/"), &request_header_offset)); | 2534 GetRequestHeaders("GET", "http", "/"), &request_header_offset)); |
2556 | 2535 |
2557 std::string alt_svc_list; | 2536 std::string alt_svc_list; |
2558 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 2537 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
2559 1, GetNthClientInitiatedStreamId(0), false, false, | 2538 1, kClientDataStreamId1, false, false, |
2560 GetResponseHeaders("200 OK", alt_svc_list), &response_header_offset)); | 2539 GetResponseHeaders("200 OK", alt_svc_list), &response_header_offset)); |
2561 mock_quic_data.AddRead(ConstructServerDataPacket( | 2540 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1, |
2562 2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!")); | 2541 false, true, 0, "hello!")); |
2563 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); | 2542 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); |
2564 | 2543 |
2565 // Second QUIC request data. | 2544 // Second QUIC request data. |
2566 // Connection pooling, using existing session, no need to include version | 2545 // Connection pooling, using existing session, no need to include version |
2567 // as version negotiation has been completed. | 2546 // as version negotiation has been completed. |
2568 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 2547 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
2569 4, GetNthClientInitiatedStreamId(1), false, true, | 2548 4, kClientDataStreamId2, false, true, |
2570 GetRequestHeaders("GET", "http", "/"), &request_header_offset)); | 2549 GetRequestHeaders("GET", "http", "/"), &request_header_offset)); |
2571 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 2550 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
2572 3, GetNthClientInitiatedStreamId(1), false, false, | 2551 3, kClientDataStreamId2, false, false, GetResponseHeaders("200 OK"), |
2573 GetResponseHeaders("200 OK"), &response_header_offset)); | 2552 &response_header_offset)); |
2574 mock_quic_data.AddRead(ConstructServerDataPacket( | 2553 mock_quic_data.AddRead(ConstructServerDataPacket(4, kClientDataStreamId2, |
2575 4, GetNthClientInitiatedStreamId(1), false, true, 0, "hello!")); | 2554 false, true, 0, "hello!")); |
2576 mock_quic_data.AddWrite( | 2555 mock_quic_data.AddWrite( |
2577 ConstructClientAckAndConnectionClosePacket(5, 4, 3, 1)); | 2556 ConstructClientAckAndConnectionClosePacket(5, 4, 3, 1)); |
2578 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read | 2557 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
2579 mock_quic_data.AddRead(ASYNC, 0); // EOF | 2558 mock_quic_data.AddRead(ASYNC, 0); // EOF |
2580 | 2559 |
2581 mock_quic_data.AddSocketDataToFactory(&socket_factory_); | 2560 mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
2582 | 2561 |
2583 AddHangingNonAlternateProtocolSocketData(); | 2562 AddHangingNonAlternateProtocolSocketData(); |
2584 | 2563 |
2585 TestProxyDelegate test_proxy_delegate; | 2564 TestProxyDelegate test_proxy_delegate; |
(...skipping 25 matching lines...) Expand all Loading... |
2611 // even if alternative service destination is different. | 2590 // even if alternative service destination is different. |
2612 TEST_P(QuicNetworkTransactionTest, PoolByOrigin) { | 2591 TEST_P(QuicNetworkTransactionTest, PoolByOrigin) { |
2613 MockQuicData mock_quic_data; | 2592 MockQuicData mock_quic_data; |
2614 QuicStreamOffset request_header_offset(0); | 2593 QuicStreamOffset request_header_offset(0); |
2615 QuicStreamOffset response_header_offset(0); | 2594 QuicStreamOffset response_header_offset(0); |
2616 | 2595 |
2617 mock_quic_data.AddWrite( | 2596 mock_quic_data.AddWrite( |
2618 ConstructInitialSettingsPacket(1, &request_header_offset)); | 2597 ConstructInitialSettingsPacket(1, &request_header_offset)); |
2619 // First request. | 2598 // First request. |
2620 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 2599 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
2621 2, GetNthClientInitiatedStreamId(0), true, true, | 2600 2, kClientDataStreamId1, true, true, |
2622 GetRequestHeaders("GET", "https", "/"), &request_header_offset)); | 2601 GetRequestHeaders("GET", "https", "/"), &request_header_offset)); |
2623 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 2602 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
2624 1, GetNthClientInitiatedStreamId(0), false, false, | 2603 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"), |
2625 GetResponseHeaders("200 OK"), &response_header_offset)); | 2604 &response_header_offset)); |
2626 mock_quic_data.AddRead(ConstructServerDataPacket( | 2605 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1, |
2627 2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!")); | 2606 false, true, 0, "hello!")); |
2628 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); | 2607 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); |
2629 | 2608 |
2630 // Second request. | 2609 // Second request. |
2631 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 2610 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
2632 4, GetNthClientInitiatedStreamId(1), false, true, | 2611 4, kClientDataStreamId2, false, true, |
2633 GetRequestHeaders("GET", "https", "/"), &request_header_offset)); | 2612 GetRequestHeaders("GET", "https", "/"), &request_header_offset)); |
2634 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 2613 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
2635 3, GetNthClientInitiatedStreamId(1), false, false, | 2614 3, kClientDataStreamId2, false, false, GetResponseHeaders("200 OK"), |
2636 GetResponseHeaders("200 OK"), &response_header_offset)); | 2615 &response_header_offset)); |
2637 mock_quic_data.AddRead(ConstructServerDataPacket( | 2616 mock_quic_data.AddRead(ConstructServerDataPacket(4, kClientDataStreamId2, |
2638 4, GetNthClientInitiatedStreamId(1), false, true, 0, "hello!")); | 2617 false, true, 0, "hello!")); |
2639 mock_quic_data.AddWrite( | 2618 mock_quic_data.AddWrite( |
2640 ConstructClientAckAndConnectionClosePacket(5, 4, 3, 1)); | 2619 ConstructClientAckAndConnectionClosePacket(5, 4, 3, 1)); |
2641 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read | 2620 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
2642 mock_quic_data.AddRead(ASYNC, 0); // EOF | 2621 mock_quic_data.AddRead(ASYNC, 0); // EOF |
2643 | 2622 |
2644 mock_quic_data.AddSocketDataToFactory(&socket_factory_); | 2623 mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
2645 | 2624 |
2646 AddHangingNonAlternateProtocolSocketData(); | 2625 AddHangingNonAlternateProtocolSocketData(); |
2647 AddHangingNonAlternateProtocolSocketData(); | 2626 AddHangingNonAlternateProtocolSocketData(); |
2648 | 2627 |
(...skipping 30 matching lines...) Expand all Loading... |
2679 ASSERT_NE(origin1.host(), origin2.host()); | 2658 ASSERT_NE(origin1.host(), origin2.host()); |
2680 | 2659 |
2681 MockQuicData mock_quic_data; | 2660 MockQuicData mock_quic_data; |
2682 QuicStreamOffset request_header_offset(0); | 2661 QuicStreamOffset request_header_offset(0); |
2683 QuicStreamOffset response_header_offset(0); | 2662 QuicStreamOffset response_header_offset(0); |
2684 | 2663 |
2685 mock_quic_data.AddWrite( | 2664 mock_quic_data.AddWrite( |
2686 ConstructInitialSettingsPacket(1, &request_header_offset)); | 2665 ConstructInitialSettingsPacket(1, &request_header_offset)); |
2687 // First request. | 2666 // First request. |
2688 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 2667 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
2689 2, GetNthClientInitiatedStreamId(0), true, true, | 2668 2, kClientDataStreamId1, true, true, |
2690 GetRequestHeaders("GET", "https", "/"), &request_header_offset)); | 2669 GetRequestHeaders("GET", "https", "/"), &request_header_offset)); |
2691 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 2670 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
2692 1, GetNthClientInitiatedStreamId(0), false, false, | 2671 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"), |
2693 GetResponseHeaders("200 OK"), &response_header_offset)); | 2672 &response_header_offset)); |
2694 mock_quic_data.AddRead(ConstructServerDataPacket( | 2673 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1, |
2695 2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!")); | 2674 false, true, 0, "hello!")); |
2696 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); | 2675 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); |
2697 | 2676 |
2698 // Second request. | 2677 // Second request. |
2699 QuicTestPacketMaker client_maker2(version_, 0, &clock_, origin2.host(), | 2678 QuicTestPacketMaker client_maker2(version_, 0, &clock_, origin2.host(), |
2700 Perspective::IS_CLIENT); | 2679 Perspective::IS_CLIENT); |
2701 QuicTestPacketMaker server_maker2(version_, 0, &clock_, origin2.host(), | 2680 QuicTestPacketMaker server_maker2(version_, 0, &clock_, origin2.host(), |
2702 Perspective::IS_SERVER); | 2681 Perspective::IS_SERVER); |
2703 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 2682 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
2704 4, GetNthClientInitiatedStreamId(1), false, true, | 2683 4, kClientDataStreamId2, false, true, |
2705 GetRequestHeaders("GET", "https", "/", &client_maker2), | 2684 GetRequestHeaders("GET", "https", "/", &client_maker2), |
2706 &request_header_offset)); | 2685 &request_header_offset)); |
2707 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 2686 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
2708 3, GetNthClientInitiatedStreamId(1), false, false, | 2687 3, kClientDataStreamId2, false, false, GetResponseHeaders("200 OK"), |
2709 GetResponseHeaders("200 OK"), &response_header_offset)); | 2688 &response_header_offset)); |
2710 mock_quic_data.AddRead(ConstructServerDataPacket( | 2689 mock_quic_data.AddRead(ConstructServerDataPacket(4, kClientDataStreamId2, |
2711 4, GetNthClientInitiatedStreamId(1), false, true, 0, "hello!")); | 2690 false, true, 0, "hello!")); |
2712 mock_quic_data.AddWrite( | 2691 mock_quic_data.AddWrite( |
2713 ConstructClientAckAndConnectionClosePacket(5, 4, 3, 1)); | 2692 ConstructClientAckAndConnectionClosePacket(5, 4, 3, 1)); |
2714 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read | 2693 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
2715 mock_quic_data.AddRead(ASYNC, 0); // EOF | 2694 mock_quic_data.AddRead(ASYNC, 0); // EOF |
2716 | 2695 |
2717 mock_quic_data.AddSocketDataToFactory(&socket_factory_); | 2696 mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
2718 | 2697 |
2719 AddHangingNonAlternateProtocolSocketData(); | 2698 AddHangingNonAlternateProtocolSocketData(); |
2720 AddHangingNonAlternateProtocolSocketData(); | 2699 AddHangingNonAlternateProtocolSocketData(); |
2721 | 2700 |
(...skipping 70 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2792 | 2771 |
2793 QuicTestPacketMaker client_maker(version_, 0, &clock_, "mail.example.org", | 2772 QuicTestPacketMaker client_maker(version_, 0, &clock_, "mail.example.org", |
2794 Perspective::IS_CLIENT); | 2773 Perspective::IS_CLIENT); |
2795 server_maker_.set_hostname("www.example.org"); | 2774 server_maker_.set_hostname("www.example.org"); |
2796 client_maker_.set_hostname("www.example.org"); | 2775 client_maker_.set_hostname("www.example.org"); |
2797 MockQuicData mock_quic_data; | 2776 MockQuicData mock_quic_data; |
2798 mock_quic_data.AddWrite( | 2777 mock_quic_data.AddWrite( |
2799 ConstructInitialSettingsPacket(1, &request_header_offset)); | 2778 ConstructInitialSettingsPacket(1, &request_header_offset)); |
2800 // First QUIC request data. | 2779 // First QUIC request data. |
2801 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 2780 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
2802 2, GetNthClientInitiatedStreamId(0), true, true, | 2781 2, kClientDataStreamId1, true, true, |
2803 GetRequestHeaders("GET", "https", "/"), &request_header_offset)); | 2782 GetRequestHeaders("GET", "https", "/"), &request_header_offset)); |
2804 | 2783 |
2805 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 2784 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
2806 1, GetNthClientInitiatedStreamId(0), false, false, | 2785 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"), |
2807 GetResponseHeaders("200 OK"), &response_header_offset)); | 2786 &response_header_offset)); |
2808 mock_quic_data.AddRead( | 2787 mock_quic_data.AddRead(ConstructServerDataPacket( |
2809 ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), false, | 2788 2, kClientDataStreamId1, false, true, 0, "hello from mail QUIC!")); |
2810 true, 0, "hello from mail QUIC!")); | |
2811 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); | 2789 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); |
2812 // Second QUIC request data. | 2790 // Second QUIC request data. |
2813 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 2791 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
2814 4, GetNthClientInitiatedStreamId(1), false, true, | 2792 4, kClientDataStreamId2, false, true, |
2815 GetRequestHeaders("GET", "https", "/", &client_maker), | 2793 GetRequestHeaders("GET", "https", "/", &client_maker), |
2816 &request_header_offset)); | 2794 &request_header_offset)); |
2817 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 2795 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
2818 3, GetNthClientInitiatedStreamId(1), false, false, | 2796 3, kClientDataStreamId2, false, false, GetResponseHeaders("200 OK"), |
2819 GetResponseHeaders("200 OK"), &response_header_offset)); | 2797 &response_header_offset)); |
2820 mock_quic_data.AddRead( | 2798 mock_quic_data.AddRead(ConstructServerDataPacket( |
2821 ConstructServerDataPacket(4, GetNthClientInitiatedStreamId(1), false, | 2799 4, kClientDataStreamId2, false, true, 0, "hello from mail QUIC!")); |
2822 true, 0, "hello from mail QUIC!")); | |
2823 mock_quic_data.AddWrite( | 2800 mock_quic_data.AddWrite( |
2824 ConstructClientAckAndConnectionClosePacket(5, 4, 3, 1)); | 2801 ConstructClientAckAndConnectionClosePacket(5, 4, 3, 1)); |
2825 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read | 2802 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
2826 mock_quic_data.AddRead(ASYNC, 0); // EOF | 2803 mock_quic_data.AddRead(ASYNC, 0); // EOF |
2827 | 2804 |
2828 mock_quic_data.AddSocketDataToFactory(&socket_factory_); | 2805 mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
2829 | 2806 |
2830 AddHangingNonAlternateProtocolSocketData(); | 2807 AddHangingNonAlternateProtocolSocketData(); |
2831 CreateSession(); | 2808 CreateSession(); |
2832 | 2809 |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2884 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr, | 2861 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr, |
2885 0); | 2862 0); |
2886 socket_factory_.AddSocketDataProvider(&http_data); | 2863 socket_factory_.AddSocketDataProvider(&http_data); |
2887 socket_factory_.AddSSLSocketDataProvider(&ssl_data_); | 2864 socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
2888 | 2865 |
2889 MockQuicData mock_quic_data; | 2866 MockQuicData mock_quic_data; |
2890 QuicStreamOffset header_stream_offset = 0; | 2867 QuicStreamOffset header_stream_offset = 0; |
2891 mock_quic_data.AddWrite( | 2868 mock_quic_data.AddWrite( |
2892 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 2869 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
2893 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 2870 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
2894 2, GetNthClientInitiatedStreamId(0), true, true, | 2871 2, kClientDataStreamId1, true, true, |
2895 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); | 2872 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
2896 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 2873 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
2897 1, GetNthClientInitiatedStreamId(0), false, false, | 2874 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"))); |
2898 GetResponseHeaders("200 OK"))); | 2875 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1, |
2899 mock_quic_data.AddRead(ConstructServerDataPacket( | 2876 false, true, 0, "hello!")); |
2900 2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!")); | |
2901 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); | 2877 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); |
2902 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read | 2878 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
2903 mock_quic_data.AddRead(ASYNC, 0); // EOF | 2879 mock_quic_data.AddRead(ASYNC, 0); // EOF |
2904 | 2880 |
2905 mock_quic_data.AddSocketDataToFactory(&socket_factory_); | 2881 mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
2906 | 2882 |
2907 AddHangingNonAlternateProtocolSocketData(); | 2883 AddHangingNonAlternateProtocolSocketData(); |
2908 CreateSession(); | 2884 CreateSession(); |
2909 | 2885 |
2910 AlternativeService alternative_service(kProtoQUIC, | 2886 AlternativeService alternative_service(kProtoQUIC, |
(...skipping 25 matching lines...) Expand all Loading... |
2936 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr, | 2912 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr, |
2937 0); | 2913 0); |
2938 socket_factory_.AddSocketDataProvider(&http_data); | 2914 socket_factory_.AddSocketDataProvider(&http_data); |
2939 socket_factory_.AddSSLSocketDataProvider(&ssl_data_); | 2915 socket_factory_.AddSSLSocketDataProvider(&ssl_data_); |
2940 | 2916 |
2941 MockQuicData mock_quic_data; | 2917 MockQuicData mock_quic_data; |
2942 QuicStreamOffset header_stream_offset = 0; | 2918 QuicStreamOffset header_stream_offset = 0; |
2943 mock_quic_data.AddWrite( | 2919 mock_quic_data.AddWrite( |
2944 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 2920 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
2945 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 2921 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
2946 2, GetNthClientInitiatedStreamId(0), true, true, | 2922 2, kClientDataStreamId1, true, true, |
2947 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); | 2923 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
2948 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 2924 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
2949 1, GetNthClientInitiatedStreamId(0), false, false, | 2925 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"))); |
2950 GetResponseHeaders("200 OK"))); | 2926 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1, |
2951 mock_quic_data.AddRead(ConstructServerDataPacket( | 2927 false, true, 0, "hello!")); |
2952 2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!")); | |
2953 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); | 2928 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); |
2954 mock_quic_data.AddRead(SYNCHRONOUS, 0); // EOF | 2929 mock_quic_data.AddRead(SYNCHRONOUS, 0); // EOF |
2955 | 2930 |
2956 mock_quic_data.AddSocketDataToFactory(&socket_factory_); | 2931 mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
2957 | 2932 |
2958 AddHangingNonAlternateProtocolSocketData(); | 2933 AddHangingNonAlternateProtocolSocketData(); |
2959 CreateSession(); | 2934 CreateSession(); |
2960 | 2935 |
2961 // TODO(rtenneti): Test QUIC over HTTPS, GetSSLInfo(). | 2936 // TODO(rtenneti): Test QUIC over HTTPS, GetSSLInfo(). |
2962 SendRequestAndExpectHttpResponse("hello world"); | 2937 SendRequestAndExpectHttpResponse("hello world"); |
2963 } | 2938 } |
2964 | 2939 |
2965 // Tests that the connection to an HTTPS proxy is raced with an available | 2940 // Tests that the connection to an HTTPS proxy is raced with an available |
2966 // alternative proxy server. | 2941 // alternative proxy server. |
2967 TEST_P(QuicNetworkTransactionTest, QuicProxyWithRacing) { | 2942 TEST_P(QuicNetworkTransactionTest, QuicProxyWithRacing) { |
2968 base::HistogramTester histogram_tester; | 2943 base::HistogramTester histogram_tester; |
2969 proxy_service_ = | 2944 proxy_service_ = |
2970 ProxyService::CreateFixedFromPacResult("HTTPS mail.example.org:443"); | 2945 ProxyService::CreateFixedFromPacResult("HTTPS mail.example.org:443"); |
2971 | 2946 |
2972 MockQuicData mock_quic_data; | 2947 MockQuicData mock_quic_data; |
2973 QuicStreamOffset header_stream_offset = 0; | 2948 QuicStreamOffset header_stream_offset = 0; |
2974 mock_quic_data.AddWrite( | 2949 mock_quic_data.AddWrite( |
2975 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 2950 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
2976 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 2951 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
2977 2, GetNthClientInitiatedStreamId(0), true, true, | 2952 2, kClientDataStreamId1, true, true, |
2978 GetRequestHeaders("GET", "http", "/"), &header_stream_offset)); | 2953 GetRequestHeaders("GET", "http", "/"), &header_stream_offset)); |
2979 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 2954 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
2980 1, GetNthClientInitiatedStreamId(0), false, false, | 2955 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"))); |
2981 GetResponseHeaders("200 OK"))); | 2956 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1, |
2982 mock_quic_data.AddRead(ConstructServerDataPacket( | 2957 false, true, 0, "hello!")); |
2983 2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!")); | |
2984 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); | 2958 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); |
2985 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read | 2959 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
2986 mock_quic_data.AddRead(ASYNC, 0); // EOF | 2960 mock_quic_data.AddRead(ASYNC, 0); // EOF |
2987 | 2961 |
2988 mock_quic_data.AddSocketDataToFactory(&socket_factory_); | 2962 mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
2989 | 2963 |
2990 // There is no need to set up main job, because no attempt will be made to | 2964 // There is no need to set up main job, because no attempt will be made to |
2991 // speak to the proxy over TCP. | 2965 // speak to the proxy over TCP. |
2992 request_.url = GURL("http://mail.example.org/"); | 2966 request_.url = GURL("http://mail.example.org/"); |
2993 TestProxyDelegate test_proxy_delegate; | 2967 TestProxyDelegate test_proxy_delegate; |
(...skipping 70 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3064 | 3038 |
3065 ASSERT_TRUE(http_data2.AllReadDataConsumed()); | 3039 ASSERT_TRUE(http_data2.AllReadDataConsumed()); |
3066 ASSERT_TRUE(http_data2.AllWriteDataConsumed()); | 3040 ASSERT_TRUE(http_data2.AllWriteDataConsumed()); |
3067 ASSERT_TRUE(quic_data.AllReadDataConsumed()); | 3041 ASSERT_TRUE(quic_data.AllReadDataConsumed()); |
3068 } | 3042 } |
3069 | 3043 |
3070 TEST_P(QuicNetworkTransactionTest, ZeroRTTWithHttpRace) { | 3044 TEST_P(QuicNetworkTransactionTest, ZeroRTTWithHttpRace) { |
3071 MockQuicData mock_quic_data; | 3045 MockQuicData mock_quic_data; |
3072 QuicStreamOffset header_stream_offset = 0; | 3046 QuicStreamOffset header_stream_offset = 0; |
3073 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 3047 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
3074 1, GetNthClientInitiatedStreamId(0), true, true, | 3048 1, kClientDataStreamId1, true, true, |
3075 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); | 3049 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
3076 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 3050 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
3077 1, GetNthClientInitiatedStreamId(0), false, false, | 3051 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"))); |
3078 GetResponseHeaders("200 OK"))); | 3052 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1, |
3079 mock_quic_data.AddRead(ConstructServerDataPacket( | 3053 false, true, 0, "hello!")); |
3080 2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!")); | |
3081 mock_quic_data.AddWrite(ConstructClientAckPacket(2, 2, 1, 1)); | 3054 mock_quic_data.AddWrite(ConstructClientAckPacket(2, 2, 1, 1)); |
3082 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read | 3055 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
3083 mock_quic_data.AddRead(ASYNC, 0); // EOF | 3056 mock_quic_data.AddRead(ASYNC, 0); // EOF |
3084 | 3057 |
3085 mock_quic_data.AddSocketDataToFactory(&socket_factory_); | 3058 mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
3086 | 3059 |
3087 // The non-alternate protocol job needs to hang in order to guarantee that | 3060 // The non-alternate protocol job needs to hang in order to guarantee that |
3088 // the alternate-protocol job will "win". | 3061 // the alternate-protocol job will "win". |
3089 AddHangingNonAlternateProtocolSocketData(); | 3062 AddHangingNonAlternateProtocolSocketData(); |
3090 | 3063 |
3091 CreateSession(); | 3064 CreateSession(); |
3092 AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); | 3065 AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
3093 SendRequestAndExpectQuicResponse("hello!"); | 3066 SendRequestAndExpectQuicResponse("hello!"); |
3094 | 3067 |
3095 EXPECT_EQ(nullptr, | 3068 EXPECT_EQ(nullptr, |
3096 http_server_properties_.GetServerNetworkStats( | 3069 http_server_properties_.GetServerNetworkStats( |
3097 url::SchemeHostPort("https", request_.url.host(), 443))); | 3070 url::SchemeHostPort("https", request_.url.host(), 443))); |
3098 } | 3071 } |
3099 | 3072 |
3100 TEST_P(QuicNetworkTransactionTest, ZeroRTTWithNoHttpRace) { | 3073 TEST_P(QuicNetworkTransactionTest, ZeroRTTWithNoHttpRace) { |
3101 MockQuicData mock_quic_data; | 3074 MockQuicData mock_quic_data; |
3102 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 3075 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
3103 1, GetNthClientInitiatedStreamId(0), true, true, | 3076 1, kClientDataStreamId1, true, true, |
3104 GetRequestHeaders("GET", "https", "/"))); | 3077 GetRequestHeaders("GET", "https", "/"))); |
3105 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 3078 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
3106 1, GetNthClientInitiatedStreamId(0), false, false, | 3079 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"))); |
3107 GetResponseHeaders("200 OK"))); | 3080 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1, |
3108 mock_quic_data.AddRead(ConstructServerDataPacket( | 3081 false, true, 0, "hello!")); |
3109 2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!")); | |
3110 mock_quic_data.AddWrite(ConstructClientAckPacket(2, 2, 1, 1)); | 3082 mock_quic_data.AddWrite(ConstructClientAckPacket(2, 2, 1, 1)); |
3111 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read | 3083 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
3112 mock_quic_data.AddRead(ASYNC, 0); // EOF | 3084 mock_quic_data.AddRead(ASYNC, 0); // EOF |
3113 mock_quic_data.AddSocketDataToFactory(&socket_factory_); | 3085 mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
3114 | 3086 |
3115 // In order for a new QUIC session to be established via alternate-protocol | 3087 // In order for a new QUIC session to be established via alternate-protocol |
3116 // without racing an HTTP connection, we need the host resolution to happen | 3088 // without racing an HTTP connection, we need the host resolution to happen |
3117 // synchronously. | 3089 // synchronously. |
3118 host_resolver_.set_synchronous_mode(true); | 3090 host_resolver_.set_synchronous_mode(true); |
3119 host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", | 3091 host_resolver_.rules()->AddIPLiteralRule("mail.example.org", "192.168.0.1", |
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3165 AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); | 3137 AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT); |
3166 SendRequestAndExpectHttpResponse("hello world"); | 3138 SendRequestAndExpectHttpResponse("hello world"); |
3167 } | 3139 } |
3168 | 3140 |
3169 TEST_P(QuicNetworkTransactionTest, ZeroRTTWithConfirmationRequired) { | 3141 TEST_P(QuicNetworkTransactionTest, ZeroRTTWithConfirmationRequired) { |
3170 MockQuicData mock_quic_data; | 3142 MockQuicData mock_quic_data; |
3171 QuicStreamOffset header_stream_offset = 0; | 3143 QuicStreamOffset header_stream_offset = 0; |
3172 mock_quic_data.AddWrite( | 3144 mock_quic_data.AddWrite( |
3173 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 3145 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
3174 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 3146 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
3175 2, GetNthClientInitiatedStreamId(0), true, true, | 3147 2, kClientDataStreamId1, true, true, |
3176 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); | 3148 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
3177 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 3149 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
3178 1, GetNthClientInitiatedStreamId(0), false, false, | 3150 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"))); |
3179 GetResponseHeaders("200 OK"))); | 3151 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1, |
3180 mock_quic_data.AddRead(ConstructServerDataPacket( | 3152 false, true, 0, "hello!")); |
3181 2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!")); | |
3182 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); | 3153 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); |
3183 mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read | 3154 mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more data to read |
3184 mock_quic_data.AddSocketDataToFactory(&socket_factory_); | 3155 mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
3185 | 3156 |
3186 // The non-alternate protocol job needs to hang in order to guarantee that | 3157 // The non-alternate protocol job needs to hang in order to guarantee that |
3187 // the alternate-protocol job will "win". | 3158 // the alternate-protocol job will "win". |
3188 AddHangingNonAlternateProtocolSocketData(); | 3159 AddHangingNonAlternateProtocolSocketData(); |
3189 | 3160 |
3190 // In order for a new QUIC session to be established via alternate-protocol | 3161 // In order for a new QUIC session to be established via alternate-protocol |
3191 // without racing an HTTP connection, we need the host resolution to happen | 3162 // without racing an HTTP connection, we need the host resolution to happen |
(...skipping 26 matching lines...) Expand all Loading... |
3218 CheckResponseData(&trans, "hello!"); | 3189 CheckResponseData(&trans, "hello!"); |
3219 } | 3190 } |
3220 | 3191 |
3221 TEST_P(QuicNetworkTransactionTest, | 3192 TEST_P(QuicNetworkTransactionTest, |
3222 LogGranularQuicErrorCodeOnQuicProtocolErrorLocal) { | 3193 LogGranularQuicErrorCodeOnQuicProtocolErrorLocal) { |
3223 MockQuicData mock_quic_data; | 3194 MockQuicData mock_quic_data; |
3224 QuicStreamOffset header_stream_offset = 0; | 3195 QuicStreamOffset header_stream_offset = 0; |
3225 mock_quic_data.AddWrite( | 3196 mock_quic_data.AddWrite( |
3226 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 3197 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
3227 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 3198 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
3228 2, GetNthClientInitiatedStreamId(0), true, true, | 3199 2, kClientDataStreamId1, true, true, |
3229 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); | 3200 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
3230 // Read a close connection packet with | 3201 // Read a close connection packet with |
3231 // QuicErrorCode: QUIC_CRYPTO_VERSION_NOT_SUPPORTED from the peer. | 3202 // QuicErrorCode: QUIC_CRYPTO_VERSION_NOT_SUPPORTED from the peer. |
3232 mock_quic_data.AddRead(ConstructServerConnectionClosePacket(1)); | 3203 mock_quic_data.AddRead(ConstructServerConnectionClosePacket(1)); |
3233 mock_quic_data.AddSocketDataToFactory(&socket_factory_); | 3204 mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
3234 | 3205 |
3235 // The non-alternate protocol job needs to hang in order to guarantee that | 3206 // The non-alternate protocol job needs to hang in order to guarantee that |
3236 // the alternate-protocol job will "win". | 3207 // the alternate-protocol job will "win". |
3237 AddHangingNonAlternateProtocolSocketData(); | 3208 AddHangingNonAlternateProtocolSocketData(); |
3238 | 3209 |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3271 EXPECT_EQ(QUIC_CRYPTO_VERSION_NOT_SUPPORTED, details.quic_connection_error); | 3242 EXPECT_EQ(QUIC_CRYPTO_VERSION_NOT_SUPPORTED, details.quic_connection_error); |
3272 } | 3243 } |
3273 | 3244 |
3274 TEST_P(QuicNetworkTransactionTest, | 3245 TEST_P(QuicNetworkTransactionTest, |
3275 LogGranularQuicErrorCodeOnQuicProtocolErrorRemote) { | 3246 LogGranularQuicErrorCodeOnQuicProtocolErrorRemote) { |
3276 MockQuicData mock_quic_data; | 3247 MockQuicData mock_quic_data; |
3277 QuicStreamOffset header_stream_offset = 0; | 3248 QuicStreamOffset header_stream_offset = 0; |
3278 mock_quic_data.AddWrite( | 3249 mock_quic_data.AddWrite( |
3279 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 3250 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
3280 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 3251 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
3281 2, GetNthClientInitiatedStreamId(0), true, true, | 3252 2, kClientDataStreamId1, true, true, |
3282 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); | 3253 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
3283 // Peer sending data from an non-existing stream causes this end to raise | 3254 // Peer sending data from an non-existing stream causes this end to raise |
3284 // error and close connection. | 3255 // error and close connection. |
3285 mock_quic_data.AddRead( | 3256 mock_quic_data.AddRead( |
3286 ConstructServerRstPacket(1, false, 99, QUIC_STREAM_LAST_ERROR)); | 3257 ConstructServerRstPacket(1, false, 99, QUIC_STREAM_LAST_ERROR)); |
3287 std::string quic_error_details = "Data for nonexistent stream"; | 3258 std::string quic_error_details = "Data for nonexistent stream"; |
3288 mock_quic_data.AddWrite(ConstructClientAckAndConnectionClosePacket( | 3259 mock_quic_data.AddWrite(ConstructClientAckAndConnectionClosePacket( |
3289 3, QuicTime::Delta::Zero(), 1, 1, 1, QUIC_INVALID_STREAM_ID, | 3260 3, QuicTime::Delta::Zero(), 1, 1, 1, QUIC_INVALID_STREAM_ID, |
3290 quic_error_details)); | 3261 quic_error_details)); |
3291 mock_quic_data.AddSocketDataToFactory(&socket_factory_); | 3262 mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3326 trans.PopulateNetErrorDetails(&details); | 3297 trans.PopulateNetErrorDetails(&details); |
3327 EXPECT_EQ(QUIC_INVALID_STREAM_ID, details.quic_connection_error); | 3298 EXPECT_EQ(QUIC_INVALID_STREAM_ID, details.quic_connection_error); |
3328 } | 3299 } |
3329 | 3300 |
3330 TEST_P(QuicNetworkTransactionTest, RstSteamErrorHandling) { | 3301 TEST_P(QuicNetworkTransactionTest, RstSteamErrorHandling) { |
3331 MockQuicData mock_quic_data; | 3302 MockQuicData mock_quic_data; |
3332 QuicStreamOffset header_stream_offset = 0; | 3303 QuicStreamOffset header_stream_offset = 0; |
3333 mock_quic_data.AddWrite( | 3304 mock_quic_data.AddWrite( |
3334 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 3305 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
3335 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 3306 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
3336 2, GetNthClientInitiatedStreamId(0), true, true, | 3307 2, kClientDataStreamId1, true, true, |
3337 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); | 3308 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
3338 // Read the response headers, then a RST_STREAM frame. | 3309 // Read the response headers, then a RST_STREAM frame. |
3339 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 3310 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
3340 1, GetNthClientInitiatedStreamId(0), false, false, | 3311 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"))); |
3341 GetResponseHeaders("200 OK"))); | |
3342 mock_quic_data.AddRead(ConstructServerRstPacket( | 3312 mock_quic_data.AddRead(ConstructServerRstPacket( |
3343 2, false, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); | 3313 2, false, kClientDataStreamId1, QUIC_STREAM_CANCELLED)); |
3344 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); | 3314 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); |
3345 mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more read data. | 3315 mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more read data. |
3346 mock_quic_data.AddSocketDataToFactory(&socket_factory_); | 3316 mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
3347 | 3317 |
3348 // The non-alternate protocol job needs to hang in order to guarantee that | 3318 // The non-alternate protocol job needs to hang in order to guarantee that |
3349 // the alternate-protocol job will "win". | 3319 // the alternate-protocol job will "win". |
3350 AddHangingNonAlternateProtocolSocketData(); | 3320 AddHangingNonAlternateProtocolSocketData(); |
3351 | 3321 |
3352 // In order for a new QUIC session to be established via alternate-protocol | 3322 // In order for a new QUIC session to be established via alternate-protocol |
3353 // without racing an HTTP connection, we need the host resolution to happen | 3323 // without racing an HTTP connection, we need the host resolution to happen |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3389 std::string response_data; | 3359 std::string response_data; |
3390 ASSERT_EQ(ERR_QUIC_PROTOCOL_ERROR, ReadTransaction(&trans, &response_data)); | 3360 ASSERT_EQ(ERR_QUIC_PROTOCOL_ERROR, ReadTransaction(&trans, &response_data)); |
3391 } | 3361 } |
3392 | 3362 |
3393 TEST_P(QuicNetworkTransactionTest, RstSteamBeforeHeaders) { | 3363 TEST_P(QuicNetworkTransactionTest, RstSteamBeforeHeaders) { |
3394 MockQuicData mock_quic_data; | 3364 MockQuicData mock_quic_data; |
3395 QuicStreamOffset header_stream_offset = 0; | 3365 QuicStreamOffset header_stream_offset = 0; |
3396 mock_quic_data.AddWrite( | 3366 mock_quic_data.AddWrite( |
3397 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 3367 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
3398 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 3368 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
3399 2, GetNthClientInitiatedStreamId(0), true, true, | 3369 2, kClientDataStreamId1, true, true, |
3400 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); | 3370 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
3401 mock_quic_data.AddRead(ConstructServerRstPacket( | 3371 mock_quic_data.AddRead(ConstructServerRstPacket( |
3402 1, false, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); | 3372 1, false, kClientDataStreamId1, QUIC_STREAM_CANCELLED)); |
3403 mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more read data. | 3373 mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more read data. |
3404 mock_quic_data.AddSocketDataToFactory(&socket_factory_); | 3374 mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
3405 | 3375 |
3406 // The non-alternate protocol job needs to hang in order to guarantee that | 3376 // The non-alternate protocol job needs to hang in order to guarantee that |
3407 // the alternate-protocol job will "win". | 3377 // the alternate-protocol job will "win". |
3408 AddHangingNonAlternateProtocolSocketData(); | 3378 AddHangingNonAlternateProtocolSocketData(); |
3409 | 3379 |
3410 // In order for a new QUIC session to be established via alternate-protocol | 3380 // In order for a new QUIC session to be established via alternate-protocol |
3411 // without racing an HTTP connection, we need the host resolution to happen | 3381 // without racing an HTTP connection, we need the host resolution to happen |
3412 // synchronously. Of course, even though QUIC *could* perform a 0-RTT | 3382 // synchronously. Of course, even though QUIC *could* perform a 0-RTT |
(...skipping 198 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3611 AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START); | 3581 AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START); |
3612 SendRequestAndExpectHttpResponse("hello from http"); | 3582 SendRequestAndExpectHttpResponse("hello from http"); |
3613 | 3583 |
3614 ExpectBrokenAlternateProtocolMapping(); | 3584 ExpectBrokenAlternateProtocolMapping(); |
3615 } | 3585 } |
3616 | 3586 |
3617 TEST_P(QuicNetworkTransactionTest, ConnectionCloseDuringConnect) { | 3587 TEST_P(QuicNetworkTransactionTest, ConnectionCloseDuringConnect) { |
3618 MockQuicData mock_quic_data; | 3588 MockQuicData mock_quic_data; |
3619 mock_quic_data.AddSynchronousRead(ConstructServerConnectionClosePacket(1)); | 3589 mock_quic_data.AddSynchronousRead(ConstructServerConnectionClosePacket(1)); |
3620 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 3590 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
3621 1, GetNthClientInitiatedStreamId(0), true, true, | 3591 1, kClientDataStreamId1, true, true, |
3622 GetRequestHeaders("GET", "https", "/"))); | 3592 GetRequestHeaders("GET", "https", "/"))); |
3623 mock_quic_data.AddWrite(ConstructClientAckPacket(2, 1, 1, 1)); | 3593 mock_quic_data.AddWrite(ConstructClientAckPacket(2, 1, 1, 1)); |
3624 mock_quic_data.AddSocketDataToFactory(&socket_factory_); | 3594 mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
3625 | 3595 |
3626 // When the QUIC connection fails, we will try the request again over HTTP. | 3596 // When the QUIC connection fails, we will try the request again over HTTP. |
3627 MockRead http_reads[] = { | 3597 MockRead http_reads[] = { |
3628 MockRead("HTTP/1.1 200 OK\r\n"), MockRead(kQuicAlternativeServiceHeader), | 3598 MockRead("HTTP/1.1 200 OK\r\n"), MockRead(kQuicAlternativeServiceHeader), |
3629 MockRead("hello world"), | 3599 MockRead("hello world"), |
3630 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), | 3600 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
3631 MockRead(ASYNC, OK)}; | 3601 MockRead(ASYNC, OK)}; |
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3677 TestAlternativeProxy(ERR_IO_PENDING); | 3647 TestAlternativeProxy(ERR_IO_PENDING); |
3678 } | 3648 } |
3679 TEST_P(QuicNetworkTransactionTest, BrokenAlternativeProxyAddressUnreachable) { | 3649 TEST_P(QuicNetworkTransactionTest, BrokenAlternativeProxyAddressUnreachable) { |
3680 TestAlternativeProxy(ERR_ADDRESS_UNREACHABLE); | 3650 TestAlternativeProxy(ERR_ADDRESS_UNREACHABLE); |
3681 } | 3651 } |
3682 | 3652 |
3683 TEST_P(QuicNetworkTransactionTest, ConnectionCloseDuringConnectProxy) { | 3653 TEST_P(QuicNetworkTransactionTest, ConnectionCloseDuringConnectProxy) { |
3684 MockQuicData mock_quic_data; | 3654 MockQuicData mock_quic_data; |
3685 mock_quic_data.AddSynchronousRead(ConstructServerConnectionClosePacket(1)); | 3655 mock_quic_data.AddSynchronousRead(ConstructServerConnectionClosePacket(1)); |
3686 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 3656 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
3687 1, GetNthClientInitiatedStreamId(0), true, true, | 3657 1, kClientDataStreamId1, true, true, |
3688 GetRequestHeaders("GET", "https", "/"))); | 3658 GetRequestHeaders("GET", "https", "/"))); |
3689 mock_quic_data.AddWrite(ConstructClientAckPacket(2, 1, 1, 1)); | 3659 mock_quic_data.AddWrite(ConstructClientAckPacket(2, 1, 1, 1)); |
3690 mock_quic_data.AddSocketDataToFactory(&socket_factory_); | 3660 mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
3691 | 3661 |
3692 // When the QUIC connection fails, we will try the request again over HTTP. | 3662 // When the QUIC connection fails, we will try the request again over HTTP. |
3693 MockRead http_reads[] = { | 3663 MockRead http_reads[] = { |
3694 MockRead("HTTP/1.1 200 OK\r\n"), MockRead(kQuicAlternativeServiceHeader), | 3664 MockRead("HTTP/1.1 200 OK\r\n"), MockRead(kQuicAlternativeServiceHeader), |
3695 MockRead("hello world"), | 3665 MockRead("hello world"), |
3696 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), | 3666 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
3697 MockRead(ASYNC, OK)}; | 3667 MockRead(ASYNC, OK)}; |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3731 | 3701 |
3732 TEST_P(QuicNetworkTransactionTest, SecureResourceOverSecureQuic) { | 3702 TEST_P(QuicNetworkTransactionTest, SecureResourceOverSecureQuic) { |
3733 client_maker_.set_hostname("www.example.org"); | 3703 client_maker_.set_hostname("www.example.org"); |
3734 EXPECT_FALSE( | 3704 EXPECT_FALSE( |
3735 test_socket_performance_watcher_factory_.rtt_notification_received()); | 3705 test_socket_performance_watcher_factory_.rtt_notification_received()); |
3736 MockQuicData mock_quic_data; | 3706 MockQuicData mock_quic_data; |
3737 QuicStreamOffset header_stream_offset = 0; | 3707 QuicStreamOffset header_stream_offset = 0; |
3738 mock_quic_data.AddWrite( | 3708 mock_quic_data.AddWrite( |
3739 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 3709 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
3740 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 3710 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
3741 2, GetNthClientInitiatedStreamId(0), true, true, | 3711 2, kClientDataStreamId1, true, true, |
3742 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); | 3712 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
3743 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 3713 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
3744 1, GetNthClientInitiatedStreamId(0), false, false, | 3714 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"))); |
3745 GetResponseHeaders("200 OK"))); | 3715 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1, |
3746 mock_quic_data.AddRead(ConstructServerDataPacket( | 3716 false, true, 0, "hello!")); |
3747 2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!")); | |
3748 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); | 3717 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); |
3749 mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more read data. | 3718 mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); // No more read data. |
3750 mock_quic_data.AddSocketDataToFactory(&socket_factory_); | 3719 mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
3751 | 3720 |
3752 request_.url = GURL("https://www.example.org:443"); | 3721 request_.url = GURL("https://www.example.org:443"); |
3753 AddHangingNonAlternateProtocolSocketData(); | 3722 AddHangingNonAlternateProtocolSocketData(); |
3754 CreateSession(); | 3723 CreateSession(); |
3755 AddQuicAlternateProtocolMapping(MockCryptoClientStream::CONFIRM_HANDSHAKE); | 3724 AddQuicAlternateProtocolMapping(MockCryptoClientStream::CONFIRM_HANDSHAKE); |
3756 SendRequestAndExpectQuicResponse("hello!"); | 3725 SendRequestAndExpectQuicResponse("hello!"); |
3757 EXPECT_TRUE( | 3726 EXPECT_TRUE( |
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3846 | 3815 |
3847 params_.origins_to_force_quic_on.insert( | 3816 params_.origins_to_force_quic_on.insert( |
3848 HostPortPair::FromString("mail.example.org:443")); | 3817 HostPortPair::FromString("mail.example.org:443")); |
3849 params_.quic_migrate_sessions_on_network_change = true; | 3818 params_.quic_migrate_sessions_on_network_change = true; |
3850 | 3819 |
3851 MockQuicData socket_data; | 3820 MockQuicData socket_data; |
3852 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); | 3821 socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING); |
3853 QuicStreamOffset offset = 0; | 3822 QuicStreamOffset offset = 0; |
3854 socket_data.AddWrite(ConstructInitialSettingsPacket(1, &offset)); | 3823 socket_data.AddWrite(ConstructInitialSettingsPacket(1, &offset)); |
3855 socket_data.AddWrite(ConstructClientRequestHeadersPacket( | 3824 socket_data.AddWrite(ConstructClientRequestHeadersPacket( |
3856 2, GetNthClientInitiatedStreamId(0), true, false, | 3825 2, kClientDataStreamId1, true, false, |
3857 GetRequestHeaders("POST", "https", "/"), &offset)); | 3826 GetRequestHeaders("POST", "https", "/"), &offset)); |
3858 socket_data.AddWrite(SYNCHRONOUS, ERR_FAILED); | 3827 socket_data.AddWrite(SYNCHRONOUS, ERR_FAILED); |
3859 socket_data.AddSocketDataToFactory(&socket_factory_); | 3828 socket_data.AddSocketDataToFactory(&socket_factory_); |
3860 | 3829 |
3861 MockQuicData socket_data2; | 3830 MockQuicData socket_data2; |
3862 socket_data2.AddConnect(SYNCHRONOUS, ERR_ADDRESS_INVALID); | 3831 socket_data2.AddConnect(SYNCHRONOUS, ERR_ADDRESS_INVALID); |
3863 socket_data2.AddSocketDataToFactory(&socket_factory_); | 3832 socket_data2.AddSocketDataToFactory(&socket_factory_); |
3864 | 3833 |
3865 // The non-alternate protocol job needs to hang in order to guarantee that | 3834 // The non-alternate protocol job needs to hang in order to guarantee that |
3866 // the alternate-protocol job will "win". | 3835 // the alternate-protocol job will "win". |
(...skipping 23 matching lines...) Expand all Loading... |
3890 // Adds coverage to catch regression such as https://crbug.com/622043 | 3859 // Adds coverage to catch regression such as https://crbug.com/622043 |
3891 TEST_P(QuicNetworkTransactionTest, QuicServerPush) { | 3860 TEST_P(QuicNetworkTransactionTest, QuicServerPush) { |
3892 params_.origins_to_force_quic_on.insert( | 3861 params_.origins_to_force_quic_on.insert( |
3893 HostPortPair::FromString("mail.example.org:443")); | 3862 HostPortPair::FromString("mail.example.org:443")); |
3894 | 3863 |
3895 MockQuicData mock_quic_data; | 3864 MockQuicData mock_quic_data; |
3896 QuicStreamOffset header_stream_offset = 0; | 3865 QuicStreamOffset header_stream_offset = 0; |
3897 mock_quic_data.AddWrite( | 3866 mock_quic_data.AddWrite( |
3898 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 3867 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
3899 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 3868 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
3900 2, GetNthClientInitiatedStreamId(0), true, true, | 3869 2, kClientDataStreamId1, true, true, |
3901 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); | 3870 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
3902 QuicStreamOffset server_header_offset = 0; | 3871 QuicStreamOffset server_header_offset = 0; |
3903 mock_quic_data.AddRead(ConstructServerPushPromisePacket( | 3872 mock_quic_data.AddRead(ConstructServerPushPromisePacket( |
3904 1, GetNthClientInitiatedStreamId(0), GetNthServerInitiatedStreamId(0), | 3873 1, kClientDataStreamId1, kServerDataStreamId1, false, |
3905 false, GetRequestHeaders("GET", "https", "/pushed.jpg"), | 3874 GetRequestHeaders("GET", "https", "/pushed.jpg"), &server_header_offset, |
3906 &server_header_offset, &server_maker_)); | 3875 &server_maker_)); |
3907 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 3876 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
3908 2, GetNthClientInitiatedStreamId(0), false, false, | 3877 2, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"), |
3909 GetResponseHeaders("200 OK"), &server_header_offset)); | 3878 &server_header_offset)); |
3910 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); | 3879 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); |
3911 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 3880 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
3912 3, GetNthServerInitiatedStreamId(0), false, false, | 3881 3, kServerDataStreamId1, false, false, GetResponseHeaders("200 OK"), |
3913 GetResponseHeaders("200 OK"), &server_header_offset)); | 3882 &server_header_offset)); |
3914 mock_quic_data.AddRead(ConstructServerDataPacket( | 3883 mock_quic_data.AddRead(ConstructServerDataPacket(4, kClientDataStreamId1, |
3915 4, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!")); | 3884 false, true, 0, "hello!")); |
3916 mock_quic_data.AddWrite(ConstructClientAckPacket(4, 4, 3, 1)); | 3885 mock_quic_data.AddWrite(ConstructClientAckPacket(4, 4, 3, 1)); |
3917 mock_quic_data.AddRead(ConstructServerDataPacket( | 3886 mock_quic_data.AddRead(ConstructServerDataPacket( |
3918 5, GetNthServerInitiatedStreamId(0), false, true, 0, "and hello!")); | 3887 5, kServerDataStreamId1, false, true, 0, "and hello!")); |
3919 mock_quic_data.AddWrite(ConstructClientAckAndRstPacket( | 3888 mock_quic_data.AddWrite(ConstructClientAckAndRstPacket( |
3920 5, GetNthServerInitiatedStreamId(0), QUIC_RST_ACKNOWLEDGEMENT, 5, 5, 1)); | 3889 5, kServerDataStreamId1, QUIC_RST_ACKNOWLEDGEMENT, 5, 5, 1)); |
3921 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read | 3890 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
3922 mock_quic_data.AddRead(ASYNC, 0); // EOF | 3891 mock_quic_data.AddRead(ASYNC, 0); // EOF |
3923 mock_quic_data.AddSocketDataToFactory(&socket_factory_); | 3892 mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
3924 | 3893 |
3925 // The non-alternate protocol job needs to hang in order to guarantee that | 3894 // The non-alternate protocol job needs to hang in order to guarantee that |
3926 // the alternate-protocol job will "win". | 3895 // the alternate-protocol job will "win". |
3927 AddHangingNonAlternateProtocolSocketData(); | 3896 AddHangingNonAlternateProtocolSocketData(); |
3928 | 3897 |
3929 CreateSession(); | 3898 CreateSession(); |
3930 | 3899 |
(...skipping 18 matching lines...) Expand all Loading... |
3949 TEST_P(QuicNetworkTransactionTest, QuicForceHolBlocking) { | 3918 TEST_P(QuicNetworkTransactionTest, QuicForceHolBlocking) { |
3950 params_.quic_force_hol_blocking = true; | 3919 params_.quic_force_hol_blocking = true; |
3951 params_.origins_to_force_quic_on.insert( | 3920 params_.origins_to_force_quic_on.insert( |
3952 HostPortPair::FromString("mail.example.org:443")); | 3921 HostPortPair::FromString("mail.example.org:443")); |
3953 | 3922 |
3954 MockQuicData mock_quic_data; | 3923 MockQuicData mock_quic_data; |
3955 | 3924 |
3956 QuicStreamOffset offset = 0; | 3925 QuicStreamOffset offset = 0; |
3957 mock_quic_data.AddWrite(ConstructInitialSettingsPacket(1, &offset)); | 3926 mock_quic_data.AddWrite(ConstructInitialSettingsPacket(1, &offset)); |
3958 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 3927 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
3959 2, GetNthClientInitiatedStreamId(0), true, false, | 3928 2, kClientDataStreamId1, true, false, |
3960 GetRequestHeaders("POST", "https", "/"), &offset)); | 3929 GetRequestHeaders("POST", "https", "/"), &offset)); |
3961 | 3930 |
3962 std::unique_ptr<QuicEncryptedPacket> packet; | 3931 std::unique_ptr<QuicEncryptedPacket> packet; |
3963 if (version_ == QUIC_VERSION_36) { | 3932 if (version_ == QUIC_VERSION_36) { |
3964 packet = ConstructClientForceHolDataPacket( | 3933 packet = ConstructClientForceHolDataPacket(3, kClientDataStreamId1, true, |
3965 3, GetNthClientInitiatedStreamId(0), true, true, &offset, "1"); | 3934 true, &offset, "1"); |
3966 } else { | 3935 } else { |
3967 packet = ConstructClientDataPacket(3, GetNthClientInitiatedStreamId(0), | 3936 packet = |
3968 true, true, 0, "1"); | 3937 ConstructClientDataPacket(3, kClientDataStreamId1, true, true, 0, "1"); |
3969 } | 3938 } |
3970 mock_quic_data.AddWrite(std::move(packet)); | 3939 mock_quic_data.AddWrite(std::move(packet)); |
3971 | 3940 |
3972 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 3941 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
3973 1, GetNthClientInitiatedStreamId(0), false, false, | 3942 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"))); |
3974 GetResponseHeaders("200 OK"))); | |
3975 | 3943 |
3976 mock_quic_data.AddRead(ConstructServerDataPacket( | 3944 mock_quic_data.AddRead(ConstructServerDataPacket(2, kClientDataStreamId1, |
3977 2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!")); | 3945 false, true, 0, "hello!")); |
3978 | 3946 |
3979 mock_quic_data.AddWrite(ConstructClientAckPacket(4, 2, 1, 1)); | 3947 mock_quic_data.AddWrite(ConstructClientAckPacket(4, 2, 1, 1)); |
3980 | 3948 |
3981 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read | 3949 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
3982 mock_quic_data.AddRead(ASYNC, 0); // EOF | 3950 mock_quic_data.AddRead(ASYNC, 0); // EOF |
3983 mock_quic_data.AddSocketDataToFactory(&socket_factory_); | 3951 mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
3984 | 3952 |
3985 // The non-alternate protocol job needs to hang in order to guarantee that | 3953 // The non-alternate protocol job needs to hang in order to guarantee that |
3986 // the alternate-protocol job will "win". | 3954 // the alternate-protocol job will "win". |
3987 AddHangingNonAlternateProtocolSocketData(); | 3955 AddHangingNonAlternateProtocolSocketData(); |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4034 HostPortPair::FromString("mail.example.org:443")); | 4002 HostPortPair::FromString("mail.example.org:443")); |
4035 | 4003 |
4036 MockQuicData mock_quic_data; | 4004 MockQuicData mock_quic_data; |
4037 QuicStreamOffset header_stream_offset = 0; | 4005 QuicStreamOffset header_stream_offset = 0; |
4038 mock_quic_data.AddWrite( | 4006 mock_quic_data.AddWrite( |
4039 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 4007 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
4040 SpdyHeaderBlock headers(GetRequestHeaders("GET", "https", "/")); | 4008 SpdyHeaderBlock headers(GetRequestHeaders("GET", "https", "/")); |
4041 headers["user-agent"] = ""; | 4009 headers["user-agent"] = ""; |
4042 headers["accept-encoding"] = "gzip, deflate"; | 4010 headers["accept-encoding"] = "gzip, deflate"; |
4043 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 4011 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
4044 2, GetNthClientInitiatedStreamId(0), true, true, std::move(headers), | 4012 2, kClientDataStreamId1, true, true, std::move(headers), |
4045 &header_stream_offset)); | 4013 &header_stream_offset)); |
4046 | 4014 |
4047 QuicStreamOffset expected_raw_header_response_size = 0; | 4015 QuicStreamOffset expected_raw_header_response_size = 0; |
4048 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 4016 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
4049 1, GetNthClientInitiatedStreamId(0), false, false, | 4017 1, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"), |
4050 GetResponseHeaders("200 OK"), &expected_raw_header_response_size)); | 4018 &expected_raw_header_response_size)); |
4051 | 4019 |
4052 mock_quic_data.AddRead( | 4020 mock_quic_data.AddRead(ConstructServerDataPacket( |
4053 ConstructServerDataPacket(2, GetNthClientInitiatedStreamId(0), false, | 4021 2, kClientDataStreamId1, false, true, 0, "Main Resource Data")); |
4054 true, 0, "Main Resource Data")); | |
4055 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); | 4022 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); |
4056 | 4023 |
4057 mock_quic_data.AddRead(ASYNC, 0); // EOF | 4024 mock_quic_data.AddRead(ASYNC, 0); // EOF |
4058 | 4025 |
4059 CreateSession(); | 4026 CreateSession(); |
4060 | 4027 |
4061 TestDelegate delegate; | 4028 TestDelegate delegate; |
4062 QuicURLRequestContext quic_url_request_context(std::move(session_), | 4029 QuicURLRequestContext quic_url_request_context(std::move(session_), |
4063 &socket_factory_); | 4030 &socket_factory_); |
4064 | 4031 |
(...skipping 28 matching lines...) Expand all Loading... |
4093 HostPortPair::FromString("mail.example.org:443")); | 4060 HostPortPair::FromString("mail.example.org:443")); |
4094 | 4061 |
4095 MockQuicData mock_quic_data; | 4062 MockQuicData mock_quic_data; |
4096 QuicStreamOffset header_stream_offset = 0; | 4063 QuicStreamOffset header_stream_offset = 0; |
4097 mock_quic_data.AddWrite( | 4064 mock_quic_data.AddWrite( |
4098 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 4065 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
4099 SpdyHeaderBlock headers(GetRequestHeaders("GET", "https", "/")); | 4066 SpdyHeaderBlock headers(GetRequestHeaders("GET", "https", "/")); |
4100 headers["user-agent"] = ""; | 4067 headers["user-agent"] = ""; |
4101 headers["accept-encoding"] = "gzip, deflate"; | 4068 headers["accept-encoding"] = "gzip, deflate"; |
4102 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 4069 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
4103 2, GetNthClientInitiatedStreamId(0), true, true, std::move(headers), | 4070 2, kClientDataStreamId1, true, true, std::move(headers), |
4104 &header_stream_offset)); | 4071 &header_stream_offset)); |
4105 | 4072 |
4106 QuicStreamOffset server_header_offset = 0; | 4073 QuicStreamOffset server_header_offset = 0; |
4107 QuicStreamOffset expected_raw_header_response_size = 0; | 4074 QuicStreamOffset expected_raw_header_response_size = 0; |
4108 | 4075 |
4109 mock_quic_data.AddRead(ConstructServerPushPromisePacket( | 4076 mock_quic_data.AddRead(ConstructServerPushPromisePacket( |
4110 1, GetNthClientInitiatedStreamId(0), GetNthServerInitiatedStreamId(0), | 4077 1, kClientDataStreamId1, kServerDataStreamId1, false, |
4111 false, GetRequestHeaders("GET", "https", "/pushed.jpg"), | 4078 GetRequestHeaders("GET", "https", "/pushed.jpg"), &server_header_offset, |
4112 &server_header_offset, &server_maker_)); | 4079 &server_maker_)); |
4113 | 4080 |
4114 expected_raw_header_response_size = server_header_offset; | 4081 expected_raw_header_response_size = server_header_offset; |
4115 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 4082 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
4116 2, GetNthClientInitiatedStreamId(0), false, false, | 4083 2, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"), |
4117 GetResponseHeaders("200 OK"), &server_header_offset)); | 4084 &server_header_offset)); |
4118 expected_raw_header_response_size = | 4085 expected_raw_header_response_size = |
4119 server_header_offset - expected_raw_header_response_size; | 4086 server_header_offset - expected_raw_header_response_size; |
4120 | 4087 |
4121 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); | 4088 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); |
4122 | 4089 |
4123 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 4090 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
4124 3, GetNthServerInitiatedStreamId(0), false, false, | 4091 3, kServerDataStreamId1, false, false, GetResponseHeaders("200 OK"), |
4125 GetResponseHeaders("200 OK"), &server_header_offset)); | 4092 &server_header_offset)); |
4126 mock_quic_data.AddRead( | 4093 mock_quic_data.AddRead(ConstructServerDataPacket( |
4127 ConstructServerDataPacket(4, GetNthServerInitiatedStreamId(0), false, | 4094 4, kServerDataStreamId1, false, true, 0, "Pushed Resource Data")); |
4128 true, 0, "Pushed Resource Data")); | |
4129 | 4095 |
4130 mock_quic_data.AddWrite(ConstructClientAckPacket(4, 4, 3, 1)); | 4096 mock_quic_data.AddWrite(ConstructClientAckPacket(4, 4, 3, 1)); |
4131 mock_quic_data.AddRead( | 4097 mock_quic_data.AddRead(ConstructServerDataPacket( |
4132 ConstructServerDataPacket(5, GetNthClientInitiatedStreamId(0), false, | 4098 5, kClientDataStreamId1, false, true, 0, "Main Resource Data")); |
4133 true, 0, "Main Resource Data")); | |
4134 | 4099 |
4135 mock_quic_data.AddRead(ConstructServerConnectionClosePacket(6)); | 4100 mock_quic_data.AddRead(ConstructServerConnectionClosePacket(6)); |
4136 | 4101 |
4137 CreateSession(); | 4102 CreateSession(); |
4138 | 4103 |
4139 TestDelegate delegate; | 4104 TestDelegate delegate; |
4140 QuicURLRequestContext quic_url_request_context(std::move(session_), | 4105 QuicURLRequestContext quic_url_request_context(std::move(session_), |
4141 &socket_factory_); | 4106 &socket_factory_); |
4142 | 4107 |
4143 mock_quic_data.AddSocketDataToFactory( | 4108 mock_quic_data.AddSocketDataToFactory( |
(...skipping 215 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4359 ASSERT_TRUE(response != nullptr); | 4324 ASSERT_TRUE(response != nullptr); |
4360 ASSERT_TRUE(response->headers.get() != nullptr); | 4325 ASSERT_TRUE(response->headers.get() != nullptr); |
4361 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); | 4326 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); |
4362 EXPECT_TRUE(response->was_fetched_via_spdy); | 4327 EXPECT_TRUE(response->was_fetched_via_spdy); |
4363 EXPECT_TRUE(response->was_alpn_negotiated); | 4328 EXPECT_TRUE(response->was_alpn_negotiated); |
4364 EXPECT_EQ(QuicHttpStream::ConnectionInfoFromQuicVersion(version_), | 4329 EXPECT_EQ(QuicHttpStream::ConnectionInfoFromQuicVersion(version_), |
4365 response->connection_info); | 4330 response->connection_info); |
4366 EXPECT_EQ(443, response->socket_address.port()); | 4331 EXPECT_EQ(443, response->socket_address.port()); |
4367 } | 4332 } |
4368 | 4333 |
4369 QuicStreamId GetNthClientInitiatedStreamId(int n) { | |
4370 return test::GetNthClientInitiatedStreamId(version_, n); | |
4371 } | |
4372 | |
4373 MockClock clock_; | 4334 MockClock clock_; |
4374 QuicVersion version_; | 4335 QuicVersion version_; |
4375 DestinationType destination_type_; | 4336 DestinationType destination_type_; |
4376 std::string origin1_; | 4337 std::string origin1_; |
4377 std::string origin2_; | 4338 std::string origin2_; |
4378 std::unique_ptr<HttpNetworkSession> session_; | 4339 std::unique_ptr<HttpNetworkSession> session_; |
4379 MockClientSocketFactory socket_factory_; | 4340 MockClientSocketFactory socket_factory_; |
4380 MockHostResolver host_resolver_; | 4341 MockHostResolver host_resolver_; |
4381 MockCertVerifier cert_verifier_; | 4342 MockCertVerifier cert_verifier_; |
4382 TransportSecurityState transport_security_state_; | 4343 TransportSecurityState transport_security_state_; |
(...skipping 86 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4469 QuicTestPacketMaker server_maker1(version_, 0, &clock_, origin1_, | 4430 QuicTestPacketMaker server_maker1(version_, 0, &clock_, origin1_, |
4470 Perspective::IS_SERVER); | 4431 Perspective::IS_SERVER); |
4471 | 4432 |
4472 QuicStreamOffset request_header_offset(0); | 4433 QuicStreamOffset request_header_offset(0); |
4473 QuicStreamOffset response_header_offset(0); | 4434 QuicStreamOffset response_header_offset(0); |
4474 | 4435 |
4475 MockQuicData mock_quic_data; | 4436 MockQuicData mock_quic_data; |
4476 mock_quic_data.AddWrite(ConstructInitialSettingsPacket( | 4437 mock_quic_data.AddWrite(ConstructInitialSettingsPacket( |
4477 1, &request_header_offset, &client_maker1)); | 4438 1, &request_header_offset, &client_maker1)); |
4478 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 4439 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
4479 2, GetNthClientInitiatedStreamId(0), true, &request_header_offset, | 4440 2, kClientDataStreamId1, true, &request_header_offset, &client_maker1)); |
4480 &client_maker1)); | |
4481 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 4441 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
4482 1, GetNthClientInitiatedStreamId(0), &response_header_offset, | 4442 1, kClientDataStreamId1, &response_header_offset, &server_maker1)); |
4483 &server_maker1)); | 4443 mock_quic_data.AddRead( |
4484 mock_quic_data.AddRead(ConstructServerDataPacket( | 4444 ConstructServerDataPacket(2, kClientDataStreamId1, &server_maker1)); |
4485 2, GetNthClientInitiatedStreamId(0), &server_maker1)); | |
4486 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1, &client_maker1)); | 4445 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1, &client_maker1)); |
4487 | 4446 |
4488 QuicTestPacketMaker client_maker2(version_, 0, &clock_, origin2_, | 4447 QuicTestPacketMaker client_maker2(version_, 0, &clock_, origin2_, |
4489 Perspective::IS_CLIENT); | 4448 Perspective::IS_CLIENT); |
4490 QuicTestPacketMaker server_maker2(version_, 0, &clock_, origin2_, | 4449 QuicTestPacketMaker server_maker2(version_, 0, &clock_, origin2_, |
4491 Perspective::IS_SERVER); | 4450 Perspective::IS_SERVER); |
4492 | 4451 |
4493 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 4452 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
4494 4, GetNthClientInitiatedStreamId(1), false, &request_header_offset, | 4453 4, kClientDataStreamId2, false, &request_header_offset, &client_maker2)); |
4495 &client_maker2)); | |
4496 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 4454 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
4497 3, GetNthClientInitiatedStreamId(1), &response_header_offset, | 4455 3, kClientDataStreamId2, &response_header_offset, &server_maker2)); |
4498 &server_maker2)); | 4456 mock_quic_data.AddRead( |
4499 mock_quic_data.AddRead(ConstructServerDataPacket( | 4457 ConstructServerDataPacket(4, kClientDataStreamId2, &server_maker2)); |
4500 4, GetNthClientInitiatedStreamId(1), &server_maker2)); | |
4501 mock_quic_data.AddWrite(ConstructClientAckPacket(5, 4, 3, 1, &client_maker2)); | 4458 mock_quic_data.AddWrite(ConstructClientAckPacket(5, 4, 3, 1, &client_maker2)); |
4502 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read | 4459 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
4503 mock_quic_data.AddRead(ASYNC, 0); // EOF | 4460 mock_quic_data.AddRead(ASYNC, 0); // EOF |
4504 | 4461 |
4505 mock_quic_data.AddSocketDataToFactory(&socket_factory_); | 4462 mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
4506 | 4463 |
4507 AddHangingSocketData(); | 4464 AddHangingSocketData(); |
4508 AddHangingSocketData(); | 4465 AddHangingSocketData(); |
4509 | 4466 |
4510 SendRequestAndExpectQuicResponse(origin1_); | 4467 SendRequestAndExpectQuicResponse(origin1_); |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4549 QuicTestPacketMaker client_maker1(version_, 0, &clock_, origin1_, | 4506 QuicTestPacketMaker client_maker1(version_, 0, &clock_, origin1_, |
4550 Perspective::IS_CLIENT); | 4507 Perspective::IS_CLIENT); |
4551 QuicTestPacketMaker server_maker1(version_, 0, &clock_, origin1_, | 4508 QuicTestPacketMaker server_maker1(version_, 0, &clock_, origin1_, |
4552 Perspective::IS_SERVER); | 4509 Perspective::IS_SERVER); |
4553 | 4510 |
4554 MockQuicData mock_quic_data1; | 4511 MockQuicData mock_quic_data1; |
4555 QuicStreamOffset header_stream_offset1 = 0; | 4512 QuicStreamOffset header_stream_offset1 = 0; |
4556 mock_quic_data1.AddWrite(ConstructInitialSettingsPacket( | 4513 mock_quic_data1.AddWrite(ConstructInitialSettingsPacket( |
4557 1, &header_stream_offset1, &client_maker1)); | 4514 1, &header_stream_offset1, &client_maker1)); |
4558 mock_quic_data1.AddWrite(ConstructClientRequestHeadersPacket( | 4515 mock_quic_data1.AddWrite(ConstructClientRequestHeadersPacket( |
4559 2, GetNthClientInitiatedStreamId(0), true, &header_stream_offset1, | 4516 2, kClientDataStreamId1, true, &header_stream_offset1, &client_maker1)); |
4560 &client_maker1)); | |
4561 mock_quic_data1.AddRead(ConstructServerResponseHeadersPacket( | 4517 mock_quic_data1.AddRead(ConstructServerResponseHeadersPacket( |
4562 1, GetNthClientInitiatedStreamId(0), &server_maker1)); | 4518 1, kClientDataStreamId1, &server_maker1)); |
4563 mock_quic_data1.AddRead(ConstructServerDataPacket( | 4519 mock_quic_data1.AddRead( |
4564 2, GetNthClientInitiatedStreamId(0), &server_maker1)); | 4520 ConstructServerDataPacket(2, kClientDataStreamId1, &server_maker1)); |
4565 mock_quic_data1.AddWrite( | 4521 mock_quic_data1.AddWrite( |
4566 ConstructClientAckPacket(3, 2, 1, 1, &client_maker1)); | 4522 ConstructClientAckPacket(3, 2, 1, 1, &client_maker1)); |
4567 mock_quic_data1.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read | 4523 mock_quic_data1.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
4568 mock_quic_data1.AddRead(ASYNC, 0); // EOF | 4524 mock_quic_data1.AddRead(ASYNC, 0); // EOF |
4569 | 4525 |
4570 mock_quic_data1.AddSocketDataToFactory(&socket_factory_); | 4526 mock_quic_data1.AddSocketDataToFactory(&socket_factory_); |
4571 | 4527 |
4572 AddHangingSocketData(); | 4528 AddHangingSocketData(); |
4573 | 4529 |
4574 QuicTestPacketMaker client_maker2(version_, 0, &clock_, origin2_, | 4530 QuicTestPacketMaker client_maker2(version_, 0, &clock_, origin2_, |
4575 Perspective::IS_CLIENT); | 4531 Perspective::IS_CLIENT); |
4576 QuicTestPacketMaker server_maker2(version_, 0, &clock_, origin2_, | 4532 QuicTestPacketMaker server_maker2(version_, 0, &clock_, origin2_, |
4577 Perspective::IS_SERVER); | 4533 Perspective::IS_SERVER); |
4578 | 4534 |
4579 MockQuicData mock_quic_data2; | 4535 MockQuicData mock_quic_data2; |
4580 QuicStreamOffset header_stream_offset2 = 0; | 4536 QuicStreamOffset header_stream_offset2 = 0; |
4581 mock_quic_data2.AddWrite(ConstructInitialSettingsPacket( | 4537 mock_quic_data2.AddWrite(ConstructInitialSettingsPacket( |
4582 1, &header_stream_offset2, &client_maker2)); | 4538 1, &header_stream_offset2, &client_maker2)); |
4583 mock_quic_data2.AddWrite(ConstructClientRequestHeadersPacket( | 4539 mock_quic_data2.AddWrite(ConstructClientRequestHeadersPacket( |
4584 2, GetNthClientInitiatedStreamId(0), true, &header_stream_offset2, | 4540 2, kClientDataStreamId1, true, &header_stream_offset2, &client_maker2)); |
4585 &client_maker2)); | |
4586 mock_quic_data2.AddRead(ConstructServerResponseHeadersPacket( | 4541 mock_quic_data2.AddRead(ConstructServerResponseHeadersPacket( |
4587 1, GetNthClientInitiatedStreamId(0), &server_maker2)); | 4542 1, kClientDataStreamId1, &server_maker2)); |
4588 mock_quic_data2.AddRead(ConstructServerDataPacket( | 4543 mock_quic_data2.AddRead( |
4589 2, GetNthClientInitiatedStreamId(0), &server_maker2)); | 4544 ConstructServerDataPacket(2, kClientDataStreamId1, &server_maker2)); |
4590 mock_quic_data2.AddWrite( | 4545 mock_quic_data2.AddWrite( |
4591 ConstructClientAckPacket(3, 2, 1, 1, &client_maker2)); | 4546 ConstructClientAckPacket(3, 2, 1, 1, &client_maker2)); |
4592 mock_quic_data2.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read | 4547 mock_quic_data2.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
4593 mock_quic_data2.AddRead(ASYNC, 0); // EOF | 4548 mock_quic_data2.AddRead(ASYNC, 0); // EOF |
4594 | 4549 |
4595 mock_quic_data2.AddSocketDataToFactory(&socket_factory_); | 4550 mock_quic_data2.AddSocketDataToFactory(&socket_factory_); |
4596 | 4551 |
4597 AddHangingSocketData(); | 4552 AddHangingSocketData(); |
4598 | 4553 |
4599 SendRequestAndExpectQuicResponse(origin1_); | 4554 SendRequestAndExpectQuicResponse(origin1_); |
4600 SendRequestAndExpectQuicResponse(origin2_); | 4555 SendRequestAndExpectQuicResponse(origin2_); |
4601 | 4556 |
4602 EXPECT_TRUE(AllDataConsumed()); | 4557 EXPECT_TRUE(AllDataConsumed()); |
4603 } | 4558 } |
4604 | 4559 |
4605 // crbug.com/705109 - this confirms that matching request with a body | 4560 // crbug.com/705109 - this confirms that matching request with a body |
4606 // triggers a crash (pre-fix). | 4561 // triggers a crash (pre-fix). |
4607 TEST_P(QuicNetworkTransactionTest, QuicServerPushMatchesRequestWithBody) { | 4562 TEST_P(QuicNetworkTransactionTest, QuicServerPushMatchesRequestWithBody) { |
4608 params_.origins_to_force_quic_on.insert( | 4563 params_.origins_to_force_quic_on.insert( |
4609 HostPortPair::FromString("mail.example.org:443")); | 4564 HostPortPair::FromString("mail.example.org:443")); |
4610 | 4565 |
4611 MockQuicData mock_quic_data; | 4566 MockQuicData mock_quic_data; |
4612 QuicStreamOffset header_stream_offset = 0; | 4567 QuicStreamOffset header_stream_offset = 0; |
4613 mock_quic_data.AddWrite( | 4568 mock_quic_data.AddWrite( |
4614 ConstructInitialSettingsPacket(1, &header_stream_offset)); | 4569 ConstructInitialSettingsPacket(1, &header_stream_offset)); |
4615 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 4570 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
4616 2, GetNthClientInitiatedStreamId(0), true, true, | 4571 2, kClientDataStreamId1, true, true, |
4617 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); | 4572 GetRequestHeaders("GET", "https", "/"), &header_stream_offset)); |
4618 QuicStreamOffset server_header_offset = 0; | 4573 QuicStreamOffset server_header_offset = 0; |
4619 mock_quic_data.AddRead(ConstructServerPushPromisePacket( | 4574 mock_quic_data.AddRead(ConstructServerPushPromisePacket( |
4620 1, GetNthClientInitiatedStreamId(0), GetNthServerInitiatedStreamId(0), | 4575 1, kClientDataStreamId1, kServerDataStreamId1, false, |
4621 false, GetRequestHeaders("GET", "https", "/pushed.jpg"), | 4576 GetRequestHeaders("GET", "https", "/pushed.jpg"), &server_header_offset, |
4622 &server_header_offset, &server_maker_)); | 4577 &server_maker_)); |
4623 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 4578 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
4624 2, GetNthClientInitiatedStreamId(0), false, false, | 4579 2, kClientDataStreamId1, false, false, GetResponseHeaders("200 OK"), |
4625 GetResponseHeaders("200 OK"), &server_header_offset)); | 4580 &server_header_offset)); |
4626 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); | 4581 mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1)); |
4627 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 4582 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
4628 3, GetNthServerInitiatedStreamId(0), false, false, | 4583 3, kServerDataStreamId1, false, false, GetResponseHeaders("200 OK"), |
4629 GetResponseHeaders("200 OK"), &server_header_offset)); | 4584 &server_header_offset)); |
4630 mock_quic_data.AddRead(ConstructServerDataPacket( | 4585 mock_quic_data.AddRead(ConstructServerDataPacket(4, kClientDataStreamId1, |
4631 4, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!")); | 4586 false, true, 0, "hello!")); |
4632 mock_quic_data.AddWrite(ConstructClientAckPacket(4, 4, 3, 1)); | 4587 mock_quic_data.AddWrite(ConstructClientAckPacket(4, 4, 3, 1)); |
4633 mock_quic_data.AddRead(ConstructServerDataPacket( | 4588 mock_quic_data.AddRead(ConstructServerDataPacket( |
4634 5, GetNthServerInitiatedStreamId(0), false, true, 0, "and hello!")); | 4589 5, kServerDataStreamId1, false, true, 0, "and hello!")); |
4635 | 4590 |
4636 // Because the matching request has a body, we will see the push | 4591 // Because the matching request has a body, we will see the push |
4637 // stream get cancelled, and the matching request go out on the | 4592 // stream get cancelled, and the matching request go out on the |
4638 // wire. | 4593 // wire. |
4639 mock_quic_data.AddWrite(ConstructClientAckAndRstPacket( | 4594 mock_quic_data.AddWrite(ConstructClientAckAndRstPacket( |
4640 5, GetNthServerInitiatedStreamId(0), QUIC_STREAM_CANCELLED, 5, 5, 1)); | 4595 5, kServerDataStreamId1, QUIC_STREAM_CANCELLED, 5, 5, 1)); |
4641 const char kBody[] = "1"; | 4596 const char kBody[] = "1"; |
4642 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( | 4597 mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket( |
4643 6, GetNthClientInitiatedStreamId(1), false, false, | 4598 6, kClientDataStreamId2, false, false, |
4644 GetRequestHeaders("GET", "https", "/pushed.jpg"), &header_stream_offset)); | 4599 GetRequestHeaders("GET", "https", "/pushed.jpg"), &header_stream_offset)); |
4645 mock_quic_data.AddWrite(ConstructClientMultipleDataFramesPacket( | 4600 mock_quic_data.AddWrite(ConstructClientMultipleDataFramesPacket( |
4646 7, GetNthClientInitiatedStreamId(1), false, true, {kBody}, 0)); | 4601 7, kClientDataStreamId2, false, true, {kBody}, 0)); |
4647 | 4602 |
4648 // We see the same response as for the earlier pushed and cancelled | 4603 // We see the same response as for the earlier pushed and cancelled |
4649 // stream. | 4604 // stream. |
4650 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( | 4605 mock_quic_data.AddRead(ConstructServerResponseHeadersPacket( |
4651 6, GetNthClientInitiatedStreamId(1), false, false, | 4606 6, kClientDataStreamId2, false, false, GetResponseHeaders("200 OK"), |
4652 GetResponseHeaders("200 OK"), &server_header_offset)); | 4607 &server_header_offset)); |
4653 mock_quic_data.AddRead(ConstructServerDataPacket( | 4608 mock_quic_data.AddRead(ConstructServerDataPacket( |
4654 7, GetNthClientInitiatedStreamId(1), false, true, 0, "and hello!")); | 4609 7, kClientDataStreamId2, false, true, 0, "and hello!")); |
4655 | 4610 |
4656 mock_quic_data.AddWrite(ConstructClientAckPacket(8, 7, 6, 1)); | 4611 mock_quic_data.AddWrite(ConstructClientAckPacket(8, 7, 6, 1)); |
4657 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read | 4612 mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read |
4658 mock_quic_data.AddRead(ASYNC, 0); // EOF | 4613 mock_quic_data.AddRead(ASYNC, 0); // EOF |
4659 mock_quic_data.AddSocketDataToFactory(&socket_factory_); | 4614 mock_quic_data.AddSocketDataToFactory(&socket_factory_); |
4660 | 4615 |
4661 // The non-alternate protocol job needs to hang in order to guarantee that | 4616 // The non-alternate protocol job needs to hang in order to guarantee that |
4662 // the alternate-protocol job will "win". | 4617 // the alternate-protocol job will "win". |
4663 AddHangingNonAlternateProtocolSocketData(); | 4618 AddHangingNonAlternateProtocolSocketData(); |
4664 | 4619 |
4665 CreateSession(); | 4620 CreateSession(); |
4666 | 4621 |
4667 // PUSH_PROMISE handling in the http layer gets exercised here. | 4622 // PUSH_PROMISE handling in the http layer gets exercised here. |
4668 SendRequestAndExpectQuicResponse("hello!"); | 4623 SendRequestAndExpectQuicResponse("hello!"); |
4669 | 4624 |
4670 request_.url = GURL("https://mail.example.org/pushed.jpg"); | 4625 request_.url = GURL("https://mail.example.org/pushed.jpg"); |
4671 ChunkedUploadDataStream upload_data(0); | 4626 ChunkedUploadDataStream upload_data(0); |
4672 upload_data.AppendData("1", 1, true); | 4627 upload_data.AppendData("1", 1, true); |
4673 request_.upload_data_stream = &upload_data; | 4628 request_.upload_data_stream = &upload_data; |
4674 SendRequestAndExpectQuicResponse("and hello!"); | 4629 SendRequestAndExpectQuicResponse("and hello!"); |
4675 } | 4630 } |
4676 | 4631 |
4677 } // namespace test | 4632 } // namespace test |
4678 } // namespace net | 4633 } // namespace net |
OLD | NEW |