OLD | NEW |
1 // Copyright (c) 2010 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2010 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_proxy_client_socket_pool.h" | 5 #include "net/http/http_proxy_client_socket_pool.h" |
6 | 6 |
7 #include "base/callback.h" | 7 #include "base/callback.h" |
8 #include "base/compiler_specific.h" | 8 #include "base/compiler_specific.h" |
| 9 #include "base/string_util.h" |
9 #include "base/time.h" | 10 #include "base/time.h" |
10 #include "net/base/auth.h" | 11 #include "net/base/auth.h" |
11 #include "net/base/mock_host_resolver.h" | 12 #include "net/base/mock_host_resolver.h" |
12 #include "net/base/net_errors.h" | 13 #include "net/base/net_errors.h" |
13 #include "net/base/test_completion_callback.h" | 14 #include "net/base/test_completion_callback.h" |
14 #include "net/base/ssl_config_service_defaults.h" | 15 #include "net/base/ssl_config_service_defaults.h" |
15 #include "net/http/http_auth_controller.h" | 16 #include "net/http/http_auth_handler_factory.h" |
16 #include "net/http/http_network_session.h" | 17 #include "net/http/http_network_session.h" |
17 #include "net/http/http_request_headers.h" | 18 #include "net/http/http_request_headers.h" |
18 #include "net/http/http_response_headers.h" | 19 #include "net/http/http_response_headers.h" |
19 #include "net/socket/client_socket_factory.h" | 20 #include "net/socket/client_socket_factory.h" |
20 #include "net/socket/client_socket_handle.h" | 21 #include "net/socket/client_socket_handle.h" |
21 #include "net/socket/client_socket_pool_histograms.h" | 22 #include "net/socket/client_socket_pool_histograms.h" |
22 #include "net/socket/socket_test_util.h" | 23 #include "net/socket/socket_test_util.h" |
| 24 #include "net/spdy/spdy_session_pool.h" |
23 #include "testing/gtest/include/gtest/gtest.h" | 25 #include "testing/gtest/include/gtest/gtest.h" |
24 | 26 |
25 namespace net { | 27 namespace net { |
26 | 28 |
27 namespace { | 29 namespace { |
28 | 30 |
29 const int kMaxSockets = 32; | 31 const int kMaxSockets = 32; |
30 const int kMaxSocketsPerGroup = 6; | 32 const int kMaxSocketsPerGroup = 6; |
31 | 33 |
32 class SSLClientSocketPoolTest : public ClientSocketPoolTest { | 34 class SSLClientSocketPoolTest : public ClientSocketPoolTest { |
33 protected: | 35 protected: |
34 SSLClientSocketPoolTest() | 36 SSLClientSocketPoolTest() |
35 : direct_tcp_socket_params_(new TCPSocketParams( | 37 : http_auth_handler_factory_(HttpAuthHandlerFactory::CreateDefault()), |
| 38 session_(new HttpNetworkSession(new MockHostResolver, |
| 39 ProxyService::CreateNull(), |
| 40 &socket_factory_, |
| 41 new SSLConfigServiceDefaults, |
| 42 new SpdySessionPool(), |
| 43 http_auth_handler_factory_.get(), |
| 44 NULL, |
| 45 NULL)), |
| 46 direct_tcp_socket_params_(new TCPSocketParams( |
36 HostPortPair("host", 443), MEDIUM, GURL(), false)), | 47 HostPortPair("host", 443), MEDIUM, GURL(), false)), |
37 tcp_socket_pool_(new MockTCPClientSocketPool( | 48 tcp_socket_pool_(new MockTCPClientSocketPool( |
38 kMaxSockets, | 49 kMaxSockets, |
39 kMaxSocketsPerGroup, | 50 kMaxSocketsPerGroup, |
40 make_scoped_refptr(new ClientSocketPoolHistograms("MockTCP")), | 51 make_scoped_refptr(new ClientSocketPoolHistograms("MockTCP")), |
41 &socket_factory_)), | 52 &socket_factory_)), |
42 proxy_tcp_socket_params_(new TCPSocketParams( | 53 proxy_tcp_socket_params_(new TCPSocketParams( |
43 HostPortPair("proxy", 443), MEDIUM, GURL(), false)), | 54 HostPortPair("proxy", 443), MEDIUM, GURL(), false)), |
| 55 http_proxy_socket_params_(new HttpProxySocketParams( |
| 56 proxy_tcp_socket_params_, GURL("http://host"), |
| 57 HostPortPair("host", 80), session_, true)), |
44 http_proxy_socket_pool_(new HttpProxyClientSocketPool( | 58 http_proxy_socket_pool_(new HttpProxyClientSocketPool( |
45 kMaxSockets, | 59 kMaxSockets, |
46 kMaxSocketsPerGroup, | 60 kMaxSocketsPerGroup, |
47 make_scoped_refptr(new ClientSocketPoolHistograms("MockHttpProxy")), | 61 make_scoped_refptr(new ClientSocketPoolHistograms("MockHttpProxy")), |
48 new MockHostResolver, | 62 new MockHostResolver, |
49 tcp_socket_pool_, | 63 tcp_socket_pool_, |
50 NULL)), | 64 NULL)), |
51 socks_socket_params_(new SOCKSSocketParams( | 65 socks_socket_params_(new SOCKSSocketParams( |
52 proxy_tcp_socket_params_, true, HostPortPair("sockshost", 443), | 66 proxy_tcp_socket_params_, true, HostPortPair("sockshost", 443), |
53 MEDIUM, GURL())), | 67 MEDIUM, GURL())), |
(...skipping 13 matching lines...) Expand all Loading... |
67 kMaxSocketsPerGroup, | 81 kMaxSocketsPerGroup, |
68 make_scoped_refptr(new ClientSocketPoolHistograms("SSLUnitTest")), | 82 make_scoped_refptr(new ClientSocketPoolHistograms("SSLUnitTest")), |
69 NULL, | 83 NULL, |
70 &socket_factory_, | 84 &socket_factory_, |
71 tcp_pool ? tcp_socket_pool_ : NULL, | 85 tcp_pool ? tcp_socket_pool_ : NULL, |
72 http_proxy_pool ? http_proxy_socket_pool_ : NULL, | 86 http_proxy_pool ? http_proxy_socket_pool_ : NULL, |
73 socks_pool ? socks_socket_pool_ : NULL, | 87 socks_pool ? socks_socket_pool_ : NULL, |
74 NULL); | 88 NULL); |
75 } | 89 } |
76 | 90 |
77 scoped_refptr<SSLSocketParams> SSLParams( | 91 scoped_refptr<SSLSocketParams> SSLParams(ProxyServer::Scheme proxy, |
78 ProxyServer::Scheme proxy, struct MockHttpAuthControllerData* auth_data, | 92 bool want_spdy_over_npn) { |
79 size_t auth_data_len, bool want_spdy_over_ssl, bool want_spdy_over_npn) { | |
80 scoped_refptr<HttpProxySocketParams> http_proxy_params; | |
81 if (proxy == ProxyServer::SCHEME_HTTP) { | |
82 scoped_refptr<MockHttpAuthController> auth_controller = | |
83 new MockHttpAuthController(); | |
84 auth_controller->SetMockAuthControllerData(auth_data, auth_data_len); | |
85 http_proxy_params = new HttpProxySocketParams(proxy_tcp_socket_params_, | |
86 GURL("http://host"), | |
87 HostPortPair("host", 80), | |
88 auth_controller, true); | |
89 } | |
90 | |
91 return make_scoped_refptr(new SSLSocketParams( | 93 return make_scoped_refptr(new SSLSocketParams( |
92 proxy == ProxyServer::SCHEME_DIRECT ? direct_tcp_socket_params_ : NULL, | 94 proxy == ProxyServer::SCHEME_DIRECT ? direct_tcp_socket_params_ : NULL, |
93 http_proxy_params, | 95 proxy == ProxyServer::SCHEME_HTTP ? http_proxy_socket_params_ : NULL, |
94 proxy == ProxyServer::SCHEME_SOCKS5 ? socks_socket_params_ : NULL, | 96 proxy == ProxyServer::SCHEME_SOCKS5 ? socks_socket_params_ : NULL, |
95 proxy, | 97 proxy, |
96 "host", | 98 "host", |
97 ssl_config_, | 99 ssl_config_, |
98 0, | 100 0, |
99 want_spdy_over_ssl, | 101 false, |
100 want_spdy_over_npn)); | 102 want_spdy_over_npn)); |
101 } | 103 } |
102 | 104 |
| 105 void AddAuthToCache() { |
| 106 const string16 kFoo(ASCIIToUTF16("foo")); |
| 107 const string16 kBar(ASCIIToUTF16("bar")); |
| 108 session_->auth_cache()->Add(GURL("http://proxy:443/"), "MyRealm1", "Basic", |
| 109 "Basic realm=MyRealm1", kFoo, kBar, "/"); |
| 110 } |
| 111 |
103 MockClientSocketFactory socket_factory_; | 112 MockClientSocketFactory socket_factory_; |
| 113 scoped_ptr<HttpAuthHandlerFactory> http_auth_handler_factory_; |
| 114 scoped_refptr<HttpNetworkSession> session_; |
104 | 115 |
105 scoped_refptr<TCPSocketParams> direct_tcp_socket_params_; | 116 scoped_refptr<TCPSocketParams> direct_tcp_socket_params_; |
106 scoped_refptr<MockTCPClientSocketPool> tcp_socket_pool_; | 117 scoped_refptr<MockTCPClientSocketPool> tcp_socket_pool_; |
107 | 118 |
108 scoped_refptr<TCPSocketParams> proxy_tcp_socket_params_; | 119 scoped_refptr<TCPSocketParams> proxy_tcp_socket_params_; |
109 scoped_refptr<HttpProxySocketParams> http_proxy_socket_params_; | 120 scoped_refptr<HttpProxySocketParams> http_proxy_socket_params_; |
110 scoped_refptr<HttpProxyClientSocketPool> http_proxy_socket_pool_; | 121 scoped_refptr<HttpProxyClientSocketPool> http_proxy_socket_pool_; |
111 | 122 |
112 scoped_refptr<SOCKSSocketParams> socks_socket_params_; | 123 scoped_refptr<SOCKSSocketParams> socks_socket_params_; |
113 scoped_refptr<MockSOCKSClientSocketPool> socks_socket_pool_; | 124 scoped_refptr<MockSOCKSClientSocketPool> socks_socket_pool_; |
114 | 125 |
115 SSLConfig ssl_config_; | 126 SSLConfig ssl_config_; |
116 scoped_refptr<SSLClientSocketPool> pool_; | 127 scoped_refptr<SSLClientSocketPool> pool_; |
117 }; | 128 }; |
118 | 129 |
119 TEST_F(SSLClientSocketPoolTest, TCPFail) { | 130 TEST_F(SSLClientSocketPoolTest, TCPFail) { |
120 StaticSocketDataProvider data; | 131 StaticSocketDataProvider data; |
121 data.set_connect_data(MockConnect(false, ERR_CONNECTION_FAILED)); | 132 data.set_connect_data(MockConnect(false, ERR_CONNECTION_FAILED)); |
122 socket_factory_.AddSocketDataProvider(&data); | 133 socket_factory_.AddSocketDataProvider(&data); |
123 | 134 |
124 CreatePool(true /* tcp pool */, false, false); | 135 CreatePool(true /* tcp pool */, false, false); |
125 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 136 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
126 NULL, 0, false, false); | 137 false); |
127 | 138 |
128 ClientSocketHandle handle; | 139 ClientSocketHandle handle; |
129 int rv = handle.Init("a", params, MEDIUM, NULL, pool_, BoundNetLog()); | 140 int rv = handle.Init("a", params, MEDIUM, NULL, pool_, BoundNetLog()); |
130 EXPECT_EQ(ERR_CONNECTION_FAILED, rv); | 141 EXPECT_EQ(ERR_CONNECTION_FAILED, rv); |
131 EXPECT_FALSE(handle.is_initialized()); | 142 EXPECT_FALSE(handle.is_initialized()); |
132 EXPECT_FALSE(handle.socket()); | 143 EXPECT_FALSE(handle.socket()); |
133 EXPECT_FALSE(handle.is_ssl_error()); | 144 EXPECT_FALSE(handle.is_ssl_error()); |
134 } | 145 } |
135 | 146 |
136 TEST_F(SSLClientSocketPoolTest, TCPFailAsync) { | 147 TEST_F(SSLClientSocketPoolTest, TCPFailAsync) { |
137 StaticSocketDataProvider data; | 148 StaticSocketDataProvider data; |
138 data.set_connect_data(MockConnect(true, ERR_CONNECTION_FAILED)); | 149 data.set_connect_data(MockConnect(true, ERR_CONNECTION_FAILED)); |
139 socket_factory_.AddSocketDataProvider(&data); | 150 socket_factory_.AddSocketDataProvider(&data); |
140 | 151 |
141 CreatePool(true /* tcp pool */, false, false); | 152 CreatePool(true /* tcp pool */, false, false); |
142 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 153 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
143 NULL, 0, false, false); | 154 false); |
144 | 155 |
145 ClientSocketHandle handle; | 156 ClientSocketHandle handle; |
146 TestCompletionCallback callback; | 157 TestCompletionCallback callback; |
147 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); | 158 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); |
148 EXPECT_EQ(ERR_IO_PENDING, rv); | 159 EXPECT_EQ(ERR_IO_PENDING, rv); |
149 EXPECT_FALSE(handle.is_initialized()); | 160 EXPECT_FALSE(handle.is_initialized()); |
150 EXPECT_FALSE(handle.socket()); | 161 EXPECT_FALSE(handle.socket()); |
151 | 162 |
152 EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult()); | 163 EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult()); |
153 EXPECT_FALSE(handle.is_initialized()); | 164 EXPECT_FALSE(handle.is_initialized()); |
154 EXPECT_FALSE(handle.socket()); | 165 EXPECT_FALSE(handle.socket()); |
155 EXPECT_FALSE(handle.is_ssl_error()); | 166 EXPECT_FALSE(handle.is_ssl_error()); |
156 } | 167 } |
157 | 168 |
158 TEST_F(SSLClientSocketPoolTest, BasicDirect) { | 169 TEST_F(SSLClientSocketPoolTest, BasicDirect) { |
159 StaticSocketDataProvider data; | 170 StaticSocketDataProvider data; |
160 data.set_connect_data(MockConnect(false, OK)); | 171 data.set_connect_data(MockConnect(false, OK)); |
161 socket_factory_.AddSocketDataProvider(&data); | 172 socket_factory_.AddSocketDataProvider(&data); |
162 SSLSocketDataProvider ssl(false, OK); | 173 SSLSocketDataProvider ssl(false, OK); |
163 socket_factory_.AddSSLSocketDataProvider(&ssl); | 174 socket_factory_.AddSSLSocketDataProvider(&ssl); |
164 | 175 |
165 CreatePool(true /* tcp pool */, false, false); | 176 CreatePool(true /* tcp pool */, false, false); |
166 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 177 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
167 NULL, 0, false, false); | 178 false); |
168 | 179 |
169 ClientSocketHandle handle; | 180 ClientSocketHandle handle; |
170 TestCompletionCallback callback; | 181 TestCompletionCallback callback; |
171 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); | 182 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); |
172 EXPECT_EQ(OK, rv); | 183 EXPECT_EQ(OK, rv); |
173 EXPECT_TRUE(handle.is_initialized()); | 184 EXPECT_TRUE(handle.is_initialized()); |
174 EXPECT_TRUE(handle.socket()); | 185 EXPECT_TRUE(handle.socket()); |
175 } | 186 } |
176 | 187 |
177 TEST_F(SSLClientSocketPoolTest, BasicDirectAsync) { | 188 TEST_F(SSLClientSocketPoolTest, BasicDirectAsync) { |
178 StaticSocketDataProvider data; | 189 StaticSocketDataProvider data; |
179 socket_factory_.AddSocketDataProvider(&data); | 190 socket_factory_.AddSocketDataProvider(&data); |
180 SSLSocketDataProvider ssl(true, OK); | 191 SSLSocketDataProvider ssl(true, OK); |
181 socket_factory_.AddSSLSocketDataProvider(&ssl); | 192 socket_factory_.AddSSLSocketDataProvider(&ssl); |
182 | 193 |
183 CreatePool(true /* tcp pool */, false, false); | 194 CreatePool(true /* tcp pool */, false, false); |
184 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 195 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
185 NULL, 0, false, false); | 196 false); |
186 | 197 |
187 ClientSocketHandle handle; | 198 ClientSocketHandle handle; |
188 TestCompletionCallback callback; | 199 TestCompletionCallback callback; |
189 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); | 200 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); |
190 EXPECT_EQ(ERR_IO_PENDING, rv); | 201 EXPECT_EQ(ERR_IO_PENDING, rv); |
191 EXPECT_FALSE(handle.is_initialized()); | 202 EXPECT_FALSE(handle.is_initialized()); |
192 EXPECT_FALSE(handle.socket()); | 203 EXPECT_FALSE(handle.socket()); |
193 | 204 |
194 EXPECT_EQ(OK, callback.WaitForResult()); | 205 EXPECT_EQ(OK, callback.WaitForResult()); |
195 EXPECT_TRUE(handle.is_initialized()); | 206 EXPECT_TRUE(handle.is_initialized()); |
196 EXPECT_TRUE(handle.socket()); | 207 EXPECT_TRUE(handle.socket()); |
197 } | 208 } |
198 | 209 |
199 TEST_F(SSLClientSocketPoolTest, DirectCertError) { | 210 TEST_F(SSLClientSocketPoolTest, DirectCertError) { |
200 StaticSocketDataProvider data; | 211 StaticSocketDataProvider data; |
201 socket_factory_.AddSocketDataProvider(&data); | 212 socket_factory_.AddSocketDataProvider(&data); |
202 SSLSocketDataProvider ssl(true, ERR_CERT_COMMON_NAME_INVALID); | 213 SSLSocketDataProvider ssl(true, ERR_CERT_COMMON_NAME_INVALID); |
203 socket_factory_.AddSSLSocketDataProvider(&ssl); | 214 socket_factory_.AddSSLSocketDataProvider(&ssl); |
204 | 215 |
205 CreatePool(true /* tcp pool */, false, false); | 216 CreatePool(true /* tcp pool */, false, false); |
206 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 217 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
207 NULL, 0, false, false); | 218 false); |
208 | 219 |
209 ClientSocketHandle handle; | 220 ClientSocketHandle handle; |
210 TestCompletionCallback callback; | 221 TestCompletionCallback callback; |
211 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); | 222 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); |
212 EXPECT_EQ(ERR_IO_PENDING, rv); | 223 EXPECT_EQ(ERR_IO_PENDING, rv); |
213 EXPECT_FALSE(handle.is_initialized()); | 224 EXPECT_FALSE(handle.is_initialized()); |
214 EXPECT_FALSE(handle.socket()); | 225 EXPECT_FALSE(handle.socket()); |
215 | 226 |
216 EXPECT_EQ(ERR_CERT_COMMON_NAME_INVALID, callback.WaitForResult()); | 227 EXPECT_EQ(ERR_CERT_COMMON_NAME_INVALID, callback.WaitForResult()); |
217 EXPECT_TRUE(handle.is_initialized()); | 228 EXPECT_TRUE(handle.is_initialized()); |
218 EXPECT_TRUE(handle.socket()); | 229 EXPECT_TRUE(handle.socket()); |
219 } | 230 } |
220 | 231 |
221 TEST_F(SSLClientSocketPoolTest, DirectSSLError) { | 232 TEST_F(SSLClientSocketPoolTest, DirectSSLError) { |
222 StaticSocketDataProvider data; | 233 StaticSocketDataProvider data; |
223 socket_factory_.AddSocketDataProvider(&data); | 234 socket_factory_.AddSocketDataProvider(&data); |
224 SSLSocketDataProvider ssl(true, ERR_SSL_PROTOCOL_ERROR); | 235 SSLSocketDataProvider ssl(true, ERR_SSL_PROTOCOL_ERROR); |
225 socket_factory_.AddSSLSocketDataProvider(&ssl); | 236 socket_factory_.AddSSLSocketDataProvider(&ssl); |
226 | 237 |
227 CreatePool(true /* tcp pool */, false, false); | 238 CreatePool(true /* tcp pool */, false, false); |
228 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 239 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
229 NULL, 0, false, false); | 240 false); |
230 | 241 |
231 ClientSocketHandle handle; | 242 ClientSocketHandle handle; |
232 TestCompletionCallback callback; | 243 TestCompletionCallback callback; |
233 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); | 244 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); |
234 EXPECT_EQ(ERR_IO_PENDING, rv); | 245 EXPECT_EQ(ERR_IO_PENDING, rv); |
235 EXPECT_FALSE(handle.is_initialized()); | 246 EXPECT_FALSE(handle.is_initialized()); |
236 EXPECT_FALSE(handle.socket()); | 247 EXPECT_FALSE(handle.socket()); |
237 | 248 |
238 EXPECT_EQ(ERR_SSL_PROTOCOL_ERROR, callback.WaitForResult()); | 249 EXPECT_EQ(ERR_SSL_PROTOCOL_ERROR, callback.WaitForResult()); |
239 EXPECT_FALSE(handle.is_initialized()); | 250 EXPECT_FALSE(handle.is_initialized()); |
240 EXPECT_FALSE(handle.socket()); | 251 EXPECT_FALSE(handle.socket()); |
241 EXPECT_TRUE(handle.is_ssl_error()); | 252 EXPECT_TRUE(handle.is_ssl_error()); |
242 } | 253 } |
243 | 254 |
244 TEST_F(SSLClientSocketPoolTest, DirectWithNPN) { | 255 TEST_F(SSLClientSocketPoolTest, DirectWithNPN) { |
245 StaticSocketDataProvider data; | 256 StaticSocketDataProvider data; |
246 socket_factory_.AddSocketDataProvider(&data); | 257 socket_factory_.AddSocketDataProvider(&data); |
247 SSLSocketDataProvider ssl(true, OK); | 258 SSLSocketDataProvider ssl(true, OK); |
248 ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated; | 259 ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated; |
249 ssl.next_proto = "http/1.1"; | 260 ssl.next_proto = "http/1.1"; |
250 socket_factory_.AddSSLSocketDataProvider(&ssl); | 261 socket_factory_.AddSSLSocketDataProvider(&ssl); |
251 | 262 |
252 CreatePool(true /* tcp pool */, false, false); | 263 CreatePool(true /* tcp pool */, false, false); |
253 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 264 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
254 NULL, 0, false, false); | 265 false); |
255 | 266 |
256 ClientSocketHandle handle; | 267 ClientSocketHandle handle; |
257 TestCompletionCallback callback; | 268 TestCompletionCallback callback; |
258 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); | 269 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); |
259 EXPECT_EQ(ERR_IO_PENDING, rv); | 270 EXPECT_EQ(ERR_IO_PENDING, rv); |
260 EXPECT_FALSE(handle.is_initialized()); | 271 EXPECT_FALSE(handle.is_initialized()); |
261 EXPECT_FALSE(handle.socket()); | 272 EXPECT_FALSE(handle.socket()); |
262 | 273 |
263 EXPECT_EQ(OK, callback.WaitForResult()); | 274 EXPECT_EQ(OK, callback.WaitForResult()); |
264 EXPECT_TRUE(handle.is_initialized()); | 275 EXPECT_TRUE(handle.is_initialized()); |
265 EXPECT_TRUE(handle.socket()); | 276 EXPECT_TRUE(handle.socket()); |
266 SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(handle.socket()); | 277 SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(handle.socket()); |
267 EXPECT_TRUE(ssl_socket->wasNpnNegotiated()); | 278 EXPECT_TRUE(ssl_socket->wasNpnNegotiated()); |
268 } | 279 } |
269 | 280 |
270 TEST_F(SSLClientSocketPoolTest, DirectNoSPDY) { | 281 TEST_F(SSLClientSocketPoolTest, DirectNoSPDY) { |
271 StaticSocketDataProvider data; | 282 StaticSocketDataProvider data; |
272 socket_factory_.AddSocketDataProvider(&data); | 283 socket_factory_.AddSocketDataProvider(&data); |
273 SSLSocketDataProvider ssl(true, OK); | 284 SSLSocketDataProvider ssl(true, OK); |
274 ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated; | 285 ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated; |
275 ssl.next_proto = "http/1.1"; | 286 ssl.next_proto = "http/1.1"; |
276 socket_factory_.AddSSLSocketDataProvider(&ssl); | 287 socket_factory_.AddSSLSocketDataProvider(&ssl); |
277 | 288 |
278 CreatePool(true /* tcp pool */, false, false); | 289 CreatePool(true /* tcp pool */, false, false); |
279 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 290 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
280 NULL, 0, false, true); | 291 true); |
281 | 292 |
282 ClientSocketHandle handle; | 293 ClientSocketHandle handle; |
283 TestCompletionCallback callback; | 294 TestCompletionCallback callback; |
284 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); | 295 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); |
285 EXPECT_EQ(ERR_IO_PENDING, rv); | 296 EXPECT_EQ(ERR_IO_PENDING, rv); |
286 EXPECT_FALSE(handle.is_initialized()); | 297 EXPECT_FALSE(handle.is_initialized()); |
287 EXPECT_FALSE(handle.socket()); | 298 EXPECT_FALSE(handle.socket()); |
288 | 299 |
289 EXPECT_EQ(ERR_NPN_NEGOTIATION_FAILED, callback.WaitForResult()); | 300 EXPECT_EQ(ERR_NPN_NEGOTIATION_FAILED, callback.WaitForResult()); |
290 EXPECT_FALSE(handle.is_initialized()); | 301 EXPECT_FALSE(handle.is_initialized()); |
291 EXPECT_FALSE(handle.socket()); | 302 EXPECT_FALSE(handle.socket()); |
292 EXPECT_TRUE(handle.is_ssl_error()); | 303 EXPECT_TRUE(handle.is_ssl_error()); |
293 } | 304 } |
294 | 305 |
295 TEST_F(SSLClientSocketPoolTest, DirectGotSPDY) { | 306 TEST_F(SSLClientSocketPoolTest, DirectGotSPDY) { |
296 StaticSocketDataProvider data; | 307 StaticSocketDataProvider data; |
297 socket_factory_.AddSocketDataProvider(&data); | 308 socket_factory_.AddSocketDataProvider(&data); |
298 SSLSocketDataProvider ssl(true, OK); | 309 SSLSocketDataProvider ssl(true, OK); |
299 ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated; | 310 ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated; |
300 ssl.next_proto = "spdy/1"; | 311 ssl.next_proto = "spdy/1"; |
301 socket_factory_.AddSSLSocketDataProvider(&ssl); | 312 socket_factory_.AddSSLSocketDataProvider(&ssl); |
302 | 313 |
303 CreatePool(true /* tcp pool */, false, false); | 314 CreatePool(true /* tcp pool */, false, false); |
304 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 315 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
305 NULL, 0, false, true); | 316 true); |
306 | 317 |
307 ClientSocketHandle handle; | 318 ClientSocketHandle handle; |
308 TestCompletionCallback callback; | 319 TestCompletionCallback callback; |
309 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); | 320 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); |
310 EXPECT_EQ(ERR_IO_PENDING, rv); | 321 EXPECT_EQ(ERR_IO_PENDING, rv); |
311 EXPECT_FALSE(handle.is_initialized()); | 322 EXPECT_FALSE(handle.is_initialized()); |
312 EXPECT_FALSE(handle.socket()); | 323 EXPECT_FALSE(handle.socket()); |
313 | 324 |
314 EXPECT_EQ(OK, callback.WaitForResult()); | 325 EXPECT_EQ(OK, callback.WaitForResult()); |
315 EXPECT_TRUE(handle.is_initialized()); | 326 EXPECT_TRUE(handle.is_initialized()); |
(...skipping 10 matching lines...) Expand all Loading... |
326 TEST_F(SSLClientSocketPoolTest, DirectGotBonusSPDY) { | 337 TEST_F(SSLClientSocketPoolTest, DirectGotBonusSPDY) { |
327 StaticSocketDataProvider data; | 338 StaticSocketDataProvider data; |
328 socket_factory_.AddSocketDataProvider(&data); | 339 socket_factory_.AddSocketDataProvider(&data); |
329 SSLSocketDataProvider ssl(true, OK); | 340 SSLSocketDataProvider ssl(true, OK); |
330 ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated; | 341 ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated; |
331 ssl.next_proto = "spdy/1"; | 342 ssl.next_proto = "spdy/1"; |
332 socket_factory_.AddSSLSocketDataProvider(&ssl); | 343 socket_factory_.AddSSLSocketDataProvider(&ssl); |
333 | 344 |
334 CreatePool(true /* tcp pool */, false, false); | 345 CreatePool(true /* tcp pool */, false, false); |
335 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 346 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
336 NULL, 0, false, true); | 347 true); |
337 | 348 |
338 ClientSocketHandle handle; | 349 ClientSocketHandle handle; |
339 TestCompletionCallback callback; | 350 TestCompletionCallback callback; |
340 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); | 351 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); |
341 EXPECT_EQ(ERR_IO_PENDING, rv); | 352 EXPECT_EQ(ERR_IO_PENDING, rv); |
342 EXPECT_FALSE(handle.is_initialized()); | 353 EXPECT_FALSE(handle.is_initialized()); |
343 EXPECT_FALSE(handle.socket()); | 354 EXPECT_FALSE(handle.socket()); |
344 | 355 |
345 EXPECT_EQ(OK, callback.WaitForResult()); | 356 EXPECT_EQ(OK, callback.WaitForResult()); |
346 EXPECT_TRUE(handle.is_initialized()); | 357 EXPECT_TRUE(handle.is_initialized()); |
347 EXPECT_TRUE(handle.socket()); | 358 EXPECT_TRUE(handle.socket()); |
348 | 359 |
349 SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(handle.socket()); | 360 SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(handle.socket()); |
350 EXPECT_TRUE(ssl_socket->wasNpnNegotiated()); | 361 EXPECT_TRUE(ssl_socket->wasNpnNegotiated()); |
351 std::string proto; | 362 std::string proto; |
352 ssl_socket->GetNextProto(&proto); | 363 ssl_socket->GetNextProto(&proto); |
353 EXPECT_EQ(SSLClientSocket::NextProtoFromString(proto), | 364 EXPECT_EQ(SSLClientSocket::NextProtoFromString(proto), |
354 SSLClientSocket::kProtoSPDY1); | 365 SSLClientSocket::kProtoSPDY1); |
355 } | 366 } |
356 | 367 |
357 TEST_F(SSLClientSocketPoolTest, SOCKSFail) { | 368 TEST_F(SSLClientSocketPoolTest, SOCKSFail) { |
358 StaticSocketDataProvider data; | 369 StaticSocketDataProvider data; |
359 data.set_connect_data(MockConnect(false, ERR_CONNECTION_FAILED)); | 370 data.set_connect_data(MockConnect(false, ERR_CONNECTION_FAILED)); |
360 socket_factory_.AddSocketDataProvider(&data); | 371 socket_factory_.AddSocketDataProvider(&data); |
361 | 372 |
362 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | 373 CreatePool(false, true /* http proxy pool */, true /* socks pool */); |
363 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5, | 374 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5, |
364 NULL, 0, false, false); | 375 false); |
365 | 376 |
366 ClientSocketHandle handle; | 377 ClientSocketHandle handle; |
367 TestCompletionCallback callback; | 378 TestCompletionCallback callback; |
368 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); | 379 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); |
369 EXPECT_EQ(ERR_CONNECTION_FAILED, rv); | 380 EXPECT_EQ(ERR_CONNECTION_FAILED, rv); |
370 EXPECT_FALSE(handle.is_initialized()); | 381 EXPECT_FALSE(handle.is_initialized()); |
371 EXPECT_FALSE(handle.socket()); | 382 EXPECT_FALSE(handle.socket()); |
372 EXPECT_FALSE(handle.is_ssl_error()); | 383 EXPECT_FALSE(handle.is_ssl_error()); |
373 } | 384 } |
374 | 385 |
375 TEST_F(SSLClientSocketPoolTest, SOCKSFailAsync) { | 386 TEST_F(SSLClientSocketPoolTest, SOCKSFailAsync) { |
376 StaticSocketDataProvider data; | 387 StaticSocketDataProvider data; |
377 data.set_connect_data(MockConnect(true, ERR_CONNECTION_FAILED)); | 388 data.set_connect_data(MockConnect(true, ERR_CONNECTION_FAILED)); |
378 socket_factory_.AddSocketDataProvider(&data); | 389 socket_factory_.AddSocketDataProvider(&data); |
379 | 390 |
380 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | 391 CreatePool(false, true /* http proxy pool */, true /* socks pool */); |
381 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5, | 392 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5, |
382 NULL, 0, false, false); | 393 false); |
383 | 394 |
384 ClientSocketHandle handle; | 395 ClientSocketHandle handle; |
385 TestCompletionCallback callback; | 396 TestCompletionCallback callback; |
386 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); | 397 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); |
387 EXPECT_EQ(ERR_IO_PENDING, rv); | 398 EXPECT_EQ(ERR_IO_PENDING, rv); |
388 EXPECT_FALSE(handle.is_initialized()); | 399 EXPECT_FALSE(handle.is_initialized()); |
389 EXPECT_FALSE(handle.socket()); | 400 EXPECT_FALSE(handle.socket()); |
390 | 401 |
391 EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult()); | 402 EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult()); |
392 EXPECT_FALSE(handle.is_initialized()); | 403 EXPECT_FALSE(handle.is_initialized()); |
393 EXPECT_FALSE(handle.socket()); | 404 EXPECT_FALSE(handle.socket()); |
394 EXPECT_FALSE(handle.is_ssl_error()); | 405 EXPECT_FALSE(handle.is_ssl_error()); |
395 } | 406 } |
396 | 407 |
397 TEST_F(SSLClientSocketPoolTest, SOCKSBasic) { | 408 TEST_F(SSLClientSocketPoolTest, SOCKSBasic) { |
398 StaticSocketDataProvider data; | 409 StaticSocketDataProvider data; |
399 data.set_connect_data(MockConnect(false, OK)); | 410 data.set_connect_data(MockConnect(false, OK)); |
400 socket_factory_.AddSocketDataProvider(&data); | 411 socket_factory_.AddSocketDataProvider(&data); |
401 SSLSocketDataProvider ssl(false, OK); | 412 SSLSocketDataProvider ssl(false, OK); |
402 socket_factory_.AddSSLSocketDataProvider(&ssl); | 413 socket_factory_.AddSSLSocketDataProvider(&ssl); |
403 | 414 |
404 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | 415 CreatePool(false, true /* http proxy pool */, true /* socks pool */); |
405 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5, | 416 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5, |
406 NULL, 0, false, false); | 417 false); |
407 | 418 |
408 ClientSocketHandle handle; | 419 ClientSocketHandle handle; |
409 TestCompletionCallback callback; | 420 TestCompletionCallback callback; |
410 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); | 421 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); |
411 EXPECT_EQ(OK, rv); | 422 EXPECT_EQ(OK, rv); |
412 EXPECT_TRUE(handle.is_initialized()); | 423 EXPECT_TRUE(handle.is_initialized()); |
413 EXPECT_TRUE(handle.socket()); | 424 EXPECT_TRUE(handle.socket()); |
414 } | 425 } |
415 | 426 |
416 TEST_F(SSLClientSocketPoolTest, SOCKSBasicAsync) { | 427 TEST_F(SSLClientSocketPoolTest, SOCKSBasicAsync) { |
417 StaticSocketDataProvider data; | 428 StaticSocketDataProvider data; |
418 socket_factory_.AddSocketDataProvider(&data); | 429 socket_factory_.AddSocketDataProvider(&data); |
419 SSLSocketDataProvider ssl(true, OK); | 430 SSLSocketDataProvider ssl(true, OK); |
420 socket_factory_.AddSSLSocketDataProvider(&ssl); | 431 socket_factory_.AddSSLSocketDataProvider(&ssl); |
421 | 432 |
422 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | 433 CreatePool(false, true /* http proxy pool */, true /* socks pool */); |
423 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5, | 434 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5, |
424 NULL, 0, false, false); | 435 false); |
425 | 436 |
426 ClientSocketHandle handle; | 437 ClientSocketHandle handle; |
427 TestCompletionCallback callback; | 438 TestCompletionCallback callback; |
428 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); | 439 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); |
429 EXPECT_EQ(ERR_IO_PENDING, rv); | 440 EXPECT_EQ(ERR_IO_PENDING, rv); |
430 EXPECT_FALSE(handle.is_initialized()); | 441 EXPECT_FALSE(handle.is_initialized()); |
431 EXPECT_FALSE(handle.socket()); | 442 EXPECT_FALSE(handle.socket()); |
432 | 443 |
433 EXPECT_EQ(OK, callback.WaitForResult()); | 444 EXPECT_EQ(OK, callback.WaitForResult()); |
434 EXPECT_TRUE(handle.is_initialized()); | 445 EXPECT_TRUE(handle.is_initialized()); |
435 EXPECT_TRUE(handle.socket()); | 446 EXPECT_TRUE(handle.socket()); |
436 } | 447 } |
437 | 448 |
438 TEST_F(SSLClientSocketPoolTest, HttpProxyFail) { | 449 TEST_F(SSLClientSocketPoolTest, HttpProxyFail) { |
439 StaticSocketDataProvider data; | 450 StaticSocketDataProvider data; |
440 data.set_connect_data(MockConnect(false, ERR_CONNECTION_FAILED)); | 451 data.set_connect_data(MockConnect(false, ERR_CONNECTION_FAILED)); |
441 socket_factory_.AddSocketDataProvider(&data); | 452 socket_factory_.AddSocketDataProvider(&data); |
442 | 453 |
443 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | 454 CreatePool(false, true /* http proxy pool */, true /* socks pool */); |
444 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, | 455 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, |
445 NULL, 0, false, false); | 456 false); |
446 | 457 |
447 ClientSocketHandle handle; | 458 ClientSocketHandle handle; |
448 TestCompletionCallback callback; | 459 TestCompletionCallback callback; |
449 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); | 460 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); |
450 EXPECT_EQ(ERR_CONNECTION_FAILED, rv); | 461 EXPECT_EQ(ERR_CONNECTION_FAILED, rv); |
451 EXPECT_FALSE(handle.is_initialized()); | 462 EXPECT_FALSE(handle.is_initialized()); |
452 EXPECT_FALSE(handle.socket()); | 463 EXPECT_FALSE(handle.socket()); |
453 EXPECT_FALSE(handle.is_ssl_error()); | 464 EXPECT_FALSE(handle.is_ssl_error()); |
454 } | 465 } |
455 | 466 |
456 TEST_F(SSLClientSocketPoolTest, HttpProxyFailAsync) { | 467 TEST_F(SSLClientSocketPoolTest, HttpProxyFailAsync) { |
457 StaticSocketDataProvider data; | 468 StaticSocketDataProvider data; |
458 data.set_connect_data(MockConnect(true, ERR_CONNECTION_FAILED)); | 469 data.set_connect_data(MockConnect(true, ERR_CONNECTION_FAILED)); |
459 socket_factory_.AddSocketDataProvider(&data); | 470 socket_factory_.AddSocketDataProvider(&data); |
460 | 471 |
461 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | 472 CreatePool(false, true /* http proxy pool */, true /* socks pool */); |
462 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, | 473 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, |
463 NULL, 0, false, false); | 474 false); |
464 | 475 |
465 ClientSocketHandle handle; | 476 ClientSocketHandle handle; |
466 TestCompletionCallback callback; | 477 TestCompletionCallback callback; |
467 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); | 478 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); |
468 EXPECT_EQ(ERR_IO_PENDING, rv); | 479 EXPECT_EQ(ERR_IO_PENDING, rv); |
469 EXPECT_FALSE(handle.is_initialized()); | 480 EXPECT_FALSE(handle.is_initialized()); |
470 EXPECT_FALSE(handle.socket()); | 481 EXPECT_FALSE(handle.socket()); |
471 | 482 |
472 EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult()); | 483 EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult()); |
473 EXPECT_FALSE(handle.is_initialized()); | 484 EXPECT_FALSE(handle.is_initialized()); |
474 EXPECT_FALSE(handle.socket()); | 485 EXPECT_FALSE(handle.socket()); |
475 EXPECT_FALSE(handle.is_ssl_error()); | 486 EXPECT_FALSE(handle.is_ssl_error()); |
476 } | 487 } |
477 | 488 |
478 TEST_F(SSLClientSocketPoolTest, HttpProxyBasic) { | 489 TEST_F(SSLClientSocketPoolTest, HttpProxyBasic) { |
479 MockWrite writes[] = { | 490 MockWrite writes[] = { |
480 MockWrite(false, | 491 MockWrite(false, |
481 "CONNECT host:80 HTTP/1.1\r\n" | 492 "CONNECT host:80 HTTP/1.1\r\n" |
482 "Host: host\r\n" | 493 "Host: host\r\n" |
483 "Proxy-Connection: keep-alive\r\n" | 494 "Proxy-Connection: keep-alive\r\n" |
484 "Proxy-Authorization: Basic Zm9vOmJheg==\r\n\r\n"), | 495 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), |
485 }; | 496 }; |
486 MockRead reads[] = { | 497 MockRead reads[] = { |
487 MockRead(false, "HTTP/1.1 200 Connection Established\r\n\r\n"), | 498 MockRead(false, "HTTP/1.1 200 Connection Established\r\n\r\n"), |
488 }; | 499 }; |
489 StaticSocketDataProvider data(reads, arraysize(reads), writes, | 500 StaticSocketDataProvider data(reads, arraysize(reads), writes, |
490 arraysize(writes)); | 501 arraysize(writes)); |
491 data.set_connect_data(MockConnect(false, OK)); | 502 data.set_connect_data(MockConnect(false, OK)); |
492 socket_factory_.AddSocketDataProvider(&data); | 503 socket_factory_.AddSocketDataProvider(&data); |
493 MockHttpAuthControllerData auth_data[] = { | 504 AddAuthToCache(); |
494 MockHttpAuthControllerData("Proxy-Authorization: Basic Zm9vOmJheg=="), | |
495 }; | |
496 SSLSocketDataProvider ssl(false, OK); | 505 SSLSocketDataProvider ssl(false, OK); |
497 socket_factory_.AddSSLSocketDataProvider(&ssl); | 506 socket_factory_.AddSSLSocketDataProvider(&ssl); |
498 | 507 |
499 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | 508 CreatePool(false, true /* http proxy pool */, true /* socks pool */); |
500 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, | 509 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, |
501 auth_data, | |
502 arraysize(auth_data), | |
503 false, | |
504 false); | 510 false); |
505 | 511 |
506 ClientSocketHandle handle; | 512 ClientSocketHandle handle; |
507 TestCompletionCallback callback; | 513 TestCompletionCallback callback; |
508 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); | 514 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); |
509 EXPECT_EQ(OK, rv); | 515 EXPECT_EQ(OK, rv); |
510 EXPECT_TRUE(handle.is_initialized()); | 516 EXPECT_TRUE(handle.is_initialized()); |
511 EXPECT_TRUE(handle.socket()); | 517 EXPECT_TRUE(handle.socket()); |
512 } | 518 } |
513 | 519 |
514 TEST_F(SSLClientSocketPoolTest, HttpProxyBasicAsync) { | 520 TEST_F(SSLClientSocketPoolTest, HttpProxyBasicAsync) { |
515 MockWrite writes[] = { | 521 MockWrite writes[] = { |
516 MockWrite("CONNECT host:80 HTTP/1.1\r\n" | 522 MockWrite("CONNECT host:80 HTTP/1.1\r\n" |
517 "Host: host\r\n" | 523 "Host: host\r\n" |
518 "Proxy-Connection: keep-alive\r\n" | 524 "Proxy-Connection: keep-alive\r\n" |
519 "Proxy-Authorization: Basic Zm9vOmJheg==\r\n\r\n"), | 525 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), |
520 }; | 526 }; |
521 MockRead reads[] = { | 527 MockRead reads[] = { |
522 MockRead("HTTP/1.1 200 Connection Established\r\n\r\n"), | 528 MockRead("HTTP/1.1 200 Connection Established\r\n\r\n"), |
523 }; | 529 }; |
524 StaticSocketDataProvider data(reads, arraysize(reads), writes, | 530 StaticSocketDataProvider data(reads, arraysize(reads), writes, |
525 arraysize(writes)); | 531 arraysize(writes)); |
526 socket_factory_.AddSocketDataProvider(&data); | 532 socket_factory_.AddSocketDataProvider(&data); |
527 MockHttpAuthControllerData auth_data[] = { | 533 AddAuthToCache(); |
528 MockHttpAuthControllerData("Proxy-Authorization: Basic Zm9vOmJheg=="), | |
529 }; | |
530 SSLSocketDataProvider ssl(true, OK); | 534 SSLSocketDataProvider ssl(true, OK); |
531 socket_factory_.AddSSLSocketDataProvider(&ssl); | 535 socket_factory_.AddSSLSocketDataProvider(&ssl); |
532 | 536 |
533 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | 537 CreatePool(false, true /* http proxy pool */, true /* socks pool */); |
534 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, | 538 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, |
535 auth_data, | |
536 arraysize(auth_data), | |
537 false, | |
538 false); | 539 false); |
539 | 540 |
540 ClientSocketHandle handle; | 541 ClientSocketHandle handle; |
541 TestCompletionCallback callback; | 542 TestCompletionCallback callback; |
542 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); | 543 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); |
543 EXPECT_EQ(ERR_IO_PENDING, rv); | 544 EXPECT_EQ(ERR_IO_PENDING, rv); |
544 EXPECT_FALSE(handle.is_initialized()); | 545 EXPECT_FALSE(handle.is_initialized()); |
545 EXPECT_FALSE(handle.socket()); | 546 EXPECT_FALSE(handle.socket()); |
546 | 547 |
547 EXPECT_EQ(OK, callback.WaitForResult()); | 548 EXPECT_EQ(OK, callback.WaitForResult()); |
548 EXPECT_TRUE(handle.is_initialized()); | 549 EXPECT_TRUE(handle.is_initialized()); |
549 EXPECT_TRUE(handle.socket()); | 550 EXPECT_TRUE(handle.socket()); |
550 } | 551 } |
551 | 552 |
552 TEST_F(SSLClientSocketPoolTest, NeedProxyAuth) { | 553 TEST_F(SSLClientSocketPoolTest, NeedProxyAuth) { |
553 MockWrite writes[] = { | 554 MockWrite writes[] = { |
554 MockWrite("CONNECT host:80 HTTP/1.1\r\n" | 555 MockWrite("CONNECT host:80 HTTP/1.1\r\n" |
555 "Host: host\r\n" | 556 "Host: host\r\n" |
556 "Proxy-Connection: keep-alive\r\n\r\n"), | 557 "Proxy-Connection: keep-alive\r\n\r\n"), |
557 }; | 558 }; |
558 MockRead reads[] = { | 559 MockRead reads[] = { |
559 MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"), | 560 MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"), |
560 MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"), | 561 MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"), |
561 MockRead("Content-Length: 10\r\n\r\n"), | 562 MockRead("Content-Length: 10\r\n\r\n"), |
562 MockRead("0123456789"), | 563 MockRead("0123456789"), |
563 }; | 564 }; |
564 StaticSocketDataProvider data(reads, arraysize(reads), writes, | 565 StaticSocketDataProvider data(reads, arraysize(reads), writes, |
565 arraysize(writes)); | 566 arraysize(writes)); |
566 socket_factory_.AddSocketDataProvider(&data); | 567 socket_factory_.AddSocketDataProvider(&data); |
567 MockHttpAuthControllerData auth_data[] = { | |
568 MockHttpAuthControllerData(""), | |
569 }; | |
570 SSLSocketDataProvider ssl(true, OK); | 568 SSLSocketDataProvider ssl(true, OK); |
571 socket_factory_.AddSSLSocketDataProvider(&ssl); | 569 socket_factory_.AddSSLSocketDataProvider(&ssl); |
572 | 570 |
573 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | 571 CreatePool(false, true /* http proxy pool */, true /* socks pool */); |
574 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, | 572 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, |
575 auth_data, | |
576 arraysize(auth_data), | |
577 false, | |
578 false); | 573 false); |
579 | 574 |
580 ClientSocketHandle handle; | 575 ClientSocketHandle handle; |
581 TestCompletionCallback callback; | |
582 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); | |
583 EXPECT_EQ(ERR_IO_PENDING, rv); | |
584 EXPECT_FALSE(handle.is_initialized()); | |
585 EXPECT_FALSE(handle.socket()); | |
586 | |
587 EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, callback.WaitForResult()); | |
588 EXPECT_FALSE(handle.is_initialized()); | |
589 EXPECT_FALSE(handle.socket()); | |
590 EXPECT_FALSE(handle.is_ssl_error()); | |
591 const HttpResponseInfo& tunnel_info = handle.ssl_error_response_info(); | |
592 EXPECT_EQ(tunnel_info.headers->response_code(), 407); | |
593 } | |
594 | |
595 TEST_F(SSLClientSocketPoolTest, DoProxyAuth) { | |
596 MockWrite writes[] = { | |
597 MockWrite("CONNECT host:80 HTTP/1.1\r\n" | |
598 "Host: host\r\n" | |
599 "Proxy-Connection: keep-alive\r\n\r\n"), | |
600 MockWrite("CONNECT host:80 HTTP/1.1\r\n" | |
601 "Host: host\r\n" | |
602 "Proxy-Connection: keep-alive\r\n" | |
603 "Proxy-Authorization: Basic Zm9vOmJheg==\r\n\r\n"), | |
604 }; | |
605 MockRead reads[] = { | |
606 MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"), | |
607 MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"), | |
608 MockRead("Content-Length: 10\r\n\r\n"), | |
609 MockRead("0123456789"), | |
610 MockRead("HTTP/1.1 200 Connection Established\r\n\r\n"), | |
611 }; | |
612 StaticSocketDataProvider data(reads, arraysize(reads), writes, | |
613 arraysize(writes)); | |
614 socket_factory_.AddSocketDataProvider(&data); | |
615 MockHttpAuthControllerData auth_data[] = { | |
616 MockHttpAuthControllerData(""), | |
617 MockHttpAuthControllerData("Proxy-Authorization: Basic Zm9vOmJheg=="), | |
618 }; | |
619 SSLSocketDataProvider ssl(true, OK); | |
620 socket_factory_.AddSSLSocketDataProvider(&ssl); | |
621 | |
622 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | |
623 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, | |
624 auth_data, | |
625 arraysize(auth_data), | |
626 false, | |
627 false); | |
628 | |
629 ClientSocketHandle handle; | |
630 TestCompletionCallback callback; | |
631 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); | |
632 EXPECT_EQ(ERR_IO_PENDING, rv); | |
633 EXPECT_FALSE(handle.is_initialized()); | |
634 EXPECT_FALSE(handle.socket()); | |
635 | |
636 EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, callback.WaitForResult()); | |
637 EXPECT_FALSE(handle.is_initialized()); | |
638 EXPECT_FALSE(handle.socket()); | |
639 EXPECT_FALSE(handle.is_ssl_error()); | |
640 const HttpResponseInfo& tunnel_info = handle.ssl_error_response_info(); | |
641 EXPECT_EQ(tunnel_info.headers->response_code(), 407); | |
642 | |
643 params->http_proxy_params()->auth_controller()->ResetAuth(string16(), | |
644 string16()); | |
645 rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); | |
646 EXPECT_EQ(ERR_IO_PENDING, rv); | |
647 EXPECT_FALSE(handle.is_initialized()); | |
648 EXPECT_FALSE(handle.socket()); | |
649 | |
650 // Test that http://crbug.com/49325 doesn't regress. | |
651 EXPECT_EQ(handle.GetLoadState(), LOAD_STATE_ESTABLISHING_PROXY_TUNNEL); | |
652 | |
653 EXPECT_EQ(OK, callback.WaitForResult()); | |
654 EXPECT_TRUE(handle.is_initialized()); | |
655 EXPECT_TRUE(handle.socket()); | |
656 } | |
657 | |
658 TEST_F(SSLClientSocketPoolTest, DoProxyAuthNoKeepAlive) { | |
659 MockWrite writes1[] = { | |
660 MockWrite("CONNECT host:80 HTTP/1.1\r\n" | |
661 "Host: host\r\n" | |
662 "Proxy-Connection: keep-alive\r\n\r\n"), | |
663 }; | |
664 MockWrite writes2[] = { | |
665 MockWrite("CONNECT host:80 HTTP/1.1\r\n" | |
666 "Host: host\r\n" | |
667 "Proxy-Connection: keep-alive\r\n" | |
668 "Proxy-Authorization: Basic Zm9vOmJheg==\r\n\r\n"), | |
669 }; | |
670 MockRead reads1[] = { | |
671 MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"), | |
672 MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n\r\n"), | |
673 MockRead("Content0123456789"), | |
674 }; | |
675 MockRead reads2[] = { | |
676 MockRead("HTTP/1.1 200 Connection Established\r\n\r\n"), | |
677 }; | |
678 StaticSocketDataProvider data1(reads1, arraysize(reads1), writes1, | |
679 arraysize(writes1)); | |
680 socket_factory_.AddSocketDataProvider(&data1); | |
681 StaticSocketDataProvider data2(reads2, arraysize(reads2), writes2, | |
682 arraysize(writes2)); | |
683 socket_factory_.AddSocketDataProvider(&data2); | |
684 MockHttpAuthControllerData auth_data[] = { | |
685 MockHttpAuthControllerData(""), | |
686 MockHttpAuthControllerData("Proxy-Authorization: Basic Zm9vOmJheg=="), | |
687 }; | |
688 SSLSocketDataProvider ssl(true, OK); | |
689 socket_factory_.AddSSLSocketDataProvider(&ssl); | |
690 | |
691 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | |
692 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, | |
693 auth_data, | |
694 arraysize(auth_data), | |
695 false, | |
696 false); | |
697 | |
698 ClientSocketHandle handle; | |
699 TestCompletionCallback callback; | 576 TestCompletionCallback callback; |
700 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); | 577 int rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); |
701 EXPECT_EQ(ERR_IO_PENDING, rv); | 578 EXPECT_EQ(ERR_IO_PENDING, rv); |
702 EXPECT_FALSE(handle.is_initialized()); | 579 EXPECT_FALSE(handle.is_initialized()); |
703 EXPECT_FALSE(handle.socket()); | 580 EXPECT_FALSE(handle.socket()); |
704 | 581 |
705 EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, callback.WaitForResult()); | 582 EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, callback.WaitForResult()); |
706 EXPECT_FALSE(handle.is_initialized()); | 583 EXPECT_FALSE(handle.is_initialized()); |
707 EXPECT_FALSE(handle.socket()); | 584 EXPECT_FALSE(handle.socket()); |
708 EXPECT_FALSE(handle.is_ssl_error()); | 585 EXPECT_FALSE(handle.is_ssl_error()); |
709 const HttpResponseInfo& tunnel_info = handle.ssl_error_response_info(); | 586 const HttpResponseInfo& tunnel_info = handle.ssl_error_response_info(); |
710 EXPECT_EQ(tunnel_info.headers->response_code(), 407); | 587 EXPECT_EQ(tunnel_info.headers->response_code(), 407); |
711 | 588 scoped_ptr<ClientSocketHandle> tunnel_handle( |
712 params->http_proxy_params()->auth_controller()->ResetAuth(string16(), | 589 handle.release_pending_http_proxy_connection()); |
713 string16()); | 590 EXPECT_TRUE(tunnel_handle->socket()); |
714 rv = handle.Init("a", params, MEDIUM, &callback, pool_, BoundNetLog()); | 591 EXPECT_FALSE(tunnel_handle->socket()->IsConnected()); |
715 EXPECT_EQ(ERR_IO_PENDING, rv); | |
716 EXPECT_FALSE(handle.is_initialized()); | |
717 EXPECT_FALSE(handle.socket()); | |
718 | |
719 EXPECT_EQ(OK, callback.WaitForResult()); | |
720 EXPECT_TRUE(handle.is_initialized()); | |
721 EXPECT_TRUE(handle.socket()); | |
722 } | 592 } |
723 | 593 |
724 // It would be nice to also test the timeouts in SSLClientSocketPool. | 594 // It would be nice to also test the timeouts in SSLClientSocketPool. |
725 | 595 |
726 } // namespace | 596 } // namespace |
727 | 597 |
728 } // namespace net | 598 } // namespace net |
OLD | NEW |