OLD | NEW |
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2011 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/string_util.h" |
10 #include "base/time.h" | 10 #include "base/time.h" |
(...skipping 165 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
176 TEST_F(SSLClientSocketPoolTest, TCPFail) { | 176 TEST_F(SSLClientSocketPoolTest, TCPFail) { |
177 StaticSocketDataProvider data; | 177 StaticSocketDataProvider data; |
178 data.set_connect_data(MockConnect(false, ERR_CONNECTION_FAILED)); | 178 data.set_connect_data(MockConnect(false, ERR_CONNECTION_FAILED)); |
179 socket_factory_.AddSocketDataProvider(&data); | 179 socket_factory_.AddSocketDataProvider(&data); |
180 | 180 |
181 CreatePool(true /* tcp pool */, false, false); | 181 CreatePool(true /* tcp pool */, false, false); |
182 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 182 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
183 false); | 183 false); |
184 | 184 |
185 ClientSocketHandle handle; | 185 ClientSocketHandle handle; |
186 int rv = handle.Init("a", params, MEDIUM, NULL, pool_.get(), BoundNetLog()); | 186 int rv = handle.Init("a", params, MEDIUM, CompletionCallback(), pool_.get(), |
| 187 BoundNetLog()); |
187 EXPECT_EQ(ERR_CONNECTION_FAILED, rv); | 188 EXPECT_EQ(ERR_CONNECTION_FAILED, rv); |
188 EXPECT_FALSE(handle.is_initialized()); | 189 EXPECT_FALSE(handle.is_initialized()); |
189 EXPECT_FALSE(handle.socket()); | 190 EXPECT_FALSE(handle.socket()); |
190 EXPECT_FALSE(handle.is_ssl_error()); | 191 EXPECT_FALSE(handle.is_ssl_error()); |
191 } | 192 } |
192 | 193 |
193 TEST_F(SSLClientSocketPoolTest, TCPFailAsync) { | 194 TEST_F(SSLClientSocketPoolTest, TCPFailAsync) { |
194 StaticSocketDataProvider data; | 195 StaticSocketDataProvider data; |
195 data.set_connect_data(MockConnect(true, ERR_CONNECTION_FAILED)); | 196 data.set_connect_data(MockConnect(true, ERR_CONNECTION_FAILED)); |
196 socket_factory_.AddSocketDataProvider(&data); | 197 socket_factory_.AddSocketDataProvider(&data); |
197 | 198 |
198 CreatePool(true /* tcp pool */, false, false); | 199 CreatePool(true /* tcp pool */, false, false); |
199 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 200 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
200 false); | 201 false); |
201 | 202 |
202 ClientSocketHandle handle; | 203 ClientSocketHandle handle; |
203 TestOldCompletionCallback callback; | 204 TestCompletionCallback callback; |
204 int rv = handle.Init( | 205 int rv = handle.Init( |
205 "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog()); | 206 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); |
206 EXPECT_EQ(ERR_IO_PENDING, rv); | 207 EXPECT_EQ(ERR_IO_PENDING, rv); |
207 EXPECT_FALSE(handle.is_initialized()); | 208 EXPECT_FALSE(handle.is_initialized()); |
208 EXPECT_FALSE(handle.socket()); | 209 EXPECT_FALSE(handle.socket()); |
209 | 210 |
210 EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult()); | 211 EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult()); |
211 EXPECT_FALSE(handle.is_initialized()); | 212 EXPECT_FALSE(handle.is_initialized()); |
212 EXPECT_FALSE(handle.socket()); | 213 EXPECT_FALSE(handle.socket()); |
213 EXPECT_FALSE(handle.is_ssl_error()); | 214 EXPECT_FALSE(handle.is_ssl_error()); |
214 } | 215 } |
215 | 216 |
216 TEST_F(SSLClientSocketPoolTest, BasicDirect) { | 217 TEST_F(SSLClientSocketPoolTest, BasicDirect) { |
217 StaticSocketDataProvider data; | 218 StaticSocketDataProvider data; |
218 data.set_connect_data(MockConnect(false, OK)); | 219 data.set_connect_data(MockConnect(false, OK)); |
219 socket_factory_.AddSocketDataProvider(&data); | 220 socket_factory_.AddSocketDataProvider(&data); |
220 SSLSocketDataProvider ssl(false, OK); | 221 SSLSocketDataProvider ssl(false, OK); |
221 socket_factory_.AddSSLSocketDataProvider(&ssl); | 222 socket_factory_.AddSSLSocketDataProvider(&ssl); |
222 | 223 |
223 CreatePool(true /* tcp pool */, false, false); | 224 CreatePool(true /* tcp pool */, false, false); |
224 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 225 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
225 false); | 226 false); |
226 | 227 |
227 ClientSocketHandle handle; | 228 ClientSocketHandle handle; |
228 TestOldCompletionCallback callback; | 229 TestCompletionCallback callback; |
229 int rv = handle.Init( | 230 int rv = handle.Init( |
230 "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog()); | 231 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); |
231 EXPECT_EQ(OK, rv); | 232 EXPECT_EQ(OK, rv); |
232 EXPECT_TRUE(handle.is_initialized()); | 233 EXPECT_TRUE(handle.is_initialized()); |
233 EXPECT_TRUE(handle.socket()); | 234 EXPECT_TRUE(handle.socket()); |
234 } | 235 } |
235 | 236 |
236 TEST_F(SSLClientSocketPoolTest, BasicDirectAsync) { | 237 TEST_F(SSLClientSocketPoolTest, BasicDirectAsync) { |
237 StaticSocketDataProvider data; | 238 StaticSocketDataProvider data; |
238 socket_factory_.AddSocketDataProvider(&data); | 239 socket_factory_.AddSocketDataProvider(&data); |
239 SSLSocketDataProvider ssl(true, OK); | 240 SSLSocketDataProvider ssl(true, OK); |
240 socket_factory_.AddSSLSocketDataProvider(&ssl); | 241 socket_factory_.AddSSLSocketDataProvider(&ssl); |
241 | 242 |
242 CreatePool(true /* tcp pool */, false, false); | 243 CreatePool(true /* tcp pool */, false, false); |
243 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 244 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
244 false); | 245 false); |
245 | 246 |
246 ClientSocketHandle handle; | 247 ClientSocketHandle handle; |
247 TestOldCompletionCallback callback; | 248 TestCompletionCallback callback; |
248 int rv = handle.Init( | 249 int rv = handle.Init( |
249 "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog()); | 250 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); |
250 EXPECT_EQ(ERR_IO_PENDING, rv); | 251 EXPECT_EQ(ERR_IO_PENDING, rv); |
251 EXPECT_FALSE(handle.is_initialized()); | 252 EXPECT_FALSE(handle.is_initialized()); |
252 EXPECT_FALSE(handle.socket()); | 253 EXPECT_FALSE(handle.socket()); |
253 | 254 |
254 EXPECT_EQ(OK, callback.WaitForResult()); | 255 EXPECT_EQ(OK, callback.WaitForResult()); |
255 EXPECT_TRUE(handle.is_initialized()); | 256 EXPECT_TRUE(handle.is_initialized()); |
256 EXPECT_TRUE(handle.socket()); | 257 EXPECT_TRUE(handle.socket()); |
257 } | 258 } |
258 | 259 |
259 TEST_F(SSLClientSocketPoolTest, DirectCertError) { | 260 TEST_F(SSLClientSocketPoolTest, DirectCertError) { |
260 StaticSocketDataProvider data; | 261 StaticSocketDataProvider data; |
261 socket_factory_.AddSocketDataProvider(&data); | 262 socket_factory_.AddSocketDataProvider(&data); |
262 SSLSocketDataProvider ssl(true, ERR_CERT_COMMON_NAME_INVALID); | 263 SSLSocketDataProvider ssl(true, ERR_CERT_COMMON_NAME_INVALID); |
263 socket_factory_.AddSSLSocketDataProvider(&ssl); | 264 socket_factory_.AddSSLSocketDataProvider(&ssl); |
264 | 265 |
265 CreatePool(true /* tcp pool */, false, false); | 266 CreatePool(true /* tcp pool */, false, false); |
266 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 267 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
267 false); | 268 false); |
268 | 269 |
269 ClientSocketHandle handle; | 270 ClientSocketHandle handle; |
270 TestOldCompletionCallback callback; | 271 TestCompletionCallback callback; |
271 int rv = handle.Init( | 272 int rv = handle.Init( |
272 "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog()); | 273 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); |
273 EXPECT_EQ(ERR_IO_PENDING, rv); | 274 EXPECT_EQ(ERR_IO_PENDING, rv); |
274 EXPECT_FALSE(handle.is_initialized()); | 275 EXPECT_FALSE(handle.is_initialized()); |
275 EXPECT_FALSE(handle.socket()); | 276 EXPECT_FALSE(handle.socket()); |
276 | 277 |
277 EXPECT_EQ(ERR_CERT_COMMON_NAME_INVALID, callback.WaitForResult()); | 278 EXPECT_EQ(ERR_CERT_COMMON_NAME_INVALID, callback.WaitForResult()); |
278 EXPECT_TRUE(handle.is_initialized()); | 279 EXPECT_TRUE(handle.is_initialized()); |
279 EXPECT_TRUE(handle.socket()); | 280 EXPECT_TRUE(handle.socket()); |
280 } | 281 } |
281 | 282 |
282 TEST_F(SSLClientSocketPoolTest, DirectSSLError) { | 283 TEST_F(SSLClientSocketPoolTest, DirectSSLError) { |
283 StaticSocketDataProvider data; | 284 StaticSocketDataProvider data; |
284 socket_factory_.AddSocketDataProvider(&data); | 285 socket_factory_.AddSocketDataProvider(&data); |
285 SSLSocketDataProvider ssl(true, ERR_SSL_PROTOCOL_ERROR); | 286 SSLSocketDataProvider ssl(true, ERR_SSL_PROTOCOL_ERROR); |
286 socket_factory_.AddSSLSocketDataProvider(&ssl); | 287 socket_factory_.AddSSLSocketDataProvider(&ssl); |
287 | 288 |
288 CreatePool(true /* tcp pool */, false, false); | 289 CreatePool(true /* tcp pool */, false, false); |
289 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 290 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
290 false); | 291 false); |
291 | 292 |
292 ClientSocketHandle handle; | 293 ClientSocketHandle handle; |
293 TestOldCompletionCallback callback; | 294 TestCompletionCallback callback; |
294 int rv = handle.Init( | 295 int rv = handle.Init( |
295 "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog()); | 296 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); |
296 EXPECT_EQ(ERR_IO_PENDING, rv); | 297 EXPECT_EQ(ERR_IO_PENDING, rv); |
297 EXPECT_FALSE(handle.is_initialized()); | 298 EXPECT_FALSE(handle.is_initialized()); |
298 EXPECT_FALSE(handle.socket()); | 299 EXPECT_FALSE(handle.socket()); |
299 | 300 |
300 EXPECT_EQ(ERR_SSL_PROTOCOL_ERROR, callback.WaitForResult()); | 301 EXPECT_EQ(ERR_SSL_PROTOCOL_ERROR, callback.WaitForResult()); |
301 EXPECT_FALSE(handle.is_initialized()); | 302 EXPECT_FALSE(handle.is_initialized()); |
302 EXPECT_FALSE(handle.socket()); | 303 EXPECT_FALSE(handle.socket()); |
303 EXPECT_TRUE(handle.is_ssl_error()); | 304 EXPECT_TRUE(handle.is_ssl_error()); |
304 } | 305 } |
305 | 306 |
306 TEST_F(SSLClientSocketPoolTest, DirectWithNPN) { | 307 TEST_F(SSLClientSocketPoolTest, DirectWithNPN) { |
307 StaticSocketDataProvider data; | 308 StaticSocketDataProvider data; |
308 socket_factory_.AddSocketDataProvider(&data); | 309 socket_factory_.AddSocketDataProvider(&data); |
309 SSLSocketDataProvider ssl(true, OK); | 310 SSLSocketDataProvider ssl(true, OK); |
310 ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated; | 311 ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated; |
311 ssl.next_proto = "http/1.1"; | 312 ssl.next_proto = "http/1.1"; |
312 socket_factory_.AddSSLSocketDataProvider(&ssl); | 313 socket_factory_.AddSSLSocketDataProvider(&ssl); |
313 | 314 |
314 CreatePool(true /* tcp pool */, false, false); | 315 CreatePool(true /* tcp pool */, false, false); |
315 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 316 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
316 false); | 317 false); |
317 | 318 |
318 ClientSocketHandle handle; | 319 ClientSocketHandle handle; |
319 TestOldCompletionCallback callback; | 320 TestCompletionCallback callback; |
320 int rv = handle.Init( | 321 int rv = handle.Init( |
321 "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog()); | 322 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); |
322 EXPECT_EQ(ERR_IO_PENDING, rv); | 323 EXPECT_EQ(ERR_IO_PENDING, rv); |
323 EXPECT_FALSE(handle.is_initialized()); | 324 EXPECT_FALSE(handle.is_initialized()); |
324 EXPECT_FALSE(handle.socket()); | 325 EXPECT_FALSE(handle.socket()); |
325 | 326 |
326 EXPECT_EQ(OK, callback.WaitForResult()); | 327 EXPECT_EQ(OK, callback.WaitForResult()); |
327 EXPECT_TRUE(handle.is_initialized()); | 328 EXPECT_TRUE(handle.is_initialized()); |
328 EXPECT_TRUE(handle.socket()); | 329 EXPECT_TRUE(handle.socket()); |
329 SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(handle.socket()); | 330 SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(handle.socket()); |
330 EXPECT_TRUE(ssl_socket->was_npn_negotiated()); | 331 EXPECT_TRUE(ssl_socket->was_npn_negotiated()); |
331 } | 332 } |
332 | 333 |
333 TEST_F(SSLClientSocketPoolTest, DirectNoSPDY) { | 334 TEST_F(SSLClientSocketPoolTest, DirectNoSPDY) { |
334 StaticSocketDataProvider data; | 335 StaticSocketDataProvider data; |
335 socket_factory_.AddSocketDataProvider(&data); | 336 socket_factory_.AddSocketDataProvider(&data); |
336 SSLSocketDataProvider ssl(true, OK); | 337 SSLSocketDataProvider ssl(true, OK); |
337 ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated; | 338 ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated; |
338 ssl.next_proto = "http/1.1"; | 339 ssl.next_proto = "http/1.1"; |
339 socket_factory_.AddSSLSocketDataProvider(&ssl); | 340 socket_factory_.AddSSLSocketDataProvider(&ssl); |
340 | 341 |
341 CreatePool(true /* tcp pool */, false, false); | 342 CreatePool(true /* tcp pool */, false, false); |
342 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 343 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
343 true); | 344 true); |
344 | 345 |
345 ClientSocketHandle handle; | 346 ClientSocketHandle handle; |
346 TestOldCompletionCallback callback; | 347 TestCompletionCallback callback; |
347 int rv = handle.Init( | 348 int rv = handle.Init( |
348 "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog()); | 349 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); |
349 EXPECT_EQ(ERR_IO_PENDING, rv); | 350 EXPECT_EQ(ERR_IO_PENDING, rv); |
350 EXPECT_FALSE(handle.is_initialized()); | 351 EXPECT_FALSE(handle.is_initialized()); |
351 EXPECT_FALSE(handle.socket()); | 352 EXPECT_FALSE(handle.socket()); |
352 | 353 |
353 EXPECT_EQ(ERR_NPN_NEGOTIATION_FAILED, callback.WaitForResult()); | 354 EXPECT_EQ(ERR_NPN_NEGOTIATION_FAILED, callback.WaitForResult()); |
354 EXPECT_FALSE(handle.is_initialized()); | 355 EXPECT_FALSE(handle.is_initialized()); |
355 EXPECT_FALSE(handle.socket()); | 356 EXPECT_FALSE(handle.socket()); |
356 EXPECT_TRUE(handle.is_ssl_error()); | 357 EXPECT_TRUE(handle.is_ssl_error()); |
357 } | 358 } |
358 | 359 |
359 TEST_F(SSLClientSocketPoolTest, DirectGotSPDY) { | 360 TEST_F(SSLClientSocketPoolTest, DirectGotSPDY) { |
360 StaticSocketDataProvider data; | 361 StaticSocketDataProvider data; |
361 socket_factory_.AddSocketDataProvider(&data); | 362 socket_factory_.AddSocketDataProvider(&data); |
362 SSLSocketDataProvider ssl(true, OK); | 363 SSLSocketDataProvider ssl(true, OK); |
363 ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated; | 364 ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated; |
364 ssl.next_proto = "spdy/2"; | 365 ssl.next_proto = "spdy/2"; |
365 socket_factory_.AddSSLSocketDataProvider(&ssl); | 366 socket_factory_.AddSSLSocketDataProvider(&ssl); |
366 | 367 |
367 CreatePool(true /* tcp pool */, false, false); | 368 CreatePool(true /* tcp pool */, false, false); |
368 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 369 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
369 true); | 370 true); |
370 | 371 |
371 ClientSocketHandle handle; | 372 ClientSocketHandle handle; |
372 TestOldCompletionCallback callback; | 373 TestCompletionCallback callback; |
373 int rv = handle.Init( | 374 int rv = handle.Init( |
374 "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog()); | 375 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); |
375 EXPECT_EQ(ERR_IO_PENDING, rv); | 376 EXPECT_EQ(ERR_IO_PENDING, rv); |
376 EXPECT_FALSE(handle.is_initialized()); | 377 EXPECT_FALSE(handle.is_initialized()); |
377 EXPECT_FALSE(handle.socket()); | 378 EXPECT_FALSE(handle.socket()); |
378 | 379 |
379 EXPECT_EQ(OK, callback.WaitForResult()); | 380 EXPECT_EQ(OK, callback.WaitForResult()); |
380 EXPECT_TRUE(handle.is_initialized()); | 381 EXPECT_TRUE(handle.is_initialized()); |
381 EXPECT_TRUE(handle.socket()); | 382 EXPECT_TRUE(handle.socket()); |
382 | 383 |
383 SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(handle.socket()); | 384 SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(handle.socket()); |
384 EXPECT_TRUE(ssl_socket->was_npn_negotiated()); | 385 EXPECT_TRUE(ssl_socket->was_npn_negotiated()); |
(...skipping 10 matching lines...) Expand all Loading... |
395 SSLSocketDataProvider ssl(true, OK); | 396 SSLSocketDataProvider ssl(true, OK); |
396 ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated; | 397 ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated; |
397 ssl.next_proto = "spdy/2"; | 398 ssl.next_proto = "spdy/2"; |
398 socket_factory_.AddSSLSocketDataProvider(&ssl); | 399 socket_factory_.AddSSLSocketDataProvider(&ssl); |
399 | 400 |
400 CreatePool(true /* tcp pool */, false, false); | 401 CreatePool(true /* tcp pool */, false, false); |
401 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 402 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
402 true); | 403 true); |
403 | 404 |
404 ClientSocketHandle handle; | 405 ClientSocketHandle handle; |
405 TestOldCompletionCallback callback; | 406 TestCompletionCallback callback; |
406 int rv = handle.Init( | 407 int rv = handle.Init( |
407 "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog()); | 408 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); |
408 EXPECT_EQ(ERR_IO_PENDING, rv); | 409 EXPECT_EQ(ERR_IO_PENDING, rv); |
409 EXPECT_FALSE(handle.is_initialized()); | 410 EXPECT_FALSE(handle.is_initialized()); |
410 EXPECT_FALSE(handle.socket()); | 411 EXPECT_FALSE(handle.socket()); |
411 | 412 |
412 EXPECT_EQ(OK, callback.WaitForResult()); | 413 EXPECT_EQ(OK, callback.WaitForResult()); |
413 EXPECT_TRUE(handle.is_initialized()); | 414 EXPECT_TRUE(handle.is_initialized()); |
414 EXPECT_TRUE(handle.socket()); | 415 EXPECT_TRUE(handle.socket()); |
415 | 416 |
416 SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(handle.socket()); | 417 SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(handle.socket()); |
417 EXPECT_TRUE(ssl_socket->was_npn_negotiated()); | 418 EXPECT_TRUE(ssl_socket->was_npn_negotiated()); |
418 std::string proto; | 419 std::string proto; |
419 std::string server_protos; | 420 std::string server_protos; |
420 ssl_socket->GetNextProto(&proto, &server_protos); | 421 ssl_socket->GetNextProto(&proto, &server_protos); |
421 EXPECT_EQ(SSLClientSocket::NextProtoFromString(proto), | 422 EXPECT_EQ(SSLClientSocket::NextProtoFromString(proto), |
422 SSLClientSocket::kProtoSPDY2); | 423 SSLClientSocket::kProtoSPDY2); |
423 } | 424 } |
424 | 425 |
425 TEST_F(SSLClientSocketPoolTest, SOCKSFail) { | 426 TEST_F(SSLClientSocketPoolTest, SOCKSFail) { |
426 StaticSocketDataProvider data; | 427 StaticSocketDataProvider data; |
427 data.set_connect_data(MockConnect(false, ERR_CONNECTION_FAILED)); | 428 data.set_connect_data(MockConnect(false, ERR_CONNECTION_FAILED)); |
428 socket_factory_.AddSocketDataProvider(&data); | 429 socket_factory_.AddSocketDataProvider(&data); |
429 | 430 |
430 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | 431 CreatePool(false, true /* http proxy pool */, true /* socks pool */); |
431 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5, | 432 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5, |
432 false); | 433 false); |
433 | 434 |
434 ClientSocketHandle handle; | 435 ClientSocketHandle handle; |
435 TestOldCompletionCallback callback; | 436 TestCompletionCallback callback; |
436 int rv = handle.Init( | 437 int rv = handle.Init( |
437 "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog()); | 438 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); |
438 EXPECT_EQ(ERR_CONNECTION_FAILED, rv); | 439 EXPECT_EQ(ERR_CONNECTION_FAILED, rv); |
439 EXPECT_FALSE(handle.is_initialized()); | 440 EXPECT_FALSE(handle.is_initialized()); |
440 EXPECT_FALSE(handle.socket()); | 441 EXPECT_FALSE(handle.socket()); |
441 EXPECT_FALSE(handle.is_ssl_error()); | 442 EXPECT_FALSE(handle.is_ssl_error()); |
442 } | 443 } |
443 | 444 |
444 TEST_F(SSLClientSocketPoolTest, SOCKSFailAsync) { | 445 TEST_F(SSLClientSocketPoolTest, SOCKSFailAsync) { |
445 StaticSocketDataProvider data; | 446 StaticSocketDataProvider data; |
446 data.set_connect_data(MockConnect(true, ERR_CONNECTION_FAILED)); | 447 data.set_connect_data(MockConnect(true, ERR_CONNECTION_FAILED)); |
447 socket_factory_.AddSocketDataProvider(&data); | 448 socket_factory_.AddSocketDataProvider(&data); |
448 | 449 |
449 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | 450 CreatePool(false, true /* http proxy pool */, true /* socks pool */); |
450 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5, | 451 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5, |
451 false); | 452 false); |
452 | 453 |
453 ClientSocketHandle handle; | 454 ClientSocketHandle handle; |
454 TestOldCompletionCallback callback; | 455 TestCompletionCallback callback; |
455 int rv = handle.Init( | 456 int rv = handle.Init( |
456 "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog()); | 457 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); |
457 EXPECT_EQ(ERR_IO_PENDING, rv); | 458 EXPECT_EQ(ERR_IO_PENDING, rv); |
458 EXPECT_FALSE(handle.is_initialized()); | 459 EXPECT_FALSE(handle.is_initialized()); |
459 EXPECT_FALSE(handle.socket()); | 460 EXPECT_FALSE(handle.socket()); |
460 | 461 |
461 EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult()); | 462 EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult()); |
462 EXPECT_FALSE(handle.is_initialized()); | 463 EXPECT_FALSE(handle.is_initialized()); |
463 EXPECT_FALSE(handle.socket()); | 464 EXPECT_FALSE(handle.socket()); |
464 EXPECT_FALSE(handle.is_ssl_error()); | 465 EXPECT_FALSE(handle.is_ssl_error()); |
465 } | 466 } |
466 | 467 |
467 TEST_F(SSLClientSocketPoolTest, SOCKSBasic) { | 468 TEST_F(SSLClientSocketPoolTest, SOCKSBasic) { |
468 StaticSocketDataProvider data; | 469 StaticSocketDataProvider data; |
469 data.set_connect_data(MockConnect(false, OK)); | 470 data.set_connect_data(MockConnect(false, OK)); |
470 socket_factory_.AddSocketDataProvider(&data); | 471 socket_factory_.AddSocketDataProvider(&data); |
471 SSLSocketDataProvider ssl(false, OK); | 472 SSLSocketDataProvider ssl(false, OK); |
472 socket_factory_.AddSSLSocketDataProvider(&ssl); | 473 socket_factory_.AddSSLSocketDataProvider(&ssl); |
473 | 474 |
474 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | 475 CreatePool(false, true /* http proxy pool */, true /* socks pool */); |
475 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5, | 476 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5, |
476 false); | 477 false); |
477 | 478 |
478 ClientSocketHandle handle; | 479 ClientSocketHandle handle; |
479 TestOldCompletionCallback callback; | 480 TestCompletionCallback callback; |
480 int rv = handle.Init( | 481 int rv = handle.Init( |
481 "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog()); | 482 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); |
482 EXPECT_EQ(OK, rv); | 483 EXPECT_EQ(OK, rv); |
483 EXPECT_TRUE(handle.is_initialized()); | 484 EXPECT_TRUE(handle.is_initialized()); |
484 EXPECT_TRUE(handle.socket()); | 485 EXPECT_TRUE(handle.socket()); |
485 } | 486 } |
486 | 487 |
487 TEST_F(SSLClientSocketPoolTest, SOCKSBasicAsync) { | 488 TEST_F(SSLClientSocketPoolTest, SOCKSBasicAsync) { |
488 StaticSocketDataProvider data; | 489 StaticSocketDataProvider data; |
489 socket_factory_.AddSocketDataProvider(&data); | 490 socket_factory_.AddSocketDataProvider(&data); |
490 SSLSocketDataProvider ssl(true, OK); | 491 SSLSocketDataProvider ssl(true, OK); |
491 socket_factory_.AddSSLSocketDataProvider(&ssl); | 492 socket_factory_.AddSSLSocketDataProvider(&ssl); |
492 | 493 |
493 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | 494 CreatePool(false, true /* http proxy pool */, true /* socks pool */); |
494 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5, | 495 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5, |
495 false); | 496 false); |
496 | 497 |
497 ClientSocketHandle handle; | 498 ClientSocketHandle handle; |
498 TestOldCompletionCallback callback; | 499 TestCompletionCallback callback; |
499 int rv = handle.Init( | 500 int rv = handle.Init( |
500 "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog()); | 501 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); |
501 EXPECT_EQ(ERR_IO_PENDING, rv); | 502 EXPECT_EQ(ERR_IO_PENDING, rv); |
502 EXPECT_FALSE(handle.is_initialized()); | 503 EXPECT_FALSE(handle.is_initialized()); |
503 EXPECT_FALSE(handle.socket()); | 504 EXPECT_FALSE(handle.socket()); |
504 | 505 |
505 EXPECT_EQ(OK, callback.WaitForResult()); | 506 EXPECT_EQ(OK, callback.WaitForResult()); |
506 EXPECT_TRUE(handle.is_initialized()); | 507 EXPECT_TRUE(handle.is_initialized()); |
507 EXPECT_TRUE(handle.socket()); | 508 EXPECT_TRUE(handle.socket()); |
508 } | 509 } |
509 | 510 |
510 TEST_F(SSLClientSocketPoolTest, HttpProxyFail) { | 511 TEST_F(SSLClientSocketPoolTest, HttpProxyFail) { |
511 StaticSocketDataProvider data; | 512 StaticSocketDataProvider data; |
512 data.set_connect_data(MockConnect(false, ERR_CONNECTION_FAILED)); | 513 data.set_connect_data(MockConnect(false, ERR_CONNECTION_FAILED)); |
513 socket_factory_.AddSocketDataProvider(&data); | 514 socket_factory_.AddSocketDataProvider(&data); |
514 | 515 |
515 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | 516 CreatePool(false, true /* http proxy pool */, true /* socks pool */); |
516 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, | 517 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, |
517 false); | 518 false); |
518 | 519 |
519 ClientSocketHandle handle; | 520 ClientSocketHandle handle; |
520 TestOldCompletionCallback callback; | 521 TestCompletionCallback callback; |
521 int rv = handle.Init( | 522 int rv = handle.Init( |
522 "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog()); | 523 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); |
523 EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, rv); | 524 EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, rv); |
524 EXPECT_FALSE(handle.is_initialized()); | 525 EXPECT_FALSE(handle.is_initialized()); |
525 EXPECT_FALSE(handle.socket()); | 526 EXPECT_FALSE(handle.socket()); |
526 EXPECT_FALSE(handle.is_ssl_error()); | 527 EXPECT_FALSE(handle.is_ssl_error()); |
527 } | 528 } |
528 | 529 |
529 TEST_F(SSLClientSocketPoolTest, HttpProxyFailAsync) { | 530 TEST_F(SSLClientSocketPoolTest, HttpProxyFailAsync) { |
530 StaticSocketDataProvider data; | 531 StaticSocketDataProvider data; |
531 data.set_connect_data(MockConnect(true, ERR_CONNECTION_FAILED)); | 532 data.set_connect_data(MockConnect(true, ERR_CONNECTION_FAILED)); |
532 socket_factory_.AddSocketDataProvider(&data); | 533 socket_factory_.AddSocketDataProvider(&data); |
533 | 534 |
534 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | 535 CreatePool(false, true /* http proxy pool */, true /* socks pool */); |
535 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, | 536 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, |
536 false); | 537 false); |
537 | 538 |
538 ClientSocketHandle handle; | 539 ClientSocketHandle handle; |
539 TestOldCompletionCallback callback; | 540 TestCompletionCallback callback; |
540 int rv = handle.Init( | 541 int rv = handle.Init( |
541 "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog()); | 542 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); |
542 EXPECT_EQ(ERR_IO_PENDING, rv); | 543 EXPECT_EQ(ERR_IO_PENDING, rv); |
543 EXPECT_FALSE(handle.is_initialized()); | 544 EXPECT_FALSE(handle.is_initialized()); |
544 EXPECT_FALSE(handle.socket()); | 545 EXPECT_FALSE(handle.socket()); |
545 | 546 |
546 EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, callback.WaitForResult()); | 547 EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, callback.WaitForResult()); |
547 EXPECT_FALSE(handle.is_initialized()); | 548 EXPECT_FALSE(handle.is_initialized()); |
548 EXPECT_FALSE(handle.socket()); | 549 EXPECT_FALSE(handle.socket()); |
549 EXPECT_FALSE(handle.is_ssl_error()); | 550 EXPECT_FALSE(handle.is_ssl_error()); |
550 } | 551 } |
551 | 552 |
(...skipping 14 matching lines...) Expand all Loading... |
566 socket_factory_.AddSocketDataProvider(&data); | 567 socket_factory_.AddSocketDataProvider(&data); |
567 AddAuthToCache(); | 568 AddAuthToCache(); |
568 SSLSocketDataProvider ssl(false, OK); | 569 SSLSocketDataProvider ssl(false, OK); |
569 socket_factory_.AddSSLSocketDataProvider(&ssl); | 570 socket_factory_.AddSSLSocketDataProvider(&ssl); |
570 | 571 |
571 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | 572 CreatePool(false, true /* http proxy pool */, true /* socks pool */); |
572 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, | 573 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, |
573 false); | 574 false); |
574 | 575 |
575 ClientSocketHandle handle; | 576 ClientSocketHandle handle; |
576 TestOldCompletionCallback callback; | 577 TestCompletionCallback callback; |
577 int rv = handle.Init( | 578 int rv = handle.Init( |
578 "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog()); | 579 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); |
579 EXPECT_EQ(OK, rv); | 580 EXPECT_EQ(OK, rv); |
580 EXPECT_TRUE(handle.is_initialized()); | 581 EXPECT_TRUE(handle.is_initialized()); |
581 EXPECT_TRUE(handle.socket()); | 582 EXPECT_TRUE(handle.socket()); |
582 } | 583 } |
583 | 584 |
584 TEST_F(SSLClientSocketPoolTest, HttpProxyBasicAsync) { | 585 TEST_F(SSLClientSocketPoolTest, HttpProxyBasicAsync) { |
585 MockWrite writes[] = { | 586 MockWrite writes[] = { |
586 MockWrite("CONNECT host:80 HTTP/1.1\r\n" | 587 MockWrite("CONNECT host:80 HTTP/1.1\r\n" |
587 "Host: host\r\n" | 588 "Host: host\r\n" |
588 "Proxy-Connection: keep-alive\r\n" | 589 "Proxy-Connection: keep-alive\r\n" |
589 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), | 590 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), |
590 }; | 591 }; |
591 MockRead reads[] = { | 592 MockRead reads[] = { |
592 MockRead("HTTP/1.1 200 Connection Established\r\n\r\n"), | 593 MockRead("HTTP/1.1 200 Connection Established\r\n\r\n"), |
593 }; | 594 }; |
594 StaticSocketDataProvider data(reads, arraysize(reads), writes, | 595 StaticSocketDataProvider data(reads, arraysize(reads), writes, |
595 arraysize(writes)); | 596 arraysize(writes)); |
596 socket_factory_.AddSocketDataProvider(&data); | 597 socket_factory_.AddSocketDataProvider(&data); |
597 AddAuthToCache(); | 598 AddAuthToCache(); |
598 SSLSocketDataProvider ssl(true, OK); | 599 SSLSocketDataProvider ssl(true, OK); |
599 socket_factory_.AddSSLSocketDataProvider(&ssl); | 600 socket_factory_.AddSSLSocketDataProvider(&ssl); |
600 | 601 |
601 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | 602 CreatePool(false, true /* http proxy pool */, true /* socks pool */); |
602 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, | 603 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, |
603 false); | 604 false); |
604 | 605 |
605 ClientSocketHandle handle; | 606 ClientSocketHandle handle; |
606 TestOldCompletionCallback callback; | 607 TestCompletionCallback callback; |
607 int rv = handle.Init( | 608 int rv = handle.Init( |
608 "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog()); | 609 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); |
609 EXPECT_EQ(ERR_IO_PENDING, rv); | 610 EXPECT_EQ(ERR_IO_PENDING, rv); |
610 EXPECT_FALSE(handle.is_initialized()); | 611 EXPECT_FALSE(handle.is_initialized()); |
611 EXPECT_FALSE(handle.socket()); | 612 EXPECT_FALSE(handle.socket()); |
612 | 613 |
613 EXPECT_EQ(OK, callback.WaitForResult()); | 614 EXPECT_EQ(OK, callback.WaitForResult()); |
614 EXPECT_TRUE(handle.is_initialized()); | 615 EXPECT_TRUE(handle.is_initialized()); |
615 EXPECT_TRUE(handle.socket()); | 616 EXPECT_TRUE(handle.socket()); |
616 } | 617 } |
617 | 618 |
618 TEST_F(SSLClientSocketPoolTest, NeedProxyAuth) { | 619 TEST_F(SSLClientSocketPoolTest, NeedProxyAuth) { |
(...skipping 12 matching lines...) Expand all Loading... |
631 arraysize(writes)); | 632 arraysize(writes)); |
632 socket_factory_.AddSocketDataProvider(&data); | 633 socket_factory_.AddSocketDataProvider(&data); |
633 SSLSocketDataProvider ssl(true, OK); | 634 SSLSocketDataProvider ssl(true, OK); |
634 socket_factory_.AddSSLSocketDataProvider(&ssl); | 635 socket_factory_.AddSSLSocketDataProvider(&ssl); |
635 | 636 |
636 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | 637 CreatePool(false, true /* http proxy pool */, true /* socks pool */); |
637 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, | 638 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, |
638 false); | 639 false); |
639 | 640 |
640 ClientSocketHandle handle; | 641 ClientSocketHandle handle; |
641 TestOldCompletionCallback callback; | 642 TestCompletionCallback callback; |
642 int rv = handle.Init( | 643 int rv = handle.Init( |
643 "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog()); | 644 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); |
644 EXPECT_EQ(ERR_IO_PENDING, rv); | 645 EXPECT_EQ(ERR_IO_PENDING, rv); |
645 EXPECT_FALSE(handle.is_initialized()); | 646 EXPECT_FALSE(handle.is_initialized()); |
646 EXPECT_FALSE(handle.socket()); | 647 EXPECT_FALSE(handle.socket()); |
647 | 648 |
648 EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, callback.WaitForResult()); | 649 EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, callback.WaitForResult()); |
649 EXPECT_FALSE(handle.is_initialized()); | 650 EXPECT_FALSE(handle.is_initialized()); |
650 EXPECT_FALSE(handle.socket()); | 651 EXPECT_FALSE(handle.socket()); |
651 EXPECT_FALSE(handle.is_ssl_error()); | 652 EXPECT_FALSE(handle.is_ssl_error()); |
652 const HttpResponseInfo& tunnel_info = handle.ssl_error_response_info(); | 653 const HttpResponseInfo& tunnel_info = handle.ssl_error_response_info(); |
653 EXPECT_EQ(tunnel_info.headers->response_code(), 407); | 654 EXPECT_EQ(tunnel_info.headers->response_code(), 407); |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
696 reinterpret_cast<const char*>(webkit_der), sizeof(webkit_der)); | 697 reinterpret_cast<const char*>(webkit_der), sizeof(webkit_der)); |
697 ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated; | 698 ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated; |
698 ssl.next_proto = "spdy/2"; | 699 ssl.next_proto = "spdy/2"; |
699 socket_factory_.AddSSLSocketDataProvider(&ssl); | 700 socket_factory_.AddSSLSocketDataProvider(&ssl); |
700 | 701 |
701 CreatePool(true /* tcp pool */, false, false); | 702 CreatePool(true /* tcp pool */, false, false); |
702 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 703 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
703 true); | 704 true); |
704 | 705 |
705 scoped_ptr<ClientSocketHandle> handle(new ClientSocketHandle()); | 706 scoped_ptr<ClientSocketHandle> handle(new ClientSocketHandle()); |
706 TestOldCompletionCallback callback; | 707 TestCompletionCallback callback; |
707 int rv = handle->Init( | 708 int rv = handle->Init( |
708 "a", params, MEDIUM, &callback, pool_.get(), BoundNetLog()); | 709 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); |
709 EXPECT_EQ(ERR_IO_PENDING, rv); | 710 EXPECT_EQ(ERR_IO_PENDING, rv); |
710 EXPECT_FALSE(handle->is_initialized()); | 711 EXPECT_FALSE(handle->is_initialized()); |
711 EXPECT_FALSE(handle->socket()); | 712 EXPECT_FALSE(handle->socket()); |
712 | 713 |
713 EXPECT_EQ(OK, callback.WaitForResult()); | 714 EXPECT_EQ(OK, callback.WaitForResult()); |
714 EXPECT_TRUE(handle->is_initialized()); | 715 EXPECT_TRUE(handle->is_initialized()); |
715 EXPECT_TRUE(handle->socket()); | 716 EXPECT_TRUE(handle->socket()); |
716 | 717 |
717 SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(handle->socket()); | 718 SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(handle->socket()); |
718 EXPECT_TRUE(ssl_socket->was_npn_negotiated()); | 719 EXPECT_TRUE(ssl_socket->was_npn_negotiated()); |
(...skipping 30 matching lines...) Expand all Loading... |
749 std::string name; | 750 std::string name; |
750 std::string iplist; | 751 std::string iplist; |
751 HostPortProxyPair pair; | 752 HostPortProxyPair pair; |
752 AddressList addresses; | 753 AddressList addresses; |
753 } test_hosts[] = { | 754 } test_hosts[] = { |
754 { "www.webkit.org", "192.0.2.33,192.168.0.1,192.168.0.5" }, | 755 { "www.webkit.org", "192.0.2.33,192.168.0.1,192.168.0.5" }, |
755 { "js.webkit.org", "192.168.0.4,192.168.0.1,192.0.2.33" }, | 756 { "js.webkit.org", "192.168.0.4,192.168.0.1,192.0.2.33" }, |
756 }; | 757 }; |
757 | 758 |
758 TestCompletionCallback callback; | 759 TestCompletionCallback callback; |
759 TestOldCompletionCallback old_callback; | |
760 int rv; | 760 int rv; |
761 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_hosts); i++) { | 761 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_hosts); i++) { |
762 host_resolver_.rules()->AddIPLiteralRule(test_hosts[i].name, | 762 host_resolver_.rules()->AddIPLiteralRule(test_hosts[i].name, |
763 test_hosts[i].iplist, ""); | 763 test_hosts[i].iplist, ""); |
764 | 764 |
765 // This test requires that the HostResolver cache be populated. Normal | 765 // This test requires that the HostResolver cache be populated. Normal |
766 // code would have done this already, but we do it manually. | 766 // code would have done this already, but we do it manually. |
767 HostResolver::RequestInfo info(HostPortPair(test_hosts[i].name, kTestPort)); | 767 HostResolver::RequestInfo info(HostPortPair(test_hosts[i].name, kTestPort)); |
768 rv = host_resolver_.Resolve(info, &test_hosts[i].addresses, | 768 rv = host_resolver_.Resolve(info, &test_hosts[i].addresses, |
769 callback.callback(), NULL, BoundNetLog()); | 769 callback.callback(), NULL, BoundNetLog()); |
(...skipping 16 matching lines...) Expand all Loading... |
786 ssl.next_proto = "spdy/2"; | 786 ssl.next_proto = "spdy/2"; |
787 ssl.client_cert_sent = true; | 787 ssl.client_cert_sent = true; |
788 socket_factory_.AddSSLSocketDataProvider(&ssl); | 788 socket_factory_.AddSSLSocketDataProvider(&ssl); |
789 | 789 |
790 CreatePool(true /* tcp pool */, false, false); | 790 CreatePool(true /* tcp pool */, false, false); |
791 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 791 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
792 true); | 792 true); |
793 | 793 |
794 scoped_ptr<ClientSocketHandle> handle(new ClientSocketHandle()); | 794 scoped_ptr<ClientSocketHandle> handle(new ClientSocketHandle()); |
795 rv = handle->Init( | 795 rv = handle->Init( |
796 "a", params, MEDIUM, &old_callback, pool_.get(), BoundNetLog()); | 796 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); |
797 EXPECT_EQ(ERR_IO_PENDING, rv); | 797 EXPECT_EQ(ERR_IO_PENDING, rv); |
798 EXPECT_FALSE(handle->is_initialized()); | 798 EXPECT_FALSE(handle->is_initialized()); |
799 EXPECT_FALSE(handle->socket()); | 799 EXPECT_FALSE(handle->socket()); |
800 | 800 |
801 EXPECT_EQ(OK, old_callback.WaitForResult()); | 801 EXPECT_EQ(OK, callback.WaitForResult()); |
802 EXPECT_TRUE(handle->is_initialized()); | 802 EXPECT_TRUE(handle->is_initialized()); |
803 EXPECT_TRUE(handle->socket()); | 803 EXPECT_TRUE(handle->socket()); |
804 | 804 |
805 SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(handle->socket()); | 805 SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(handle->socket()); |
806 EXPECT_TRUE(ssl_socket->was_npn_negotiated()); | 806 EXPECT_TRUE(ssl_socket->was_npn_negotiated()); |
807 std::string proto; | 807 std::string proto; |
808 std::string server_protos; | 808 std::string server_protos; |
809 ssl_socket->GetNextProto(&proto, &server_protos); | 809 ssl_socket->GetNextProto(&proto, &server_protos); |
810 EXPECT_EQ(SSLClientSocket::NextProtoFromString(proto), | 810 EXPECT_EQ(SSLClientSocket::NextProtoFromString(proto), |
811 SSLClientSocket::kProtoSPDY2); | 811 SSLClientSocket::kProtoSPDY2); |
(...skipping 14 matching lines...) Expand all Loading... |
826 EXPECT_FALSE(session_->spdy_session_pool()->HasSession(test_hosts[1].pair)); | 826 EXPECT_FALSE(session_->spdy_session_pool()->HasSession(test_hosts[1].pair)); |
827 | 827 |
828 session_->spdy_session_pool()->CloseAllSessions(); | 828 session_->spdy_session_pool()->CloseAllSessions(); |
829 } | 829 } |
830 | 830 |
831 // It would be nice to also test the timeouts in SSLClientSocketPool. | 831 // It would be nice to also test the timeouts in SSLClientSocketPool. |
832 | 832 |
833 } // namespace | 833 } // namespace |
834 | 834 |
835 } // namespace net | 835 } // namespace net |
OLD | NEW |