OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/http/http_stream_factory_impl.h" | 5 #include "net/http/http_stream_factory_impl.h" |
6 | 6 |
7 #include <stdint.h> | 7 #include <stdint.h> |
8 | 8 |
9 #include <memory> | 9 #include <memory> |
10 #include <string> | 10 #include <string> |
(...skipping 695 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
706 ERR_MSG_TOO_BIG, | 706 ERR_MSG_TOO_BIG, |
707 }; | 707 }; |
708 | 708 |
709 // Tests that a bad QUIC proxy is added to the list of bad proxies. | 709 // Tests that a bad QUIC proxy is added to the list of bad proxies. |
710 TEST_F(HttpStreamFactoryTest, QuicProxyMarkedAsBad) { | 710 TEST_F(HttpStreamFactoryTest, QuicProxyMarkedAsBad) { |
711 for (size_t i = 0; i < arraysize(quic_proxy_test_mock_errors); ++i) { | 711 for (size_t i = 0; i < arraysize(quic_proxy_test_mock_errors); ++i) { |
712 std::unique_ptr<ProxyService> proxy_service; | 712 std::unique_ptr<ProxyService> proxy_service; |
713 proxy_service = | 713 proxy_service = |
714 ProxyService::CreateFixedFromPacResult("QUIC bad:99; DIRECT"); | 714 ProxyService::CreateFixedFromPacResult("QUIC bad:99; DIRECT"); |
715 | 715 |
716 HttpNetworkSession::Params params; | 716 HttpNetworkSession::Params session_params; |
717 params.enable_quic = true; | 717 session_params.enable_quic = true; |
| 718 |
| 719 HttpNetworkSession::Context session_context; |
718 scoped_refptr<SSLConfigServiceDefaults> ssl_config_service( | 720 scoped_refptr<SSLConfigServiceDefaults> ssl_config_service( |
719 new SSLConfigServiceDefaults); | 721 new SSLConfigServiceDefaults); |
720 HttpServerPropertiesImpl http_server_properties; | 722 HttpServerPropertiesImpl http_server_properties; |
721 MockClientSocketFactory socket_factory; | 723 MockClientSocketFactory socket_factory; |
722 params.client_socket_factory = &socket_factory; | 724 session_context.client_socket_factory = &socket_factory; |
723 MockHostResolver host_resolver; | 725 MockHostResolver host_resolver; |
724 params.host_resolver = &host_resolver; | 726 session_context.host_resolver = &host_resolver; |
725 MockCertVerifier cert_verifier; | 727 MockCertVerifier cert_verifier; |
726 params.cert_verifier = &cert_verifier; | 728 session_context.cert_verifier = &cert_verifier; |
727 TransportSecurityState transport_security_state; | 729 TransportSecurityState transport_security_state; |
728 params.transport_security_state = &transport_security_state; | 730 session_context.transport_security_state = &transport_security_state; |
729 MultiLogCTVerifier ct_verifier; | 731 MultiLogCTVerifier ct_verifier; |
730 params.cert_transparency_verifier = &ct_verifier; | 732 session_context.cert_transparency_verifier = &ct_verifier; |
731 CTPolicyEnforcer ct_policy_enforcer; | 733 CTPolicyEnforcer ct_policy_enforcer; |
732 params.ct_policy_enforcer = &ct_policy_enforcer; | 734 session_context.ct_policy_enforcer = &ct_policy_enforcer; |
733 params.proxy_service = proxy_service.get(); | 735 session_context.proxy_service = proxy_service.get(); |
734 params.ssl_config_service = ssl_config_service.get(); | 736 session_context.ssl_config_service = ssl_config_service.get(); |
735 params.http_server_properties = &http_server_properties; | 737 session_context.http_server_properties = &http_server_properties; |
736 | 738 |
737 auto session = base::MakeUnique<HttpNetworkSession>(params); | 739 auto session = |
| 740 base::MakeUnique<HttpNetworkSession>(session_params, session_context); |
738 session->quic_stream_factory()->set_require_confirmation(false); | 741 session->quic_stream_factory()->set_require_confirmation(false); |
739 | 742 |
740 StaticSocketDataProvider socket_data1; | 743 StaticSocketDataProvider socket_data1; |
741 socket_data1.set_connect_data( | 744 socket_data1.set_connect_data( |
742 MockConnect(ASYNC, quic_proxy_test_mock_errors[i])); | 745 MockConnect(ASYNC, quic_proxy_test_mock_errors[i])); |
743 socket_factory.AddSocketDataProvider(&socket_data1); | 746 socket_factory.AddSocketDataProvider(&socket_data1); |
744 | 747 |
745 // Second connection attempt succeeds. | 748 // Second connection attempt succeeds. |
746 StaticSocketDataProvider socket_data2; | 749 StaticSocketDataProvider socket_data2; |
747 socket_data2.set_connect_data(MockConnect(ASYNC, OK)); | 750 socket_data2.set_connect_data(MockConnect(ASYNC, OK)); |
(...skipping 83 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
831 | 834 |
832 private: | 835 private: |
833 std::vector<std::unique_ptr<QuicEncryptedPacket>> packets_; | 836 std::vector<std::unique_ptr<QuicEncryptedPacket>> packets_; |
834 std::vector<MockWrite> writes_; | 837 std::vector<MockWrite> writes_; |
835 std::vector<MockRead> reads_; | 838 std::vector<MockRead> reads_; |
836 size_t packet_number_; | 839 size_t packet_number_; |
837 std::unique_ptr<SequencedSocketData> socket_data_; | 840 std::unique_ptr<SequencedSocketData> socket_data_; |
838 }; | 841 }; |
839 | 842 |
840 void SetupForQuicAlternativeProxyTest( | 843 void SetupForQuicAlternativeProxyTest( |
841 HttpNetworkSession::Params* params, | 844 HttpNetworkSession::Params* session_params, |
| 845 HttpNetworkSession::Context* session_context, |
842 MockClientSocketFactory* socket_factory, | 846 MockClientSocketFactory* socket_factory, |
843 ProxyService* proxy_service, | 847 ProxyService* proxy_service, |
844 TestProxyDelegate* test_proxy_delegate, | 848 TestProxyDelegate* test_proxy_delegate, |
845 HttpServerPropertiesImpl* http_server_properties, | 849 HttpServerPropertiesImpl* http_server_properties, |
846 MockCertVerifier* cert_verifier, | 850 MockCertVerifier* cert_verifier, |
847 CTPolicyEnforcer* ct_policy_enforcer, | 851 CTPolicyEnforcer* ct_policy_enforcer, |
848 MultiLogCTVerifier* ct_verifier, | 852 MultiLogCTVerifier* ct_verifier, |
849 SSLConfigServiceDefaults* ssl_config_service, | 853 SSLConfigServiceDefaults* ssl_config_service, |
850 MockHostResolver* host_resolver, | 854 MockHostResolver* host_resolver, |
851 TransportSecurityState* transport_security_state, | 855 TransportSecurityState* transport_security_state, |
852 bool set_alternative_proxy_server) { | 856 bool set_alternative_proxy_server) { |
853 params->enable_quic = true; | 857 session_params->enable_quic = true; |
854 params->client_socket_factory = socket_factory; | 858 |
855 params->host_resolver = host_resolver; | 859 session_context->client_socket_factory = socket_factory; |
856 params->transport_security_state = transport_security_state; | 860 session_context->host_resolver = host_resolver; |
857 params->proxy_service = proxy_service; | 861 session_context->transport_security_state = transport_security_state; |
858 params->ssl_config_service = ssl_config_service; | 862 session_context->proxy_service = proxy_service; |
859 params->http_server_properties = http_server_properties; | 863 session_context->ssl_config_service = ssl_config_service; |
860 params->cert_verifier = cert_verifier; | 864 session_context->http_server_properties = http_server_properties; |
861 params->ct_policy_enforcer = ct_policy_enforcer; | 865 session_context->cert_verifier = cert_verifier; |
862 params->cert_transparency_verifier = ct_verifier; | 866 session_context->ct_policy_enforcer = ct_policy_enforcer; |
| 867 session_context->cert_transparency_verifier = ct_verifier; |
863 | 868 |
864 if (set_alternative_proxy_server) { | 869 if (set_alternative_proxy_server) { |
865 test_proxy_delegate->set_alternative_proxy_server( | 870 test_proxy_delegate->set_alternative_proxy_server( |
866 ProxyServer::FromPacString("QUIC badproxy:99")); | 871 ProxyServer::FromPacString("QUIC badproxy:99")); |
867 } | 872 } |
868 params->proxy_delegate = test_proxy_delegate; | 873 session_context->proxy_delegate = test_proxy_delegate; |
869 } | 874 } |
870 | 875 |
871 } // namespace | 876 } // namespace |
872 | 877 |
873 // Tests that a HTTPS proxy that supports QUIC alternative proxy server is | 878 // Tests that a HTTPS proxy that supports QUIC alternative proxy server is |
874 // marked as bad if connecting to both the default proxy and the alternative | 879 // marked as bad if connecting to both the default proxy and the alternative |
875 // proxy is unsuccessful. | 880 // proxy is unsuccessful. |
876 TEST_F(HttpStreamFactoryTest, WithQUICAlternativeProxyMarkedAsBad) { | 881 TEST_F(HttpStreamFactoryTest, WithQUICAlternativeProxyMarkedAsBad) { |
877 const bool set_alternative_proxy_server_values[] = { | 882 const bool set_alternative_proxy_server_values[] = { |
878 false, true, | 883 false, true, |
879 }; | 884 }; |
880 | 885 |
881 for (auto mock_error : quic_proxy_test_mock_errors) { | 886 for (auto mock_error : quic_proxy_test_mock_errors) { |
882 for (auto set_alternative_proxy_server : | 887 for (auto set_alternative_proxy_server : |
883 set_alternative_proxy_server_values) { | 888 set_alternative_proxy_server_values) { |
884 HttpNetworkSession::Params params; | 889 HttpNetworkSession::Params session_params; |
| 890 HttpNetworkSession::Context session_context; |
885 MockClientSocketFactory socket_factory; | 891 MockClientSocketFactory socket_factory; |
886 std::unique_ptr<ProxyService> proxy_service = | 892 std::unique_ptr<ProxyService> proxy_service = |
887 ProxyService::CreateFixedFromPacResult( | 893 ProxyService::CreateFixedFromPacResult( |
888 "HTTPS badproxy:99; HTTPS badfallbackproxy:98; DIRECT"); | 894 "HTTPS badproxy:99; HTTPS badfallbackproxy:98; DIRECT"); |
889 TestProxyDelegate test_proxy_delegate; | 895 TestProxyDelegate test_proxy_delegate; |
890 HttpServerPropertiesImpl http_server_properties; | 896 HttpServerPropertiesImpl http_server_properties; |
891 MockCertVerifier cert_verifier; | 897 MockCertVerifier cert_verifier; |
892 CTPolicyEnforcer ct_policy_enforcer; | 898 CTPolicyEnforcer ct_policy_enforcer; |
893 MultiLogCTVerifier ct_verifier; | 899 MultiLogCTVerifier ct_verifier; |
894 scoped_refptr<SSLConfigServiceDefaults> ssl_config_service( | 900 scoped_refptr<SSLConfigServiceDefaults> ssl_config_service( |
895 new SSLConfigServiceDefaults); | 901 new SSLConfigServiceDefaults); |
896 MockHostResolver host_resolver; | 902 MockHostResolver host_resolver; |
897 TransportSecurityState transport_security_state; | 903 TransportSecurityState transport_security_state; |
898 SetupForQuicAlternativeProxyTest( | 904 SetupForQuicAlternativeProxyTest( |
899 ¶ms, &socket_factory, proxy_service.get(), &test_proxy_delegate, | 905 &session_params, &session_context, &socket_factory, |
900 &http_server_properties, &cert_verifier, &ct_policy_enforcer, | 906 proxy_service.get(), &test_proxy_delegate, &http_server_properties, |
901 &ct_verifier, ssl_config_service.get(), &host_resolver, | 907 &cert_verifier, &ct_policy_enforcer, &ct_verifier, |
902 &transport_security_state, set_alternative_proxy_server); | 908 ssl_config_service.get(), &host_resolver, &transport_security_state, |
| 909 set_alternative_proxy_server); |
903 | 910 |
904 auto session = base::MakeUnique<HttpNetworkSession>(params); | 911 auto session = |
| 912 base::MakeUnique<HttpNetworkSession>(session_params, session_context); |
905 | 913 |
906 // Before starting the test, verify that there are no proxies marked as | 914 // Before starting the test, verify that there are no proxies marked as |
907 // bad. | 915 // bad. |
908 ASSERT_TRUE(session->proxy_service()->proxy_retry_info().empty()) | 916 ASSERT_TRUE(session->proxy_service()->proxy_retry_info().empty()) |
909 << mock_error; | 917 << mock_error; |
910 | 918 |
911 StaticSocketDataProvider socket_data_proxy_main_job; | 919 StaticSocketDataProvider socket_data_proxy_main_job; |
912 socket_data_proxy_main_job.set_connect_data( | 920 socket_data_proxy_main_job.set_connect_data( |
913 MockConnect(ASYNC, mock_error)); | 921 MockConnect(ASYNC, mock_error)); |
914 socket_factory.AddSocketDataProvider(&socket_data_proxy_main_job); | 922 socket_factory.AddSocketDataProvider(&socket_data_proxy_main_job); |
(...skipping 77 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
992 } | 1000 } |
993 } | 1001 } |
994 } | 1002 } |
995 } | 1003 } |
996 } | 1004 } |
997 | 1005 |
998 // Tests that a HTTPS proxy that supports QUIC alternative proxy server is | 1006 // Tests that a HTTPS proxy that supports QUIC alternative proxy server is |
999 // not marked as bad if only the alternative proxy server job fails. | 1007 // not marked as bad if only the alternative proxy server job fails. |
1000 TEST_F(HttpStreamFactoryTest, WithQUICAlternativeProxyNotMarkedAsBad) { | 1008 TEST_F(HttpStreamFactoryTest, WithQUICAlternativeProxyNotMarkedAsBad) { |
1001 for (auto mock_error : quic_proxy_test_mock_errors) { | 1009 for (auto mock_error : quic_proxy_test_mock_errors) { |
1002 HttpNetworkSession::Params params; | 1010 HttpNetworkSession::Params session_params; |
| 1011 HttpNetworkSession::Context session_context; |
1003 MockClientSocketFactory socket_factory; | 1012 MockClientSocketFactory socket_factory; |
1004 std::unique_ptr<ProxyService> proxy_service = | 1013 std::unique_ptr<ProxyService> proxy_service = |
1005 ProxyService::CreateFixedFromPacResult("HTTPS badproxy:99; DIRECT"); | 1014 ProxyService::CreateFixedFromPacResult("HTTPS badproxy:99; DIRECT"); |
1006 TestProxyDelegate test_proxy_delegate; | 1015 TestProxyDelegate test_proxy_delegate; |
1007 HttpServerPropertiesImpl http_server_properties; | 1016 HttpServerPropertiesImpl http_server_properties; |
1008 MockCertVerifier cert_verifier; | 1017 MockCertVerifier cert_verifier; |
1009 CTPolicyEnforcer ct_policy_enforcer; | 1018 CTPolicyEnforcer ct_policy_enforcer; |
1010 MultiLogCTVerifier ct_verifier; | 1019 MultiLogCTVerifier ct_verifier; |
1011 | 1020 |
1012 scoped_refptr<SSLConfigServiceDefaults> ssl_config_service( | 1021 scoped_refptr<SSLConfigServiceDefaults> ssl_config_service( |
1013 new SSLConfigServiceDefaults); | 1022 new SSLConfigServiceDefaults); |
1014 MockHostResolver host_resolver; | 1023 MockHostResolver host_resolver; |
1015 TransportSecurityState transport_security_state; | 1024 TransportSecurityState transport_security_state; |
1016 | 1025 |
1017 SetupForQuicAlternativeProxyTest( | 1026 SetupForQuicAlternativeProxyTest( |
1018 ¶ms, &socket_factory, proxy_service.get(), &test_proxy_delegate, | 1027 &session_params, &session_context, &socket_factory, proxy_service.get(), |
1019 &http_server_properties, &cert_verifier, &ct_policy_enforcer, | 1028 &test_proxy_delegate, &http_server_properties, &cert_verifier, |
1020 &ct_verifier, ssl_config_service.get(), &host_resolver, | 1029 &ct_policy_enforcer, &ct_verifier, ssl_config_service.get(), |
1021 &transport_security_state, true); | 1030 &host_resolver, &transport_security_state, true); |
1022 | 1031 |
1023 HostPortPair host_port_pair("badproxy", 99); | 1032 HostPortPair host_port_pair("badproxy", 99); |
1024 auto session = base::MakeUnique<HttpNetworkSession>(params); | 1033 auto session = |
| 1034 base::MakeUnique<HttpNetworkSession>(session_params, session_context); |
1025 | 1035 |
1026 // Before starting the test, verify that there are no proxies marked as | 1036 // Before starting the test, verify that there are no proxies marked as |
1027 // bad. | 1037 // bad. |
1028 ASSERT_TRUE(session->proxy_service()->proxy_retry_info().empty()) | 1038 ASSERT_TRUE(session->proxy_service()->proxy_retry_info().empty()) |
1029 << mock_error; | 1039 << mock_error; |
1030 | 1040 |
1031 StaticSocketDataProvider socket_data_proxy_main_job; | 1041 StaticSocketDataProvider socket_data_proxy_main_job; |
1032 socket_data_proxy_main_job.set_connect_data(MockConnect(ASYNC, mock_error)); | 1042 socket_data_proxy_main_job.set_connect_data(MockConnect(ASYNC, mock_error)); |
1033 socket_factory.AddSocketDataProvider(&socket_data_proxy_main_job); | 1043 socket_factory.AddSocketDataProvider(&socket_data_proxy_main_job); |
1034 | 1044 |
(...skipping 71 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1106 HostPortPair host_port_pair(alternative_service.host_port_pair()); | 1116 HostPortPair host_port_pair(alternative_service.host_port_pair()); |
1107 url::SchemeHostPort server("https", host_port_pair.host(), | 1117 url::SchemeHostPort server("https", host_port_pair.host(), |
1108 host_port_pair.port()); | 1118 host_port_pair.port()); |
1109 http_server_properties.SetAlternativeServices( | 1119 http_server_properties.SetAlternativeServices( |
1110 server, alternative_service_info_vector); | 1120 server, alternative_service_info_vector); |
1111 | 1121 |
1112 SpdySessionDependencies session_deps( | 1122 SpdySessionDependencies session_deps( |
1113 ProxyService::CreateFixed("http_proxy")); | 1123 ProxyService::CreateFixed("http_proxy")); |
1114 | 1124 |
1115 // Setup params to disable preconnect, but QUIC doesn't 0RTT. | 1125 // Setup params to disable preconnect, but QUIC doesn't 0RTT. |
1116 HttpNetworkSession::Params params = | 1126 HttpNetworkSession::Params session_params = |
1117 SpdySessionDependencies::CreateSessionParams(&session_deps); | 1127 SpdySessionDependencies::CreateSessionParams(&session_deps); |
1118 params.enable_quic = true; | 1128 session_params.enable_quic = true; |
1119 params.http_server_properties = &http_server_properties; | |
1120 | 1129 |
1121 auto session = base::MakeUnique<HttpNetworkSession>(params); | 1130 HttpNetworkSession::Context session_context = |
| 1131 SpdySessionDependencies::CreateSessionContext(&session_deps); |
| 1132 session_context.http_server_properties = &http_server_properties; |
| 1133 |
| 1134 auto session = |
| 1135 base::MakeUnique<HttpNetworkSession>(session_params, session_context); |
1122 HttpNetworkSessionPeer peer(session.get()); | 1136 HttpNetworkSessionPeer peer(session.get()); |
1123 HostPortPair proxy_host("http_proxy", 80); | 1137 HostPortPair proxy_host("http_proxy", 80); |
1124 CapturePreconnectsHttpProxySocketPool* http_proxy_pool = | 1138 CapturePreconnectsHttpProxySocketPool* http_proxy_pool = |
1125 new CapturePreconnectsHttpProxySocketPool( | 1139 new CapturePreconnectsHttpProxySocketPool( |
1126 session_deps.host_resolver.get(), session_deps.cert_verifier.get(), | 1140 session_deps.host_resolver.get(), session_deps.cert_verifier.get(), |
1127 session_deps.transport_security_state.get(), | 1141 session_deps.transport_security_state.get(), |
1128 session_deps.cert_transparency_verifier.get(), | 1142 session_deps.cert_transparency_verifier.get(), |
1129 session_deps.ct_policy_enforcer.get()); | 1143 session_deps.ct_policy_enforcer.get()); |
1130 CapturePreconnectsSSLSocketPool* ssl_conn_pool = | 1144 CapturePreconnectsSSLSocketPool* ssl_conn_pool = |
1131 new CapturePreconnectsSSLSocketPool( | 1145 new CapturePreconnectsSSLSocketPool( |
(...skipping 23 matching lines...) Expand all Loading... |
1155 ProxyService::CreateFixedFromPacResult("HTTPS myproxy.org:443"); | 1169 ProxyService::CreateFixedFromPacResult("HTTPS myproxy.org:443"); |
1156 | 1170 |
1157 // Set up the proxy server as a server that supports request priorities. | 1171 // Set up the proxy server as a server that supports request priorities. |
1158 HttpServerPropertiesImpl http_server_properties; | 1172 HttpServerPropertiesImpl http_server_properties; |
1159 if (set_http_server_properties) { | 1173 if (set_http_server_properties) { |
1160 url::SchemeHostPort spdy_server("https", "myproxy.org", 443); | 1174 url::SchemeHostPort spdy_server("https", "myproxy.org", 443); |
1161 http_server_properties.SetSupportsSpdy(spdy_server, true); | 1175 http_server_properties.SetSupportsSpdy(spdy_server, true); |
1162 } | 1176 } |
1163 | 1177 |
1164 SpdySessionDependencies session_deps; | 1178 SpdySessionDependencies session_deps; |
1165 HttpNetworkSession::Params params = | 1179 HttpNetworkSession::Params session_params = |
1166 SpdySessionDependencies::CreateSessionParams(&session_deps); | 1180 SpdySessionDependencies::CreateSessionParams(&session_deps); |
1167 params.enable_quic = true; | 1181 session_params.enable_quic = true; |
1168 params.proxy_service = proxy_service.get(); | |
1169 params.http_server_properties = &http_server_properties; | |
1170 | 1182 |
1171 auto session = base::MakeUnique<HttpNetworkSession>(params); | 1183 HttpNetworkSession::Context session_context = |
| 1184 SpdySessionDependencies::CreateSessionContext(&session_deps); |
| 1185 session_context.proxy_service = proxy_service.get(); |
| 1186 session_context.http_server_properties = &http_server_properties; |
| 1187 |
| 1188 auto session = |
| 1189 base::MakeUnique<HttpNetworkSession>(session_params, session_context); |
1172 | 1190 |
1173 HttpNetworkSessionPeer peer(session.get()); | 1191 HttpNetworkSessionPeer peer(session.get()); |
1174 HostPortPair proxy_host("myproxy.org", 443); | 1192 HostPortPair proxy_host("myproxy.org", 443); |
1175 | 1193 |
1176 for (int preconnect_request = 0; preconnect_request < 2; | 1194 for (int preconnect_request = 0; preconnect_request < 2; |
1177 ++preconnect_request) { | 1195 ++preconnect_request) { |
1178 CapturePreconnectsHttpProxySocketPool* http_proxy_pool = | 1196 CapturePreconnectsHttpProxySocketPool* http_proxy_pool = |
1179 new CapturePreconnectsHttpProxySocketPool( | 1197 new CapturePreconnectsHttpProxySocketPool( |
1180 session_deps.host_resolver.get(), | 1198 session_deps.host_resolver.get(), |
1181 session_deps.cert_verifier.get(), | 1199 session_deps.cert_verifier.get(), |
(...skipping 61 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1243 std::unique_ptr<ProxyService> proxy_service = | 1261 std::unique_ptr<ProxyService> proxy_service = |
1244 ProxyService::CreateFixedFromPacResult("HTTPS myproxy.org:443"); | 1262 ProxyService::CreateFixedFromPacResult("HTTPS myproxy.org:443"); |
1245 | 1263 |
1246 // Set up the proxy server as a server that supports request priorities. | 1264 // Set up the proxy server as a server that supports request priorities. |
1247 HttpServerPropertiesImpl http_server_properties; | 1265 HttpServerPropertiesImpl http_server_properties; |
1248 | 1266 |
1249 url::SchemeHostPort spdy_server("https", "myproxy.org", 443); | 1267 url::SchemeHostPort spdy_server("https", "myproxy.org", 443); |
1250 http_server_properties.SetSupportsSpdy(spdy_server, true); | 1268 http_server_properties.SetSupportsSpdy(spdy_server, true); |
1251 | 1269 |
1252 SpdySessionDependencies session_deps; | 1270 SpdySessionDependencies session_deps; |
1253 HttpNetworkSession::Params params = | 1271 HttpNetworkSession::Params session_params = |
1254 SpdySessionDependencies::CreateSessionParams(&session_deps); | 1272 SpdySessionDependencies::CreateSessionParams(&session_deps); |
1255 params.enable_quic = true; | 1273 session_params.enable_quic = true; |
1256 params.proxy_service = proxy_service.get(); | |
1257 params.http_server_properties = &http_server_properties; | |
1258 | 1274 |
1259 auto session = base::MakeUnique<HttpNetworkSession>(params); | 1275 HttpNetworkSession::Context session_context = |
| 1276 SpdySessionDependencies::CreateSessionContext(&session_deps); |
| 1277 session_context.proxy_service = proxy_service.get(); |
| 1278 session_context.http_server_properties = &http_server_properties; |
| 1279 |
| 1280 auto session = |
| 1281 base::MakeUnique<HttpNetworkSession>(session_params, session_context); |
1260 | 1282 |
1261 HttpNetworkSessionPeer peer(session.get()); | 1283 HttpNetworkSessionPeer peer(session.get()); |
1262 HostPortPair proxy_host("myproxy.org", 443); | 1284 HostPortPair proxy_host("myproxy.org", 443); |
1263 | 1285 |
1264 CapturePreconnectsHttpProxySocketPool* http_proxy_pool = | 1286 CapturePreconnectsHttpProxySocketPool* http_proxy_pool = |
1265 new CapturePreconnectsHttpProxySocketPool( | 1287 new CapturePreconnectsHttpProxySocketPool( |
1266 session_deps.host_resolver.get(), session_deps.cert_verifier.get(), | 1288 session_deps.host_resolver.get(), session_deps.cert_verifier.get(), |
1267 session_deps.transport_security_state.get(), | 1289 session_deps.transport_security_state.get(), |
1268 session_deps.cert_transparency_verifier.get(), | 1290 session_deps.cert_transparency_verifier.get(), |
1269 session_deps.ct_policy_enforcer.get()); | 1291 session_deps.ct_policy_enforcer.get()); |
(...skipping 875 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2145 void TearDown() override { session_.reset(); } | 2167 void TearDown() override { session_.reset(); } |
2146 | 2168 |
2147 // Disable bidirectional stream over QUIC. This should be invoked before | 2169 // Disable bidirectional stream over QUIC. This should be invoked before |
2148 // Initialize(). | 2170 // Initialize(). |
2149 void DisableQuicBidirectionalStream() { | 2171 void DisableQuicBidirectionalStream() { |
2150 params_.quic_disable_bidirectional_streams = true; | 2172 params_.quic_disable_bidirectional_streams = true; |
2151 } | 2173 } |
2152 | 2174 |
2153 void Initialize() { | 2175 void Initialize() { |
2154 params_.enable_quic = true; | 2176 params_.enable_quic = true; |
2155 params_.http_server_properties = &http_server_properties_; | 2177 params_.quic_supported_versions = test::SupportedVersions(GetParam()); |
2156 params_.quic_random = &random_generator_; | 2178 |
2157 params_.quic_clock = &clock_; | 2179 HttpNetworkSession::Context session_context; |
| 2180 session_context.http_server_properties = &http_server_properties_; |
| 2181 session_context.quic_random = &random_generator_; |
| 2182 session_context.quic_clock = &clock_; |
2158 | 2183 |
2159 // Load a certificate that is valid for *.example.org | 2184 // Load a certificate that is valid for *.example.org |
2160 scoped_refptr<X509Certificate> test_cert( | 2185 scoped_refptr<X509Certificate> test_cert( |
2161 ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem")); | 2186 ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem")); |
2162 EXPECT_TRUE(test_cert.get()); | 2187 EXPECT_TRUE(test_cert.get()); |
2163 verify_details_.cert_verify_result.verified_cert = test_cert; | 2188 verify_details_.cert_verify_result.verified_cert = test_cert; |
2164 verify_details_.cert_verify_result.is_issued_by_known_root = true; | 2189 verify_details_.cert_verify_result.is_issued_by_known_root = true; |
2165 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details_); | 2190 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details_); |
2166 crypto_client_stream_factory_.set_handshake_mode( | 2191 crypto_client_stream_factory_.set_handshake_mode( |
2167 MockCryptoClientStream::CONFIRM_HANDSHAKE); | 2192 MockCryptoClientStream::CONFIRM_HANDSHAKE); |
2168 params_.cert_verifier = &cert_verifier_; | 2193 session_context.cert_verifier = &cert_verifier_; |
2169 params_.quic_crypto_client_stream_factory = &crypto_client_stream_factory_; | 2194 session_context.quic_crypto_client_stream_factory = |
2170 params_.quic_supported_versions = test::SupportedVersions(GetParam()); | 2195 &crypto_client_stream_factory_; |
2171 params_.transport_security_state = &transport_security_state_; | 2196 session_context.transport_security_state = &transport_security_state_; |
2172 params_.cert_transparency_verifier = &ct_verifier_; | 2197 session_context.cert_transparency_verifier = &ct_verifier_; |
2173 params_.ct_policy_enforcer = &ct_policy_enforcer_; | 2198 session_context.ct_policy_enforcer = &ct_policy_enforcer_; |
2174 params_.host_resolver = &host_resolver_; | 2199 session_context.host_resolver = &host_resolver_; |
2175 params_.proxy_service = proxy_service_.get(); | 2200 session_context.proxy_service = proxy_service_.get(); |
2176 params_.ssl_config_service = ssl_config_service_.get(); | 2201 session_context.ssl_config_service = ssl_config_service_.get(); |
2177 params_.client_socket_factory = &socket_factory_; | 2202 session_context.client_socket_factory = &socket_factory_; |
2178 session_ = base::MakeUnique<HttpNetworkSession>(params_); | 2203 session_.reset(new HttpNetworkSession(params_, session_context)); |
2179 session_->quic_stream_factory()->set_require_confirmation(false); | 2204 session_->quic_stream_factory()->set_require_confirmation(false); |
2180 } | 2205 } |
2181 | 2206 |
2182 void AddQuicAlternativeService() { | 2207 void AddQuicAlternativeService() { |
2183 const AlternativeService alternative_service(kProtoQUIC, "www.example.org", | 2208 const AlternativeService alternative_service(kProtoQUIC, "www.example.org", |
2184 443); | 2209 443); |
2185 AlternativeServiceInfoVector alternative_service_info_vector; | 2210 AlternativeServiceInfoVector alternative_service_info_vector; |
2186 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); | 2211 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
2187 alternative_service_info_vector.push_back( | 2212 alternative_service_info_vector.push_back( |
2188 AlternativeServiceInfo(alternative_service, expiration)); | 2213 AlternativeServiceInfo(alternative_service, expiration)); |
(...skipping 295 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2484 HttpNetworkSession::NORMAL_SOCKET_POOL))); | 2509 HttpNetworkSession::NORMAL_SOCKET_POOL))); |
2485 EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetTransportSocketPool( | 2510 EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetTransportSocketPool( |
2486 HttpNetworkSession::WEBSOCKET_SOCKET_POOL))); | 2511 HttpNetworkSession::WEBSOCKET_SOCKET_POOL))); |
2487 EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSSLSocketPool( | 2512 EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSSLSocketPool( |
2488 HttpNetworkSession::WEBSOCKET_SOCKET_POOL))); | 2513 HttpNetworkSession::WEBSOCKET_SOCKET_POOL))); |
2489 } | 2514 } |
2490 | 2515 |
2491 } // namespace | 2516 } // namespace |
2492 | 2517 |
2493 } // namespace net | 2518 } // namespace net |
OLD | NEW |