OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/http/http_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 199 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
210 EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult()); | 210 EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult()); |
211 EXPECT_FALSE(handle.is_initialized()); | 211 EXPECT_FALSE(handle.is_initialized()); |
212 EXPECT_FALSE(handle.socket()); | 212 EXPECT_FALSE(handle.socket()); |
213 EXPECT_FALSE(handle.is_ssl_error()); | 213 EXPECT_FALSE(handle.is_ssl_error()); |
214 } | 214 } |
215 | 215 |
216 TEST_F(SSLClientSocketPoolTest, BasicDirect) { | 216 TEST_F(SSLClientSocketPoolTest, BasicDirect) { |
217 StaticSocketDataProvider data; | 217 StaticSocketDataProvider data; |
218 data.set_connect_data(MockConnect(SYNCHRONOUS, OK)); | 218 data.set_connect_data(MockConnect(SYNCHRONOUS, OK)); |
219 socket_factory_.AddSocketDataProvider(&data); | 219 socket_factory_.AddSocketDataProvider(&data); |
220 SSLSocketDataProvider ssl(false, OK); | 220 SSLSocketDataProvider ssl(SYNCHRONOUS, OK); |
221 socket_factory_.AddSSLSocketDataProvider(&ssl); | 221 socket_factory_.AddSSLSocketDataProvider(&ssl); |
222 | 222 |
223 CreatePool(true /* tcp pool */, false, false); | 223 CreatePool(true /* tcp pool */, false, false); |
224 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 224 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
225 false); | 225 false); |
226 | 226 |
227 ClientSocketHandle handle; | 227 ClientSocketHandle handle; |
228 TestCompletionCallback callback; | 228 TestCompletionCallback callback; |
229 int rv = handle.Init( | 229 int rv = handle.Init( |
230 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); | 230 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); |
231 EXPECT_EQ(OK, rv); | 231 EXPECT_EQ(OK, rv); |
232 EXPECT_TRUE(handle.is_initialized()); | 232 EXPECT_TRUE(handle.is_initialized()); |
233 EXPECT_TRUE(handle.socket()); | 233 EXPECT_TRUE(handle.socket()); |
234 } | 234 } |
235 | 235 |
236 TEST_F(SSLClientSocketPoolTest, BasicDirectAsync) { | 236 TEST_F(SSLClientSocketPoolTest, BasicDirectAsync) { |
237 StaticSocketDataProvider data; | 237 StaticSocketDataProvider data; |
238 socket_factory_.AddSocketDataProvider(&data); | 238 socket_factory_.AddSocketDataProvider(&data); |
239 SSLSocketDataProvider ssl(true, OK); | 239 SSLSocketDataProvider ssl(ASYNC, OK); |
240 socket_factory_.AddSSLSocketDataProvider(&ssl); | 240 socket_factory_.AddSSLSocketDataProvider(&ssl); |
241 | 241 |
242 CreatePool(true /* tcp pool */, false, false); | 242 CreatePool(true /* tcp pool */, false, false); |
243 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 243 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
244 false); | 244 false); |
245 | 245 |
246 ClientSocketHandle handle; | 246 ClientSocketHandle handle; |
247 TestCompletionCallback callback; | 247 TestCompletionCallback callback; |
248 int rv = handle.Init( | 248 int rv = handle.Init( |
249 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); | 249 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); |
250 EXPECT_EQ(ERR_IO_PENDING, rv); | 250 EXPECT_EQ(ERR_IO_PENDING, rv); |
251 EXPECT_FALSE(handle.is_initialized()); | 251 EXPECT_FALSE(handle.is_initialized()); |
252 EXPECT_FALSE(handle.socket()); | 252 EXPECT_FALSE(handle.socket()); |
253 | 253 |
254 EXPECT_EQ(OK, callback.WaitForResult()); | 254 EXPECT_EQ(OK, callback.WaitForResult()); |
255 EXPECT_TRUE(handle.is_initialized()); | 255 EXPECT_TRUE(handle.is_initialized()); |
256 EXPECT_TRUE(handle.socket()); | 256 EXPECT_TRUE(handle.socket()); |
257 } | 257 } |
258 | 258 |
259 TEST_F(SSLClientSocketPoolTest, DirectCertError) { | 259 TEST_F(SSLClientSocketPoolTest, DirectCertError) { |
260 StaticSocketDataProvider data; | 260 StaticSocketDataProvider data; |
261 socket_factory_.AddSocketDataProvider(&data); | 261 socket_factory_.AddSocketDataProvider(&data); |
262 SSLSocketDataProvider ssl(true, ERR_CERT_COMMON_NAME_INVALID); | 262 SSLSocketDataProvider ssl(ASYNC, ERR_CERT_COMMON_NAME_INVALID); |
263 socket_factory_.AddSSLSocketDataProvider(&ssl); | 263 socket_factory_.AddSSLSocketDataProvider(&ssl); |
264 | 264 |
265 CreatePool(true /* tcp pool */, false, false); | 265 CreatePool(true /* tcp pool */, false, false); |
266 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 266 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
267 false); | 267 false); |
268 | 268 |
269 ClientSocketHandle handle; | 269 ClientSocketHandle handle; |
270 TestCompletionCallback callback; | 270 TestCompletionCallback callback; |
271 int rv = handle.Init( | 271 int rv = handle.Init( |
272 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); | 272 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); |
273 EXPECT_EQ(ERR_IO_PENDING, rv); | 273 EXPECT_EQ(ERR_IO_PENDING, rv); |
274 EXPECT_FALSE(handle.is_initialized()); | 274 EXPECT_FALSE(handle.is_initialized()); |
275 EXPECT_FALSE(handle.socket()); | 275 EXPECT_FALSE(handle.socket()); |
276 | 276 |
277 EXPECT_EQ(ERR_CERT_COMMON_NAME_INVALID, callback.WaitForResult()); | 277 EXPECT_EQ(ERR_CERT_COMMON_NAME_INVALID, callback.WaitForResult()); |
278 EXPECT_TRUE(handle.is_initialized()); | 278 EXPECT_TRUE(handle.is_initialized()); |
279 EXPECT_TRUE(handle.socket()); | 279 EXPECT_TRUE(handle.socket()); |
280 } | 280 } |
281 | 281 |
282 TEST_F(SSLClientSocketPoolTest, DirectSSLError) { | 282 TEST_F(SSLClientSocketPoolTest, DirectSSLError) { |
283 StaticSocketDataProvider data; | 283 StaticSocketDataProvider data; |
284 socket_factory_.AddSocketDataProvider(&data); | 284 socket_factory_.AddSocketDataProvider(&data); |
285 SSLSocketDataProvider ssl(true, ERR_SSL_PROTOCOL_ERROR); | 285 SSLSocketDataProvider ssl(ASYNC, ERR_SSL_PROTOCOL_ERROR); |
286 socket_factory_.AddSSLSocketDataProvider(&ssl); | 286 socket_factory_.AddSSLSocketDataProvider(&ssl); |
287 | 287 |
288 CreatePool(true /* tcp pool */, false, false); | 288 CreatePool(true /* tcp pool */, false, false); |
289 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 289 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
290 false); | 290 false); |
291 | 291 |
292 ClientSocketHandle handle; | 292 ClientSocketHandle handle; |
293 TestCompletionCallback callback; | 293 TestCompletionCallback callback; |
294 int rv = handle.Init( | 294 int rv = handle.Init( |
295 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); | 295 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); |
296 EXPECT_EQ(ERR_IO_PENDING, rv); | 296 EXPECT_EQ(ERR_IO_PENDING, rv); |
297 EXPECT_FALSE(handle.is_initialized()); | 297 EXPECT_FALSE(handle.is_initialized()); |
298 EXPECT_FALSE(handle.socket()); | 298 EXPECT_FALSE(handle.socket()); |
299 | 299 |
300 EXPECT_EQ(ERR_SSL_PROTOCOL_ERROR, callback.WaitForResult()); | 300 EXPECT_EQ(ERR_SSL_PROTOCOL_ERROR, callback.WaitForResult()); |
301 EXPECT_FALSE(handle.is_initialized()); | 301 EXPECT_FALSE(handle.is_initialized()); |
302 EXPECT_FALSE(handle.socket()); | 302 EXPECT_FALSE(handle.socket()); |
303 EXPECT_TRUE(handle.is_ssl_error()); | 303 EXPECT_TRUE(handle.is_ssl_error()); |
304 } | 304 } |
305 | 305 |
306 TEST_F(SSLClientSocketPoolTest, DirectWithNPN) { | 306 TEST_F(SSLClientSocketPoolTest, DirectWithNPN) { |
307 StaticSocketDataProvider data; | 307 StaticSocketDataProvider data; |
308 socket_factory_.AddSocketDataProvider(&data); | 308 socket_factory_.AddSocketDataProvider(&data); |
309 SSLSocketDataProvider ssl(true, OK); | 309 SSLSocketDataProvider ssl(ASYNC, OK); |
310 ssl.SetNextProto(SSLClientSocket::kProtoHTTP11); | 310 ssl.SetNextProto(SSLClientSocket::kProtoHTTP11); |
311 socket_factory_.AddSSLSocketDataProvider(&ssl); | 311 socket_factory_.AddSSLSocketDataProvider(&ssl); |
312 | 312 |
313 CreatePool(true /* tcp pool */, false, false); | 313 CreatePool(true /* tcp pool */, false, false); |
314 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 314 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
315 false); | 315 false); |
316 | 316 |
317 ClientSocketHandle handle; | 317 ClientSocketHandle handle; |
318 TestCompletionCallback callback; | 318 TestCompletionCallback callback; |
319 int rv = handle.Init( | 319 int rv = handle.Init( |
320 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); | 320 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); |
321 EXPECT_EQ(ERR_IO_PENDING, rv); | 321 EXPECT_EQ(ERR_IO_PENDING, rv); |
322 EXPECT_FALSE(handle.is_initialized()); | 322 EXPECT_FALSE(handle.is_initialized()); |
323 EXPECT_FALSE(handle.socket()); | 323 EXPECT_FALSE(handle.socket()); |
324 | 324 |
325 EXPECT_EQ(OK, callback.WaitForResult()); | 325 EXPECT_EQ(OK, callback.WaitForResult()); |
326 EXPECT_TRUE(handle.is_initialized()); | 326 EXPECT_TRUE(handle.is_initialized()); |
327 EXPECT_TRUE(handle.socket()); | 327 EXPECT_TRUE(handle.socket()); |
328 SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(handle.socket()); | 328 SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(handle.socket()); |
329 EXPECT_TRUE(ssl_socket->was_npn_negotiated()); | 329 EXPECT_TRUE(ssl_socket->was_npn_negotiated()); |
330 } | 330 } |
331 | 331 |
332 TEST_F(SSLClientSocketPoolTest, DirectNoSPDY) { | 332 TEST_F(SSLClientSocketPoolTest, DirectNoSPDY) { |
333 StaticSocketDataProvider data; | 333 StaticSocketDataProvider data; |
334 socket_factory_.AddSocketDataProvider(&data); | 334 socket_factory_.AddSocketDataProvider(&data); |
335 SSLSocketDataProvider ssl(true, OK); | 335 SSLSocketDataProvider ssl(ASYNC, OK); |
336 ssl.SetNextProto(SSLClientSocket::kProtoHTTP11); | 336 ssl.SetNextProto(SSLClientSocket::kProtoHTTP11); |
337 socket_factory_.AddSSLSocketDataProvider(&ssl); | 337 socket_factory_.AddSSLSocketDataProvider(&ssl); |
338 | 338 |
339 CreatePool(true /* tcp pool */, false, false); | 339 CreatePool(true /* tcp pool */, false, false); |
340 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 340 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
341 true); | 341 true); |
342 | 342 |
343 ClientSocketHandle handle; | 343 ClientSocketHandle handle; |
344 TestCompletionCallback callback; | 344 TestCompletionCallback callback; |
345 int rv = handle.Init( | 345 int rv = handle.Init( |
346 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); | 346 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); |
347 EXPECT_EQ(ERR_IO_PENDING, rv); | 347 EXPECT_EQ(ERR_IO_PENDING, rv); |
348 EXPECT_FALSE(handle.is_initialized()); | 348 EXPECT_FALSE(handle.is_initialized()); |
349 EXPECT_FALSE(handle.socket()); | 349 EXPECT_FALSE(handle.socket()); |
350 | 350 |
351 EXPECT_EQ(ERR_NPN_NEGOTIATION_FAILED, callback.WaitForResult()); | 351 EXPECT_EQ(ERR_NPN_NEGOTIATION_FAILED, callback.WaitForResult()); |
352 EXPECT_FALSE(handle.is_initialized()); | 352 EXPECT_FALSE(handle.is_initialized()); |
353 EXPECT_FALSE(handle.socket()); | 353 EXPECT_FALSE(handle.socket()); |
354 EXPECT_TRUE(handle.is_ssl_error()); | 354 EXPECT_TRUE(handle.is_ssl_error()); |
355 } | 355 } |
356 | 356 |
357 TEST_F(SSLClientSocketPoolTest, DirectGotSPDY) { | 357 TEST_F(SSLClientSocketPoolTest, DirectGotSPDY) { |
358 StaticSocketDataProvider data; | 358 StaticSocketDataProvider data; |
359 socket_factory_.AddSocketDataProvider(&data); | 359 socket_factory_.AddSocketDataProvider(&data); |
360 SSLSocketDataProvider ssl(true, OK); | 360 SSLSocketDataProvider ssl(ASYNC, OK); |
361 ssl.SetNextProto(SSLClientSocket::kProtoSPDY21); | 361 ssl.SetNextProto(SSLClientSocket::kProtoSPDY21); |
362 socket_factory_.AddSSLSocketDataProvider(&ssl); | 362 socket_factory_.AddSSLSocketDataProvider(&ssl); |
363 | 363 |
364 CreatePool(true /* tcp pool */, false, false); | 364 CreatePool(true /* tcp pool */, false, false); |
365 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 365 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
366 true); | 366 true); |
367 | 367 |
368 ClientSocketHandle handle; | 368 ClientSocketHandle handle; |
369 TestCompletionCallback callback; | 369 TestCompletionCallback callback; |
370 int rv = handle.Init( | 370 int rv = handle.Init( |
(...skipping 11 matching lines...) Expand all Loading... |
382 std::string proto; | 382 std::string proto; |
383 std::string server_protos; | 383 std::string server_protos; |
384 ssl_socket->GetNextProto(&proto, &server_protos); | 384 ssl_socket->GetNextProto(&proto, &server_protos); |
385 EXPECT_EQ(SSLClientSocket::NextProtoFromString(proto), | 385 EXPECT_EQ(SSLClientSocket::NextProtoFromString(proto), |
386 SSLClientSocket::kProtoSPDY21); | 386 SSLClientSocket::kProtoSPDY21); |
387 } | 387 } |
388 | 388 |
389 TEST_F(SSLClientSocketPoolTest, DirectGotBonusSPDY) { | 389 TEST_F(SSLClientSocketPoolTest, DirectGotBonusSPDY) { |
390 StaticSocketDataProvider data; | 390 StaticSocketDataProvider data; |
391 socket_factory_.AddSocketDataProvider(&data); | 391 socket_factory_.AddSocketDataProvider(&data); |
392 SSLSocketDataProvider ssl(true, OK); | 392 SSLSocketDataProvider ssl(ASYNC, OK); |
393 ssl.SetNextProto(SSLClientSocket::kProtoSPDY21); | 393 ssl.SetNextProto(SSLClientSocket::kProtoSPDY21); |
394 socket_factory_.AddSSLSocketDataProvider(&ssl); | 394 socket_factory_.AddSSLSocketDataProvider(&ssl); |
395 | 395 |
396 CreatePool(true /* tcp pool */, false, false); | 396 CreatePool(true /* tcp pool */, false, false); |
397 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 397 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
398 true); | 398 true); |
399 | 399 |
400 ClientSocketHandle handle; | 400 ClientSocketHandle handle; |
401 TestCompletionCallback callback; | 401 TestCompletionCallback callback; |
402 int rv = handle.Init( | 402 int rv = handle.Init( |
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
457 EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult()); | 457 EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult()); |
458 EXPECT_FALSE(handle.is_initialized()); | 458 EXPECT_FALSE(handle.is_initialized()); |
459 EXPECT_FALSE(handle.socket()); | 459 EXPECT_FALSE(handle.socket()); |
460 EXPECT_FALSE(handle.is_ssl_error()); | 460 EXPECT_FALSE(handle.is_ssl_error()); |
461 } | 461 } |
462 | 462 |
463 TEST_F(SSLClientSocketPoolTest, SOCKSBasic) { | 463 TEST_F(SSLClientSocketPoolTest, SOCKSBasic) { |
464 StaticSocketDataProvider data; | 464 StaticSocketDataProvider data; |
465 data.set_connect_data(MockConnect(SYNCHRONOUS, OK)); | 465 data.set_connect_data(MockConnect(SYNCHRONOUS, OK)); |
466 socket_factory_.AddSocketDataProvider(&data); | 466 socket_factory_.AddSocketDataProvider(&data); |
467 SSLSocketDataProvider ssl(false, OK); | 467 SSLSocketDataProvider ssl(SYNCHRONOUS, OK); |
468 socket_factory_.AddSSLSocketDataProvider(&ssl); | 468 socket_factory_.AddSSLSocketDataProvider(&ssl); |
469 | 469 |
470 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | 470 CreatePool(false, true /* http proxy pool */, true /* socks pool */); |
471 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5, | 471 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5, |
472 false); | 472 false); |
473 | 473 |
474 ClientSocketHandle handle; | 474 ClientSocketHandle handle; |
475 TestCompletionCallback callback; | 475 TestCompletionCallback callback; |
476 int rv = handle.Init( | 476 int rv = handle.Init( |
477 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); | 477 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); |
478 EXPECT_EQ(OK, rv); | 478 EXPECT_EQ(OK, rv); |
479 EXPECT_TRUE(handle.is_initialized()); | 479 EXPECT_TRUE(handle.is_initialized()); |
480 EXPECT_TRUE(handle.socket()); | 480 EXPECT_TRUE(handle.socket()); |
481 } | 481 } |
482 | 482 |
483 TEST_F(SSLClientSocketPoolTest, SOCKSBasicAsync) { | 483 TEST_F(SSLClientSocketPoolTest, SOCKSBasicAsync) { |
484 StaticSocketDataProvider data; | 484 StaticSocketDataProvider data; |
485 socket_factory_.AddSocketDataProvider(&data); | 485 socket_factory_.AddSocketDataProvider(&data); |
486 SSLSocketDataProvider ssl(true, OK); | 486 SSLSocketDataProvider ssl(ASYNC, OK); |
487 socket_factory_.AddSSLSocketDataProvider(&ssl); | 487 socket_factory_.AddSSLSocketDataProvider(&ssl); |
488 | 488 |
489 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | 489 CreatePool(false, true /* http proxy pool */, true /* socks pool */); |
490 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5, | 490 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5, |
491 false); | 491 false); |
492 | 492 |
493 ClientSocketHandle handle; | 493 ClientSocketHandle handle; |
494 TestCompletionCallback callback; | 494 TestCompletionCallback callback; |
495 int rv = handle.Init( | 495 int rv = handle.Init( |
496 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); | 496 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
540 EXPECT_FALSE(handle.socket()); | 540 EXPECT_FALSE(handle.socket()); |
541 | 541 |
542 EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, callback.WaitForResult()); | 542 EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, callback.WaitForResult()); |
543 EXPECT_FALSE(handle.is_initialized()); | 543 EXPECT_FALSE(handle.is_initialized()); |
544 EXPECT_FALSE(handle.socket()); | 544 EXPECT_FALSE(handle.socket()); |
545 EXPECT_FALSE(handle.is_ssl_error()); | 545 EXPECT_FALSE(handle.is_ssl_error()); |
546 } | 546 } |
547 | 547 |
548 TEST_F(SSLClientSocketPoolTest, HttpProxyBasic) { | 548 TEST_F(SSLClientSocketPoolTest, HttpProxyBasic) { |
549 MockWrite writes[] = { | 549 MockWrite writes[] = { |
550 MockWrite(false, | 550 MockWrite(SYNCHRONOUS, |
551 "CONNECT host:80 HTTP/1.1\r\n" | 551 "CONNECT host:80 HTTP/1.1\r\n" |
552 "Host: host\r\n" | 552 "Host: host\r\n" |
553 "Proxy-Connection: keep-alive\r\n" | 553 "Proxy-Connection: keep-alive\r\n" |
554 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), | 554 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), |
555 }; | 555 }; |
556 MockRead reads[] = { | 556 MockRead reads[] = { |
557 MockRead(false, "HTTP/1.1 200 Connection Established\r\n\r\n"), | 557 MockRead(SYNCHRONOUS, "HTTP/1.1 200 Connection Established\r\n\r\n"), |
558 }; | 558 }; |
559 StaticSocketDataProvider data(reads, arraysize(reads), writes, | 559 StaticSocketDataProvider data(reads, arraysize(reads), writes, |
560 arraysize(writes)); | 560 arraysize(writes)); |
561 data.set_connect_data(MockConnect(SYNCHRONOUS, OK)); | 561 data.set_connect_data(MockConnect(SYNCHRONOUS, OK)); |
562 socket_factory_.AddSocketDataProvider(&data); | 562 socket_factory_.AddSocketDataProvider(&data); |
563 AddAuthToCache(); | 563 AddAuthToCache(); |
564 SSLSocketDataProvider ssl(false, OK); | 564 SSLSocketDataProvider ssl(SYNCHRONOUS, OK); |
565 socket_factory_.AddSSLSocketDataProvider(&ssl); | 565 socket_factory_.AddSSLSocketDataProvider(&ssl); |
566 | 566 |
567 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | 567 CreatePool(false, true /* http proxy pool */, true /* socks pool */); |
568 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, | 568 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, |
569 false); | 569 false); |
570 | 570 |
571 ClientSocketHandle handle; | 571 ClientSocketHandle handle; |
572 TestCompletionCallback callback; | 572 TestCompletionCallback callback; |
573 int rv = handle.Init( | 573 int rv = handle.Init( |
574 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); | 574 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); |
575 EXPECT_EQ(OK, rv); | 575 EXPECT_EQ(OK, rv); |
576 EXPECT_TRUE(handle.is_initialized()); | 576 EXPECT_TRUE(handle.is_initialized()); |
577 EXPECT_TRUE(handle.socket()); | 577 EXPECT_TRUE(handle.socket()); |
578 } | 578 } |
579 | 579 |
580 TEST_F(SSLClientSocketPoolTest, HttpProxyBasicAsync) { | 580 TEST_F(SSLClientSocketPoolTest, HttpProxyBasicAsync) { |
581 MockWrite writes[] = { | 581 MockWrite writes[] = { |
582 MockWrite("CONNECT host:80 HTTP/1.1\r\n" | 582 MockWrite("CONNECT host:80 HTTP/1.1\r\n" |
583 "Host: host\r\n" | 583 "Host: host\r\n" |
584 "Proxy-Connection: keep-alive\r\n" | 584 "Proxy-Connection: keep-alive\r\n" |
585 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), | 585 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), |
586 }; | 586 }; |
587 MockRead reads[] = { | 587 MockRead reads[] = { |
588 MockRead("HTTP/1.1 200 Connection Established\r\n\r\n"), | 588 MockRead("HTTP/1.1 200 Connection Established\r\n\r\n"), |
589 }; | 589 }; |
590 StaticSocketDataProvider data(reads, arraysize(reads), writes, | 590 StaticSocketDataProvider data(reads, arraysize(reads), writes, |
591 arraysize(writes)); | 591 arraysize(writes)); |
592 socket_factory_.AddSocketDataProvider(&data); | 592 socket_factory_.AddSocketDataProvider(&data); |
593 AddAuthToCache(); | 593 AddAuthToCache(); |
594 SSLSocketDataProvider ssl(true, OK); | 594 SSLSocketDataProvider ssl(ASYNC, OK); |
595 socket_factory_.AddSSLSocketDataProvider(&ssl); | 595 socket_factory_.AddSSLSocketDataProvider(&ssl); |
596 | 596 |
597 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | 597 CreatePool(false, true /* http proxy pool */, true /* socks pool */); |
598 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, | 598 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, |
599 false); | 599 false); |
600 | 600 |
601 ClientSocketHandle handle; | 601 ClientSocketHandle handle; |
602 TestCompletionCallback callback; | 602 TestCompletionCallback callback; |
603 int rv = handle.Init( | 603 int rv = handle.Init( |
604 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); | 604 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); |
(...skipping 14 matching lines...) Expand all Loading... |
619 }; | 619 }; |
620 MockRead reads[] = { | 620 MockRead reads[] = { |
621 MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"), | 621 MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"), |
622 MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"), | 622 MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"), |
623 MockRead("Content-Length: 10\r\n\r\n"), | 623 MockRead("Content-Length: 10\r\n\r\n"), |
624 MockRead("0123456789"), | 624 MockRead("0123456789"), |
625 }; | 625 }; |
626 StaticSocketDataProvider data(reads, arraysize(reads), writes, | 626 StaticSocketDataProvider data(reads, arraysize(reads), writes, |
627 arraysize(writes)); | 627 arraysize(writes)); |
628 socket_factory_.AddSocketDataProvider(&data); | 628 socket_factory_.AddSocketDataProvider(&data); |
629 SSLSocketDataProvider ssl(true, OK); | 629 SSLSocketDataProvider ssl(ASYNC, OK); |
630 socket_factory_.AddSSLSocketDataProvider(&ssl); | 630 socket_factory_.AddSSLSocketDataProvider(&ssl); |
631 | 631 |
632 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | 632 CreatePool(false, true /* http proxy pool */, true /* socks pool */); |
633 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, | 633 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, |
634 false); | 634 false); |
635 | 635 |
636 ClientSocketHandle handle; | 636 ClientSocketHandle handle; |
637 TestCompletionCallback callback; | 637 TestCompletionCallback callback; |
638 int rv = handle.Init( | 638 int rv = handle.Init( |
639 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); | 639 "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog()); |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
676 HostResolver::RequestInfo info(HostPortPair(test_hosts[i].name, kTestPort)); | 676 HostResolver::RequestInfo info(HostPortPair(test_hosts[i].name, kTestPort)); |
677 host_resolver_.Resolve(info, &test_hosts[i].addresses, CompletionCallback(), | 677 host_resolver_.Resolve(info, &test_hosts[i].addresses, CompletionCallback(), |
678 NULL, BoundNetLog()); | 678 NULL, BoundNetLog()); |
679 | 679 |
680 // Setup a HostPortProxyPair | 680 // Setup a HostPortProxyPair |
681 test_hosts[i].pair = HostPortProxyPair( | 681 test_hosts[i].pair = HostPortProxyPair( |
682 HostPortPair(test_hosts[i].name, kTestPort), ProxyServer::Direct()); | 682 HostPortPair(test_hosts[i].name, kTestPort), ProxyServer::Direct()); |
683 } | 683 } |
684 | 684 |
685 MockRead reads[] = { | 685 MockRead reads[] = { |
686 MockRead(true, ERR_IO_PENDING), | 686 MockRead(ASYNC, ERR_IO_PENDING), |
687 }; | 687 }; |
688 StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0); | 688 StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0); |
689 socket_factory_.AddSocketDataProvider(&data); | 689 socket_factory_.AddSocketDataProvider(&data); |
690 SSLSocketDataProvider ssl(true, OK); | 690 SSLSocketDataProvider ssl(ASYNC, OK); |
691 ssl.cert = X509Certificate::CreateFromBytes( | 691 ssl.cert = X509Certificate::CreateFromBytes( |
692 reinterpret_cast<const char*>(webkit_der), sizeof(webkit_der)); | 692 reinterpret_cast<const char*>(webkit_der), sizeof(webkit_der)); |
693 ssl.SetNextProto(SSLClientSocket::kProtoSPDY21); | 693 ssl.SetNextProto(SSLClientSocket::kProtoSPDY21); |
694 socket_factory_.AddSSLSocketDataProvider(&ssl); | 694 socket_factory_.AddSSLSocketDataProvider(&ssl); |
695 | 695 |
696 CreatePool(true /* tcp pool */, false, false); | 696 CreatePool(true /* tcp pool */, false, false); |
697 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 697 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
698 true); | 698 true); |
699 | 699 |
700 scoped_ptr<ClientSocketHandle> handle(new ClientSocketHandle()); | 700 scoped_ptr<ClientSocketHandle> handle(new ClientSocketHandle()); |
(...skipping 61 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
762 rv = host_resolver_.Resolve(info, &test_hosts[i].addresses, | 762 rv = host_resolver_.Resolve(info, &test_hosts[i].addresses, |
763 callback.callback(), NULL, BoundNetLog()); | 763 callback.callback(), NULL, BoundNetLog()); |
764 EXPECT_EQ(OK, callback.GetResult(rv)); | 764 EXPECT_EQ(OK, callback.GetResult(rv)); |
765 | 765 |
766 // Setup a HostPortProxyPair | 766 // Setup a HostPortProxyPair |
767 test_hosts[i].pair = HostPortProxyPair( | 767 test_hosts[i].pair = HostPortProxyPair( |
768 HostPortPair(test_hosts[i].name, kTestPort), ProxyServer::Direct()); | 768 HostPortPair(test_hosts[i].name, kTestPort), ProxyServer::Direct()); |
769 } | 769 } |
770 | 770 |
771 MockRead reads[] = { | 771 MockRead reads[] = { |
772 MockRead(true, ERR_IO_PENDING), | 772 MockRead(ASYNC, ERR_IO_PENDING), |
773 }; | 773 }; |
774 StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0); | 774 StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0); |
775 socket_factory_.AddSocketDataProvider(&data); | 775 socket_factory_.AddSocketDataProvider(&data); |
776 SSLSocketDataProvider ssl(true, OK); | 776 SSLSocketDataProvider ssl(ASYNC, OK); |
777 ssl.cert = X509Certificate::CreateFromBytes( | 777 ssl.cert = X509Certificate::CreateFromBytes( |
778 reinterpret_cast<const char*>(webkit_der), sizeof(webkit_der)); | 778 reinterpret_cast<const char*>(webkit_der), sizeof(webkit_der)); |
779 ssl.client_cert_sent = true; | 779 ssl.client_cert_sent = true; |
780 ssl.SetNextProto(SSLClientSocket::kProtoSPDY21); | 780 ssl.SetNextProto(SSLClientSocket::kProtoSPDY21); |
781 socket_factory_.AddSSLSocketDataProvider(&ssl); | 781 socket_factory_.AddSSLSocketDataProvider(&ssl); |
782 | 782 |
783 CreatePool(true /* tcp pool */, false, false); | 783 CreatePool(true /* tcp pool */, false, false); |
784 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 784 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
785 true); | 785 true); |
786 | 786 |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
819 EXPECT_FALSE(session_->spdy_session_pool()->HasSession(test_hosts[1].pair)); | 819 EXPECT_FALSE(session_->spdy_session_pool()->HasSession(test_hosts[1].pair)); |
820 | 820 |
821 session_->spdy_session_pool()->CloseAllSessions(); | 821 session_->spdy_session_pool()->CloseAllSessions(); |
822 } | 822 } |
823 | 823 |
824 // It would be nice to also test the timeouts in SSLClientSocketPool. | 824 // It would be nice to also test the timeouts in SSLClientSocketPool. |
825 | 825 |
826 } // namespace | 826 } // namespace |
827 | 827 |
828 } // namespace net | 828 } // namespace net |
OLD | NEW |