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/strings/string_util.h" | 9 #include "base/strings/string_util.h" |
10 #include "base/strings/utf_string_conversions.h" | 10 #include "base/strings/utf_string_conversions.h" |
(...skipping 202 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
213 data.set_connect_data(MockConnect(SYNCHRONOUS, ERR_CONNECTION_FAILED)); | 213 data.set_connect_data(MockConnect(SYNCHRONOUS, ERR_CONNECTION_FAILED)); |
214 socket_factory_.AddSocketDataProvider(&data); | 214 socket_factory_.AddSocketDataProvider(&data); |
215 | 215 |
216 CreatePool(true /* tcp pool */, false, false); | 216 CreatePool(true /* tcp pool */, false, false); |
217 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 217 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
218 false); | 218 false); |
219 | 219 |
220 ClientSocketHandle handle; | 220 ClientSocketHandle handle; |
221 int rv = | 221 int rv = |
222 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, | 222 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, |
223 CompletionCallback(), pool_.get(), BoundNetLog()); | 223 CompletionCallback(), pool_.get(), NetLogWithSource()); |
224 EXPECT_THAT(rv, IsError(ERR_CONNECTION_FAILED)); | 224 EXPECT_THAT(rv, IsError(ERR_CONNECTION_FAILED)); |
225 EXPECT_FALSE(handle.is_initialized()); | 225 EXPECT_FALSE(handle.is_initialized()); |
226 EXPECT_FALSE(handle.socket()); | 226 EXPECT_FALSE(handle.socket()); |
227 EXPECT_FALSE(handle.is_ssl_error()); | 227 EXPECT_FALSE(handle.is_ssl_error()); |
228 ASSERT_EQ(1u, handle.connection_attempts().size()); | 228 ASSERT_EQ(1u, handle.connection_attempts().size()); |
229 EXPECT_THAT(handle.connection_attempts()[0].result, | 229 EXPECT_THAT(handle.connection_attempts()[0].result, |
230 IsError(ERR_CONNECTION_FAILED)); | 230 IsError(ERR_CONNECTION_FAILED)); |
231 } | 231 } |
232 | 232 |
233 TEST_F(SSLClientSocketPoolTest, TCPFailAsync) { | 233 TEST_F(SSLClientSocketPoolTest, TCPFailAsync) { |
234 StaticSocketDataProvider data; | 234 StaticSocketDataProvider data; |
235 data.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_FAILED)); | 235 data.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_FAILED)); |
236 socket_factory_.AddSocketDataProvider(&data); | 236 socket_factory_.AddSocketDataProvider(&data); |
237 | 237 |
238 CreatePool(true /* tcp pool */, false, false); | 238 CreatePool(true /* tcp pool */, false, false); |
239 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 239 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
240 false); | 240 false); |
241 | 241 |
242 ClientSocketHandle handle; | 242 ClientSocketHandle handle; |
243 TestCompletionCallback callback; | 243 TestCompletionCallback callback; |
244 int rv = | 244 int rv = |
245 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, | 245 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, |
246 callback.callback(), pool_.get(), BoundNetLog()); | 246 callback.callback(), pool_.get(), NetLogWithSource()); |
247 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); | 247 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
248 EXPECT_FALSE(handle.is_initialized()); | 248 EXPECT_FALSE(handle.is_initialized()); |
249 EXPECT_FALSE(handle.socket()); | 249 EXPECT_FALSE(handle.socket()); |
250 | 250 |
251 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_FAILED)); | 251 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_FAILED)); |
252 EXPECT_FALSE(handle.is_initialized()); | 252 EXPECT_FALSE(handle.is_initialized()); |
253 EXPECT_FALSE(handle.socket()); | 253 EXPECT_FALSE(handle.socket()); |
254 EXPECT_FALSE(handle.is_ssl_error()); | 254 EXPECT_FALSE(handle.is_ssl_error()); |
255 ASSERT_EQ(1u, handle.connection_attempts().size()); | 255 ASSERT_EQ(1u, handle.connection_attempts().size()); |
256 EXPECT_THAT(handle.connection_attempts()[0].result, | 256 EXPECT_THAT(handle.connection_attempts()[0].result, |
257 IsError(ERR_CONNECTION_FAILED)); | 257 IsError(ERR_CONNECTION_FAILED)); |
258 } | 258 } |
259 | 259 |
260 TEST_F(SSLClientSocketPoolTest, BasicDirect) { | 260 TEST_F(SSLClientSocketPoolTest, BasicDirect) { |
261 StaticSocketDataProvider data; | 261 StaticSocketDataProvider data; |
262 data.set_connect_data(MockConnect(SYNCHRONOUS, OK)); | 262 data.set_connect_data(MockConnect(SYNCHRONOUS, OK)); |
263 socket_factory_.AddSocketDataProvider(&data); | 263 socket_factory_.AddSocketDataProvider(&data); |
264 SSLSocketDataProvider ssl(SYNCHRONOUS, OK); | 264 SSLSocketDataProvider ssl(SYNCHRONOUS, OK); |
265 socket_factory_.AddSSLSocketDataProvider(&ssl); | 265 socket_factory_.AddSSLSocketDataProvider(&ssl); |
266 | 266 |
267 CreatePool(true /* tcp pool */, false, false); | 267 CreatePool(true /* tcp pool */, false, false); |
268 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 268 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
269 false); | 269 false); |
270 | 270 |
271 ClientSocketHandle handle; | 271 ClientSocketHandle handle; |
272 TestCompletionCallback callback; | 272 TestCompletionCallback callback; |
273 int rv = | 273 int rv = |
274 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, | 274 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, |
275 callback.callback(), pool_.get(), BoundNetLog()); | 275 callback.callback(), pool_.get(), NetLogWithSource()); |
276 EXPECT_THAT(rv, IsOk()); | 276 EXPECT_THAT(rv, IsOk()); |
277 EXPECT_TRUE(handle.is_initialized()); | 277 EXPECT_TRUE(handle.is_initialized()); |
278 EXPECT_TRUE(handle.socket()); | 278 EXPECT_TRUE(handle.socket()); |
279 TestLoadTimingInfo(handle); | 279 TestLoadTimingInfo(handle); |
280 EXPECT_EQ(0u, handle.connection_attempts().size()); | 280 EXPECT_EQ(0u, handle.connection_attempts().size()); |
281 } | 281 } |
282 | 282 |
283 // Make sure that SSLConnectJob passes on its priority to its | 283 // Make sure that SSLConnectJob passes on its priority to its |
284 // socket request on Init (for the DIRECT case). | 284 // socket request on Init (for the DIRECT case). |
285 TEST_F(SSLClientSocketPoolTest, SetSocketRequestPriorityOnInitDirect) { | 285 TEST_F(SSLClientSocketPoolTest, SetSocketRequestPriorityOnInitDirect) { |
286 CreatePool(true /* tcp pool */, false, false); | 286 CreatePool(true /* tcp pool */, false, false); |
287 scoped_refptr<SSLSocketParams> params = | 287 scoped_refptr<SSLSocketParams> params = |
288 SSLParams(ProxyServer::SCHEME_DIRECT, false); | 288 SSLParams(ProxyServer::SCHEME_DIRECT, false); |
289 | 289 |
290 for (int i = MINIMUM_PRIORITY; i <= MAXIMUM_PRIORITY; ++i) { | 290 for (int i = MINIMUM_PRIORITY; i <= MAXIMUM_PRIORITY; ++i) { |
291 RequestPriority priority = static_cast<RequestPriority>(i); | 291 RequestPriority priority = static_cast<RequestPriority>(i); |
292 StaticSocketDataProvider data; | 292 StaticSocketDataProvider data; |
293 data.set_connect_data(MockConnect(SYNCHRONOUS, OK)); | 293 data.set_connect_data(MockConnect(SYNCHRONOUS, OK)); |
294 socket_factory_.AddSocketDataProvider(&data); | 294 socket_factory_.AddSocketDataProvider(&data); |
295 SSLSocketDataProvider ssl(SYNCHRONOUS, OK); | 295 SSLSocketDataProvider ssl(SYNCHRONOUS, OK); |
296 socket_factory_.AddSSLSocketDataProvider(&ssl); | 296 socket_factory_.AddSSLSocketDataProvider(&ssl); |
297 | 297 |
298 ClientSocketHandle handle; | 298 ClientSocketHandle handle; |
299 TestCompletionCallback callback; | 299 TestCompletionCallback callback; |
300 EXPECT_EQ(OK, handle.Init("a", params, priority, | 300 EXPECT_EQ( |
301 ClientSocketPool::RespectLimits::ENABLED, | 301 OK, handle.Init("a", params, priority, |
302 callback.callback(), pool_.get(), BoundNetLog())); | 302 ClientSocketPool::RespectLimits::ENABLED, |
| 303 callback.callback(), pool_.get(), NetLogWithSource())); |
303 EXPECT_EQ(priority, transport_socket_pool_.last_request_priority()); | 304 EXPECT_EQ(priority, transport_socket_pool_.last_request_priority()); |
304 handle.socket()->Disconnect(); | 305 handle.socket()->Disconnect(); |
305 } | 306 } |
306 } | 307 } |
307 | 308 |
308 TEST_F(SSLClientSocketPoolTest, BasicDirectAsync) { | 309 TEST_F(SSLClientSocketPoolTest, BasicDirectAsync) { |
309 StaticSocketDataProvider data; | 310 StaticSocketDataProvider data; |
310 socket_factory_.AddSocketDataProvider(&data); | 311 socket_factory_.AddSocketDataProvider(&data); |
311 SSLSocketDataProvider ssl(ASYNC, OK); | 312 SSLSocketDataProvider ssl(ASYNC, OK); |
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 TestCompletionCallback callback; | 320 TestCompletionCallback callback; |
320 int rv = | 321 int rv = |
321 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, | 322 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, |
322 callback.callback(), pool_.get(), BoundNetLog()); | 323 callback.callback(), pool_.get(), NetLogWithSource()); |
323 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); | 324 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
324 EXPECT_FALSE(handle.is_initialized()); | 325 EXPECT_FALSE(handle.is_initialized()); |
325 EXPECT_FALSE(handle.socket()); | 326 EXPECT_FALSE(handle.socket()); |
326 | 327 |
327 EXPECT_THAT(callback.WaitForResult(), IsOk()); | 328 EXPECT_THAT(callback.WaitForResult(), IsOk()); |
328 EXPECT_TRUE(handle.is_initialized()); | 329 EXPECT_TRUE(handle.is_initialized()); |
329 EXPECT_TRUE(handle.socket()); | 330 EXPECT_TRUE(handle.socket()); |
330 TestLoadTimingInfo(handle); | 331 TestLoadTimingInfo(handle); |
331 } | 332 } |
332 | 333 |
333 TEST_F(SSLClientSocketPoolTest, DirectCertError) { | 334 TEST_F(SSLClientSocketPoolTest, DirectCertError) { |
334 StaticSocketDataProvider data; | 335 StaticSocketDataProvider data; |
335 socket_factory_.AddSocketDataProvider(&data); | 336 socket_factory_.AddSocketDataProvider(&data); |
336 SSLSocketDataProvider ssl(ASYNC, ERR_CERT_COMMON_NAME_INVALID); | 337 SSLSocketDataProvider ssl(ASYNC, ERR_CERT_COMMON_NAME_INVALID); |
337 socket_factory_.AddSSLSocketDataProvider(&ssl); | 338 socket_factory_.AddSSLSocketDataProvider(&ssl); |
338 | 339 |
339 CreatePool(true /* tcp pool */, false, false); | 340 CreatePool(true /* tcp pool */, false, false); |
340 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 341 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
341 false); | 342 false); |
342 | 343 |
343 ClientSocketHandle handle; | 344 ClientSocketHandle handle; |
344 TestCompletionCallback callback; | 345 TestCompletionCallback callback; |
345 int rv = | 346 int rv = |
346 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, | 347 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, |
347 callback.callback(), pool_.get(), BoundNetLog()); | 348 callback.callback(), pool_.get(), NetLogWithSource()); |
348 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); | 349 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
349 EXPECT_FALSE(handle.is_initialized()); | 350 EXPECT_FALSE(handle.is_initialized()); |
350 EXPECT_FALSE(handle.socket()); | 351 EXPECT_FALSE(handle.socket()); |
351 | 352 |
352 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CERT_COMMON_NAME_INVALID)); | 353 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CERT_COMMON_NAME_INVALID)); |
353 EXPECT_TRUE(handle.is_initialized()); | 354 EXPECT_TRUE(handle.is_initialized()); |
354 EXPECT_TRUE(handle.socket()); | 355 EXPECT_TRUE(handle.socket()); |
355 TestLoadTimingInfo(handle); | 356 TestLoadTimingInfo(handle); |
356 } | 357 } |
357 | 358 |
358 TEST_F(SSLClientSocketPoolTest, DirectSSLError) { | 359 TEST_F(SSLClientSocketPoolTest, DirectSSLError) { |
359 StaticSocketDataProvider data; | 360 StaticSocketDataProvider data; |
360 socket_factory_.AddSocketDataProvider(&data); | 361 socket_factory_.AddSocketDataProvider(&data); |
361 SSLSocketDataProvider ssl(ASYNC, ERR_SSL_PROTOCOL_ERROR); | 362 SSLSocketDataProvider ssl(ASYNC, ERR_SSL_PROTOCOL_ERROR); |
362 socket_factory_.AddSSLSocketDataProvider(&ssl); | 363 socket_factory_.AddSSLSocketDataProvider(&ssl); |
363 | 364 |
364 CreatePool(true /* tcp pool */, false, false); | 365 CreatePool(true /* tcp pool */, false, false); |
365 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 366 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
366 false); | 367 false); |
367 | 368 |
368 ClientSocketHandle handle; | 369 ClientSocketHandle handle; |
369 TestCompletionCallback callback; | 370 TestCompletionCallback callback; |
370 int rv = | 371 int rv = |
371 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, | 372 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, |
372 callback.callback(), pool_.get(), BoundNetLog()); | 373 callback.callback(), pool_.get(), NetLogWithSource()); |
373 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); | 374 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
374 EXPECT_FALSE(handle.is_initialized()); | 375 EXPECT_FALSE(handle.is_initialized()); |
375 EXPECT_FALSE(handle.socket()); | 376 EXPECT_FALSE(handle.socket()); |
376 | 377 |
377 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_SSL_PROTOCOL_ERROR)); | 378 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_SSL_PROTOCOL_ERROR)); |
378 EXPECT_FALSE(handle.is_initialized()); | 379 EXPECT_FALSE(handle.is_initialized()); |
379 EXPECT_FALSE(handle.socket()); | 380 EXPECT_FALSE(handle.socket()); |
380 EXPECT_TRUE(handle.is_ssl_error()); | 381 EXPECT_TRUE(handle.is_ssl_error()); |
381 } | 382 } |
382 | 383 |
383 TEST_F(SSLClientSocketPoolTest, DirectWithNPN) { | 384 TEST_F(SSLClientSocketPoolTest, DirectWithNPN) { |
384 StaticSocketDataProvider data; | 385 StaticSocketDataProvider data; |
385 socket_factory_.AddSocketDataProvider(&data); | 386 socket_factory_.AddSocketDataProvider(&data); |
386 SSLSocketDataProvider ssl(ASYNC, OK); | 387 SSLSocketDataProvider ssl(ASYNC, OK); |
387 ssl.next_proto = kProtoHTTP11; | 388 ssl.next_proto = kProtoHTTP11; |
388 socket_factory_.AddSSLSocketDataProvider(&ssl); | 389 socket_factory_.AddSSLSocketDataProvider(&ssl); |
389 | 390 |
390 CreatePool(true /* tcp pool */, false, false); | 391 CreatePool(true /* tcp pool */, false, false); |
391 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 392 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
392 false); | 393 false); |
393 | 394 |
394 ClientSocketHandle handle; | 395 ClientSocketHandle handle; |
395 TestCompletionCallback callback; | 396 TestCompletionCallback callback; |
396 int rv = | 397 int rv = |
397 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, | 398 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, |
398 callback.callback(), pool_.get(), BoundNetLog()); | 399 callback.callback(), pool_.get(), NetLogWithSource()); |
399 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); | 400 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
400 EXPECT_FALSE(handle.is_initialized()); | 401 EXPECT_FALSE(handle.is_initialized()); |
401 EXPECT_FALSE(handle.socket()); | 402 EXPECT_FALSE(handle.socket()); |
402 | 403 |
403 EXPECT_THAT(callback.WaitForResult(), IsOk()); | 404 EXPECT_THAT(callback.WaitForResult(), IsOk()); |
404 EXPECT_TRUE(handle.is_initialized()); | 405 EXPECT_TRUE(handle.is_initialized()); |
405 EXPECT_TRUE(handle.socket()); | 406 EXPECT_TRUE(handle.socket()); |
406 TestLoadTimingInfo(handle); | 407 TestLoadTimingInfo(handle); |
407 SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(handle.socket()); | 408 SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(handle.socket()); |
408 EXPECT_TRUE(ssl_socket->WasNpnNegotiated()); | 409 EXPECT_TRUE(ssl_socket->WasNpnNegotiated()); |
409 } | 410 } |
410 | 411 |
411 TEST_F(SSLClientSocketPoolTest, DirectNoSPDY) { | 412 TEST_F(SSLClientSocketPoolTest, DirectNoSPDY) { |
412 StaticSocketDataProvider data; | 413 StaticSocketDataProvider data; |
413 socket_factory_.AddSocketDataProvider(&data); | 414 socket_factory_.AddSocketDataProvider(&data); |
414 SSLSocketDataProvider ssl(ASYNC, OK); | 415 SSLSocketDataProvider ssl(ASYNC, OK); |
415 ssl.next_proto = kProtoHTTP11; | 416 ssl.next_proto = kProtoHTTP11; |
416 socket_factory_.AddSSLSocketDataProvider(&ssl); | 417 socket_factory_.AddSSLSocketDataProvider(&ssl); |
417 | 418 |
418 CreatePool(true /* tcp pool */, false, false); | 419 CreatePool(true /* tcp pool */, false, false); |
419 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 420 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
420 true); | 421 true); |
421 | 422 |
422 ClientSocketHandle handle; | 423 ClientSocketHandle handle; |
423 TestCompletionCallback callback; | 424 TestCompletionCallback callback; |
424 int rv = | 425 int rv = |
425 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, | 426 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, |
426 callback.callback(), pool_.get(), BoundNetLog()); | 427 callback.callback(), pool_.get(), NetLogWithSource()); |
427 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); | 428 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
428 EXPECT_FALSE(handle.is_initialized()); | 429 EXPECT_FALSE(handle.is_initialized()); |
429 EXPECT_FALSE(handle.socket()); | 430 EXPECT_FALSE(handle.socket()); |
430 | 431 |
431 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_ALPN_NEGOTIATION_FAILED)); | 432 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_ALPN_NEGOTIATION_FAILED)); |
432 EXPECT_FALSE(handle.is_initialized()); | 433 EXPECT_FALSE(handle.is_initialized()); |
433 EXPECT_FALSE(handle.socket()); | 434 EXPECT_FALSE(handle.socket()); |
434 EXPECT_TRUE(handle.is_ssl_error()); | 435 EXPECT_TRUE(handle.is_ssl_error()); |
435 } | 436 } |
436 | 437 |
437 TEST_F(SSLClientSocketPoolTest, DirectGotSPDY) { | 438 TEST_F(SSLClientSocketPoolTest, DirectGotSPDY) { |
438 StaticSocketDataProvider data; | 439 StaticSocketDataProvider data; |
439 socket_factory_.AddSocketDataProvider(&data); | 440 socket_factory_.AddSocketDataProvider(&data); |
440 SSLSocketDataProvider ssl(ASYNC, OK); | 441 SSLSocketDataProvider ssl(ASYNC, OK); |
441 ssl.next_proto = kProtoHTTP2; | 442 ssl.next_proto = kProtoHTTP2; |
442 socket_factory_.AddSSLSocketDataProvider(&ssl); | 443 socket_factory_.AddSSLSocketDataProvider(&ssl); |
443 | 444 |
444 CreatePool(true /* tcp pool */, false, false); | 445 CreatePool(true /* tcp pool */, false, false); |
445 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 446 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
446 true); | 447 true); |
447 | 448 |
448 ClientSocketHandle handle; | 449 ClientSocketHandle handle; |
449 TestCompletionCallback callback; | 450 TestCompletionCallback callback; |
450 int rv = | 451 int rv = |
451 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, | 452 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, |
452 callback.callback(), pool_.get(), BoundNetLog()); | 453 callback.callback(), pool_.get(), NetLogWithSource()); |
453 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); | 454 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
454 EXPECT_FALSE(handle.is_initialized()); | 455 EXPECT_FALSE(handle.is_initialized()); |
455 EXPECT_FALSE(handle.socket()); | 456 EXPECT_FALSE(handle.socket()); |
456 | 457 |
457 EXPECT_THAT(callback.WaitForResult(), IsOk()); | 458 EXPECT_THAT(callback.WaitForResult(), IsOk()); |
458 EXPECT_TRUE(handle.is_initialized()); | 459 EXPECT_TRUE(handle.is_initialized()); |
459 EXPECT_TRUE(handle.socket()); | 460 EXPECT_TRUE(handle.socket()); |
460 TestLoadTimingInfo(handle); | 461 TestLoadTimingInfo(handle); |
461 | 462 |
462 SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(handle.socket()); | 463 SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(handle.socket()); |
463 EXPECT_TRUE(ssl_socket->WasNpnNegotiated()); | 464 EXPECT_TRUE(ssl_socket->WasNpnNegotiated()); |
464 EXPECT_EQ(kProtoHTTP2, ssl_socket->GetNegotiatedProtocol()); | 465 EXPECT_EQ(kProtoHTTP2, ssl_socket->GetNegotiatedProtocol()); |
465 } | 466 } |
466 | 467 |
467 TEST_F(SSLClientSocketPoolTest, DirectGotBonusSPDY) { | 468 TEST_F(SSLClientSocketPoolTest, DirectGotBonusSPDY) { |
468 StaticSocketDataProvider data; | 469 StaticSocketDataProvider data; |
469 socket_factory_.AddSocketDataProvider(&data); | 470 socket_factory_.AddSocketDataProvider(&data); |
470 SSLSocketDataProvider ssl(ASYNC, OK); | 471 SSLSocketDataProvider ssl(ASYNC, OK); |
471 ssl.next_proto = kProtoHTTP2; | 472 ssl.next_proto = kProtoHTTP2; |
472 socket_factory_.AddSSLSocketDataProvider(&ssl); | 473 socket_factory_.AddSSLSocketDataProvider(&ssl); |
473 | 474 |
474 CreatePool(true /* tcp pool */, false, false); | 475 CreatePool(true /* tcp pool */, false, false); |
475 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, | 476 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT, |
476 true); | 477 true); |
477 | 478 |
478 ClientSocketHandle handle; | 479 ClientSocketHandle handle; |
479 TestCompletionCallback callback; | 480 TestCompletionCallback callback; |
480 int rv = | 481 int rv = |
481 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, | 482 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, |
482 callback.callback(), pool_.get(), BoundNetLog()); | 483 callback.callback(), pool_.get(), NetLogWithSource()); |
483 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); | 484 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
484 EXPECT_FALSE(handle.is_initialized()); | 485 EXPECT_FALSE(handle.is_initialized()); |
485 EXPECT_FALSE(handle.socket()); | 486 EXPECT_FALSE(handle.socket()); |
486 | 487 |
487 EXPECT_THAT(callback.WaitForResult(), IsOk()); | 488 EXPECT_THAT(callback.WaitForResult(), IsOk()); |
488 EXPECT_TRUE(handle.is_initialized()); | 489 EXPECT_TRUE(handle.is_initialized()); |
489 EXPECT_TRUE(handle.socket()); | 490 EXPECT_TRUE(handle.socket()); |
490 TestLoadTimingInfo(handle); | 491 TestLoadTimingInfo(handle); |
491 | 492 |
492 SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(handle.socket()); | 493 SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(handle.socket()); |
493 EXPECT_TRUE(ssl_socket->WasNpnNegotiated()); | 494 EXPECT_TRUE(ssl_socket->WasNpnNegotiated()); |
494 EXPECT_EQ(kProtoHTTP2, ssl_socket->GetNegotiatedProtocol()); | 495 EXPECT_EQ(kProtoHTTP2, ssl_socket->GetNegotiatedProtocol()); |
495 } | 496 } |
496 | 497 |
497 TEST_F(SSLClientSocketPoolTest, SOCKSFail) { | 498 TEST_F(SSLClientSocketPoolTest, SOCKSFail) { |
498 StaticSocketDataProvider data; | 499 StaticSocketDataProvider data; |
499 data.set_connect_data(MockConnect(SYNCHRONOUS, ERR_CONNECTION_FAILED)); | 500 data.set_connect_data(MockConnect(SYNCHRONOUS, ERR_CONNECTION_FAILED)); |
500 socket_factory_.AddSocketDataProvider(&data); | 501 socket_factory_.AddSocketDataProvider(&data); |
501 | 502 |
502 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | 503 CreatePool(false, true /* http proxy pool */, true /* socks pool */); |
503 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5, | 504 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5, |
504 false); | 505 false); |
505 | 506 |
506 ClientSocketHandle handle; | 507 ClientSocketHandle handle; |
507 TestCompletionCallback callback; | 508 TestCompletionCallback callback; |
508 int rv = | 509 int rv = |
509 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, | 510 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, |
510 callback.callback(), pool_.get(), BoundNetLog()); | 511 callback.callback(), pool_.get(), NetLogWithSource()); |
511 EXPECT_THAT(rv, IsError(ERR_CONNECTION_FAILED)); | 512 EXPECT_THAT(rv, IsError(ERR_CONNECTION_FAILED)); |
512 EXPECT_FALSE(handle.is_initialized()); | 513 EXPECT_FALSE(handle.is_initialized()); |
513 EXPECT_FALSE(handle.socket()); | 514 EXPECT_FALSE(handle.socket()); |
514 EXPECT_FALSE(handle.is_ssl_error()); | 515 EXPECT_FALSE(handle.is_ssl_error()); |
515 } | 516 } |
516 | 517 |
517 TEST_F(SSLClientSocketPoolTest, SOCKSFailAsync) { | 518 TEST_F(SSLClientSocketPoolTest, SOCKSFailAsync) { |
518 StaticSocketDataProvider data; | 519 StaticSocketDataProvider data; |
519 data.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_FAILED)); | 520 data.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_FAILED)); |
520 socket_factory_.AddSocketDataProvider(&data); | 521 socket_factory_.AddSocketDataProvider(&data); |
521 | 522 |
522 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | 523 CreatePool(false, true /* http proxy pool */, true /* socks pool */); |
523 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5, | 524 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5, |
524 false); | 525 false); |
525 | 526 |
526 ClientSocketHandle handle; | 527 ClientSocketHandle handle; |
527 TestCompletionCallback callback; | 528 TestCompletionCallback callback; |
528 int rv = | 529 int rv = |
529 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, | 530 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, |
530 callback.callback(), pool_.get(), BoundNetLog()); | 531 callback.callback(), pool_.get(), NetLogWithSource()); |
531 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); | 532 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
532 EXPECT_FALSE(handle.is_initialized()); | 533 EXPECT_FALSE(handle.is_initialized()); |
533 EXPECT_FALSE(handle.socket()); | 534 EXPECT_FALSE(handle.socket()); |
534 | 535 |
535 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_FAILED)); | 536 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_FAILED)); |
536 EXPECT_FALSE(handle.is_initialized()); | 537 EXPECT_FALSE(handle.is_initialized()); |
537 EXPECT_FALSE(handle.socket()); | 538 EXPECT_FALSE(handle.socket()); |
538 EXPECT_FALSE(handle.is_ssl_error()); | 539 EXPECT_FALSE(handle.is_ssl_error()); |
539 } | 540 } |
540 | 541 |
541 TEST_F(SSLClientSocketPoolTest, SOCKSBasic) { | 542 TEST_F(SSLClientSocketPoolTest, SOCKSBasic) { |
542 StaticSocketDataProvider data; | 543 StaticSocketDataProvider data; |
543 data.set_connect_data(MockConnect(SYNCHRONOUS, OK)); | 544 data.set_connect_data(MockConnect(SYNCHRONOUS, OK)); |
544 socket_factory_.AddSocketDataProvider(&data); | 545 socket_factory_.AddSocketDataProvider(&data); |
545 SSLSocketDataProvider ssl(SYNCHRONOUS, OK); | 546 SSLSocketDataProvider ssl(SYNCHRONOUS, OK); |
546 socket_factory_.AddSSLSocketDataProvider(&ssl); | 547 socket_factory_.AddSSLSocketDataProvider(&ssl); |
547 | 548 |
548 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | 549 CreatePool(false, true /* http proxy pool */, true /* socks pool */); |
549 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5, | 550 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5, |
550 false); | 551 false); |
551 | 552 |
552 ClientSocketHandle handle; | 553 ClientSocketHandle handle; |
553 TestCompletionCallback callback; | 554 TestCompletionCallback callback; |
554 int rv = | 555 int rv = |
555 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, | 556 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, |
556 callback.callback(), pool_.get(), BoundNetLog()); | 557 callback.callback(), pool_.get(), NetLogWithSource()); |
557 EXPECT_THAT(rv, IsOk()); | 558 EXPECT_THAT(rv, IsOk()); |
558 EXPECT_TRUE(handle.is_initialized()); | 559 EXPECT_TRUE(handle.is_initialized()); |
559 EXPECT_TRUE(handle.socket()); | 560 EXPECT_TRUE(handle.socket()); |
560 // SOCKS5 generally has no DNS times, but the mock SOCKS5 sockets used here | 561 // SOCKS5 generally has no DNS times, but the mock SOCKS5 sockets used here |
561 // don't go through the real logic, unlike in the HTTP proxy tests. | 562 // don't go through the real logic, unlike in the HTTP proxy tests. |
562 TestLoadTimingInfo(handle); | 563 TestLoadTimingInfo(handle); |
563 } | 564 } |
564 | 565 |
565 // Make sure that SSLConnectJob passes on its priority to its | 566 // Make sure that SSLConnectJob passes on its priority to its |
566 // transport socket on Init (for the SOCKS_PROXY case). | 567 // transport socket on Init (for the SOCKS_PROXY case). |
567 TEST_F(SSLClientSocketPoolTest, SetTransportPriorityOnInitSOCKS) { | 568 TEST_F(SSLClientSocketPoolTest, SetTransportPriorityOnInitSOCKS) { |
568 StaticSocketDataProvider data; | 569 StaticSocketDataProvider data; |
569 data.set_connect_data(MockConnect(SYNCHRONOUS, OK)); | 570 data.set_connect_data(MockConnect(SYNCHRONOUS, OK)); |
570 socket_factory_.AddSocketDataProvider(&data); | 571 socket_factory_.AddSocketDataProvider(&data); |
571 SSLSocketDataProvider ssl(SYNCHRONOUS, OK); | 572 SSLSocketDataProvider ssl(SYNCHRONOUS, OK); |
572 socket_factory_.AddSSLSocketDataProvider(&ssl); | 573 socket_factory_.AddSSLSocketDataProvider(&ssl); |
573 | 574 |
574 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | 575 CreatePool(false, true /* http proxy pool */, true /* socks pool */); |
575 scoped_refptr<SSLSocketParams> params = | 576 scoped_refptr<SSLSocketParams> params = |
576 SSLParams(ProxyServer::SCHEME_SOCKS5, false); | 577 SSLParams(ProxyServer::SCHEME_SOCKS5, false); |
577 | 578 |
578 ClientSocketHandle handle; | 579 ClientSocketHandle handle; |
579 TestCompletionCallback callback; | 580 TestCompletionCallback callback; |
580 EXPECT_EQ(OK, handle.Init("a", params, HIGHEST, | 581 EXPECT_EQ(OK, |
581 ClientSocketPool::RespectLimits::ENABLED, | 582 handle.Init("a", params, HIGHEST, |
582 callback.callback(), pool_.get(), BoundNetLog())); | 583 ClientSocketPool::RespectLimits::ENABLED, |
| 584 callback.callback(), pool_.get(), NetLogWithSource())); |
583 EXPECT_EQ(HIGHEST, transport_socket_pool_.last_request_priority()); | 585 EXPECT_EQ(HIGHEST, transport_socket_pool_.last_request_priority()); |
584 } | 586 } |
585 | 587 |
586 TEST_F(SSLClientSocketPoolTest, SOCKSBasicAsync) { | 588 TEST_F(SSLClientSocketPoolTest, SOCKSBasicAsync) { |
587 StaticSocketDataProvider data; | 589 StaticSocketDataProvider data; |
588 socket_factory_.AddSocketDataProvider(&data); | 590 socket_factory_.AddSocketDataProvider(&data); |
589 SSLSocketDataProvider ssl(ASYNC, OK); | 591 SSLSocketDataProvider ssl(ASYNC, OK); |
590 socket_factory_.AddSSLSocketDataProvider(&ssl); | 592 socket_factory_.AddSSLSocketDataProvider(&ssl); |
591 | 593 |
592 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | 594 CreatePool(false, true /* http proxy pool */, true /* socks pool */); |
593 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5, | 595 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5, |
594 false); | 596 false); |
595 | 597 |
596 ClientSocketHandle handle; | 598 ClientSocketHandle handle; |
597 TestCompletionCallback callback; | 599 TestCompletionCallback callback; |
598 int rv = | 600 int rv = |
599 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, | 601 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, |
600 callback.callback(), pool_.get(), BoundNetLog()); | 602 callback.callback(), pool_.get(), NetLogWithSource()); |
601 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); | 603 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
602 EXPECT_FALSE(handle.is_initialized()); | 604 EXPECT_FALSE(handle.is_initialized()); |
603 EXPECT_FALSE(handle.socket()); | 605 EXPECT_FALSE(handle.socket()); |
604 | 606 |
605 EXPECT_THAT(callback.WaitForResult(), IsOk()); | 607 EXPECT_THAT(callback.WaitForResult(), IsOk()); |
606 EXPECT_TRUE(handle.is_initialized()); | 608 EXPECT_TRUE(handle.is_initialized()); |
607 EXPECT_TRUE(handle.socket()); | 609 EXPECT_TRUE(handle.socket()); |
608 // SOCKS5 generally has no DNS times, but the mock SOCKS5 sockets used here | 610 // SOCKS5 generally has no DNS times, but the mock SOCKS5 sockets used here |
609 // don't go through the real logic, unlike in the HTTP proxy tests. | 611 // don't go through the real logic, unlike in the HTTP proxy tests. |
610 TestLoadTimingInfo(handle); | 612 TestLoadTimingInfo(handle); |
611 } | 613 } |
612 | 614 |
613 TEST_F(SSLClientSocketPoolTest, HttpProxyFail) { | 615 TEST_F(SSLClientSocketPoolTest, HttpProxyFail) { |
614 StaticSocketDataProvider data; | 616 StaticSocketDataProvider data; |
615 data.set_connect_data(MockConnect(SYNCHRONOUS, ERR_CONNECTION_FAILED)); | 617 data.set_connect_data(MockConnect(SYNCHRONOUS, ERR_CONNECTION_FAILED)); |
616 socket_factory_.AddSocketDataProvider(&data); | 618 socket_factory_.AddSocketDataProvider(&data); |
617 | 619 |
618 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | 620 CreatePool(false, true /* http proxy pool */, true /* socks pool */); |
619 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, | 621 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, |
620 false); | 622 false); |
621 | 623 |
622 ClientSocketHandle handle; | 624 ClientSocketHandle handle; |
623 TestCompletionCallback callback; | 625 TestCompletionCallback callback; |
624 int rv = | 626 int rv = |
625 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, | 627 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, |
626 callback.callback(), pool_.get(), BoundNetLog()); | 628 callback.callback(), pool_.get(), NetLogWithSource()); |
627 EXPECT_THAT(rv, IsError(ERR_PROXY_CONNECTION_FAILED)); | 629 EXPECT_THAT(rv, IsError(ERR_PROXY_CONNECTION_FAILED)); |
628 EXPECT_FALSE(handle.is_initialized()); | 630 EXPECT_FALSE(handle.is_initialized()); |
629 EXPECT_FALSE(handle.socket()); | 631 EXPECT_FALSE(handle.socket()); |
630 EXPECT_FALSE(handle.is_ssl_error()); | 632 EXPECT_FALSE(handle.is_ssl_error()); |
631 } | 633 } |
632 | 634 |
633 TEST_F(SSLClientSocketPoolTest, HttpProxyFailAsync) { | 635 TEST_F(SSLClientSocketPoolTest, HttpProxyFailAsync) { |
634 StaticSocketDataProvider data; | 636 StaticSocketDataProvider data; |
635 data.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_FAILED)); | 637 data.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_FAILED)); |
636 socket_factory_.AddSocketDataProvider(&data); | 638 socket_factory_.AddSocketDataProvider(&data); |
637 | 639 |
638 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | 640 CreatePool(false, true /* http proxy pool */, true /* socks pool */); |
639 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, | 641 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, |
640 false); | 642 false); |
641 | 643 |
642 ClientSocketHandle handle; | 644 ClientSocketHandle handle; |
643 TestCompletionCallback callback; | 645 TestCompletionCallback callback; |
644 int rv = | 646 int rv = |
645 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, | 647 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, |
646 callback.callback(), pool_.get(), BoundNetLog()); | 648 callback.callback(), pool_.get(), NetLogWithSource()); |
647 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); | 649 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
648 EXPECT_FALSE(handle.is_initialized()); | 650 EXPECT_FALSE(handle.is_initialized()); |
649 EXPECT_FALSE(handle.socket()); | 651 EXPECT_FALSE(handle.socket()); |
650 | 652 |
651 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_PROXY_CONNECTION_FAILED)); | 653 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_PROXY_CONNECTION_FAILED)); |
652 EXPECT_FALSE(handle.is_initialized()); | 654 EXPECT_FALSE(handle.is_initialized()); |
653 EXPECT_FALSE(handle.socket()); | 655 EXPECT_FALSE(handle.socket()); |
654 EXPECT_FALSE(handle.is_ssl_error()); | 656 EXPECT_FALSE(handle.is_ssl_error()); |
655 } | 657 } |
656 | 658 |
(...skipping 17 matching lines...) Expand all Loading... |
674 socket_factory_.AddSSLSocketDataProvider(&ssl); | 676 socket_factory_.AddSSLSocketDataProvider(&ssl); |
675 | 677 |
676 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | 678 CreatePool(false, true /* http proxy pool */, true /* socks pool */); |
677 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, | 679 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, |
678 false); | 680 false); |
679 | 681 |
680 ClientSocketHandle handle; | 682 ClientSocketHandle handle; |
681 TestCompletionCallback callback; | 683 TestCompletionCallback callback; |
682 int rv = | 684 int rv = |
683 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, | 685 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, |
684 callback.callback(), pool_.get(), BoundNetLog()); | 686 callback.callback(), pool_.get(), NetLogWithSource()); |
685 EXPECT_THAT(rv, IsOk()); | 687 EXPECT_THAT(rv, IsOk()); |
686 EXPECT_TRUE(handle.is_initialized()); | 688 EXPECT_TRUE(handle.is_initialized()); |
687 EXPECT_TRUE(handle.socket()); | 689 EXPECT_TRUE(handle.socket()); |
688 TestLoadTimingInfoNoDns(handle); | 690 TestLoadTimingInfoNoDns(handle); |
689 } | 691 } |
690 | 692 |
691 // Make sure that SSLConnectJob passes on its priority to its | 693 // Make sure that SSLConnectJob passes on its priority to its |
692 // transport socket on Init (for the HTTP_PROXY case). | 694 // transport socket on Init (for the HTTP_PROXY case). |
693 TEST_F(SSLClientSocketPoolTest, SetTransportPriorityOnInitHTTP) { | 695 TEST_F(SSLClientSocketPoolTest, SetTransportPriorityOnInitHTTP) { |
694 MockWrite writes[] = { | 696 MockWrite writes[] = { |
(...skipping 13 matching lines...) Expand all Loading... |
708 AddAuthToCache(); | 710 AddAuthToCache(); |
709 SSLSocketDataProvider ssl(SYNCHRONOUS, OK); | 711 SSLSocketDataProvider ssl(SYNCHRONOUS, OK); |
710 socket_factory_.AddSSLSocketDataProvider(&ssl); | 712 socket_factory_.AddSSLSocketDataProvider(&ssl); |
711 | 713 |
712 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | 714 CreatePool(false, true /* http proxy pool */, true /* socks pool */); |
713 scoped_refptr<SSLSocketParams> params = | 715 scoped_refptr<SSLSocketParams> params = |
714 SSLParams(ProxyServer::SCHEME_HTTP, false); | 716 SSLParams(ProxyServer::SCHEME_HTTP, false); |
715 | 717 |
716 ClientSocketHandle handle; | 718 ClientSocketHandle handle; |
717 TestCompletionCallback callback; | 719 TestCompletionCallback callback; |
718 EXPECT_EQ(OK, handle.Init("a", params, HIGHEST, | 720 EXPECT_EQ(OK, |
719 ClientSocketPool::RespectLimits::ENABLED, | 721 handle.Init("a", params, HIGHEST, |
720 callback.callback(), pool_.get(), BoundNetLog())); | 722 ClientSocketPool::RespectLimits::ENABLED, |
| 723 callback.callback(), pool_.get(), NetLogWithSource())); |
721 EXPECT_EQ(HIGHEST, transport_socket_pool_.last_request_priority()); | 724 EXPECT_EQ(HIGHEST, transport_socket_pool_.last_request_priority()); |
722 } | 725 } |
723 | 726 |
724 TEST_F(SSLClientSocketPoolTest, HttpProxyBasicAsync) { | 727 TEST_F(SSLClientSocketPoolTest, HttpProxyBasicAsync) { |
725 MockWrite writes[] = { | 728 MockWrite writes[] = { |
726 MockWrite( | 729 MockWrite( |
727 "CONNECT host:80 HTTP/1.1\r\n" | 730 "CONNECT host:80 HTTP/1.1\r\n" |
728 "Host: host:80\r\n" | 731 "Host: host:80\r\n" |
729 "Proxy-Connection: keep-alive\r\n" | 732 "Proxy-Connection: keep-alive\r\n" |
730 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), | 733 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), |
731 }; | 734 }; |
732 MockRead reads[] = { | 735 MockRead reads[] = { |
733 MockRead("HTTP/1.1 200 Connection Established\r\n\r\n"), | 736 MockRead("HTTP/1.1 200 Connection Established\r\n\r\n"), |
734 }; | 737 }; |
735 StaticSocketDataProvider data(reads, arraysize(reads), writes, | 738 StaticSocketDataProvider data(reads, arraysize(reads), writes, |
736 arraysize(writes)); | 739 arraysize(writes)); |
737 socket_factory_.AddSocketDataProvider(&data); | 740 socket_factory_.AddSocketDataProvider(&data); |
738 AddAuthToCache(); | 741 AddAuthToCache(); |
739 SSLSocketDataProvider ssl(ASYNC, OK); | 742 SSLSocketDataProvider ssl(ASYNC, OK); |
740 socket_factory_.AddSSLSocketDataProvider(&ssl); | 743 socket_factory_.AddSSLSocketDataProvider(&ssl); |
741 | 744 |
742 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | 745 CreatePool(false, true /* http proxy pool */, true /* socks pool */); |
743 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, | 746 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, |
744 false); | 747 false); |
745 | 748 |
746 ClientSocketHandle handle; | 749 ClientSocketHandle handle; |
747 TestCompletionCallback callback; | 750 TestCompletionCallback callback; |
748 int rv = | 751 int rv = |
749 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, | 752 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, |
750 callback.callback(), pool_.get(), BoundNetLog()); | 753 callback.callback(), pool_.get(), NetLogWithSource()); |
751 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); | 754 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
752 EXPECT_FALSE(handle.is_initialized()); | 755 EXPECT_FALSE(handle.is_initialized()); |
753 EXPECT_FALSE(handle.socket()); | 756 EXPECT_FALSE(handle.socket()); |
754 | 757 |
755 EXPECT_THAT(callback.WaitForResult(), IsOk()); | 758 EXPECT_THAT(callback.WaitForResult(), IsOk()); |
756 EXPECT_TRUE(handle.is_initialized()); | 759 EXPECT_TRUE(handle.is_initialized()); |
757 EXPECT_TRUE(handle.socket()); | 760 EXPECT_TRUE(handle.socket()); |
758 TestLoadTimingInfoNoDns(handle); | 761 TestLoadTimingInfoNoDns(handle); |
759 } | 762 } |
760 | 763 |
(...skipping 17 matching lines...) Expand all Loading... |
778 socket_factory_.AddSSLSocketDataProvider(&ssl); | 781 socket_factory_.AddSSLSocketDataProvider(&ssl); |
779 | 782 |
780 CreatePool(false, true /* http proxy pool */, true /* socks pool */); | 783 CreatePool(false, true /* http proxy pool */, true /* socks pool */); |
781 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, | 784 scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP, |
782 false); | 785 false); |
783 | 786 |
784 ClientSocketHandle handle; | 787 ClientSocketHandle handle; |
785 TestCompletionCallback callback; | 788 TestCompletionCallback callback; |
786 int rv = | 789 int rv = |
787 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, | 790 handle.Init("a", params, MEDIUM, ClientSocketPool::RespectLimits::ENABLED, |
788 callback.callback(), pool_.get(), BoundNetLog()); | 791 callback.callback(), pool_.get(), NetLogWithSource()); |
789 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); | 792 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
790 EXPECT_FALSE(handle.is_initialized()); | 793 EXPECT_FALSE(handle.is_initialized()); |
791 EXPECT_FALSE(handle.socket()); | 794 EXPECT_FALSE(handle.socket()); |
792 | 795 |
793 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_PROXY_AUTH_REQUESTED)); | 796 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_PROXY_AUTH_REQUESTED)); |
794 EXPECT_FALSE(handle.is_initialized()); | 797 EXPECT_FALSE(handle.is_initialized()); |
795 EXPECT_FALSE(handle.socket()); | 798 EXPECT_FALSE(handle.socket()); |
796 EXPECT_FALSE(handle.is_ssl_error()); | 799 EXPECT_FALSE(handle.is_ssl_error()); |
797 const HttpResponseInfo& tunnel_info = handle.ssl_error_response_info(); | 800 const HttpResponseInfo& tunnel_info = handle.ssl_error_response_info(); |
798 EXPECT_EQ(tunnel_info.headers->response_code(), 407); | 801 EXPECT_EQ(tunnel_info.headers->response_code(), 407); |
(...skipping 19 matching lines...) Expand all Loading... |
818 host_resolver_.set_synchronous_mode(true); | 821 host_resolver_.set_synchronous_mode(true); |
819 std::unique_ptr<HostResolver::Request> req[arraysize(test_hosts)]; | 822 std::unique_ptr<HostResolver::Request> req[arraysize(test_hosts)]; |
820 for (size_t i = 0; i < arraysize(test_hosts); i++) { | 823 for (size_t i = 0; i < arraysize(test_hosts); i++) { |
821 host_resolver_.rules()->AddIPLiteralRule( | 824 host_resolver_.rules()->AddIPLiteralRule( |
822 test_hosts[i].name, test_hosts[i].iplist, std::string()); | 825 test_hosts[i].name, test_hosts[i].iplist, std::string()); |
823 | 826 |
824 // This test requires that the HostResolver cache be populated. Normal | 827 // This test requires that the HostResolver cache be populated. Normal |
825 // code would have done this already, but we do it manually. | 828 // code would have done this already, but we do it manually. |
826 HostResolver::RequestInfo info(HostPortPair(test_hosts[i].name, kTestPort)); | 829 HostResolver::RequestInfo info(HostPortPair(test_hosts[i].name, kTestPort)); |
827 host_resolver_.Resolve(info, DEFAULT_PRIORITY, &test_hosts[i].addresses, | 830 host_resolver_.Resolve(info, DEFAULT_PRIORITY, &test_hosts[i].addresses, |
828 CompletionCallback(), &req[i], BoundNetLog()); | 831 CompletionCallback(), &req[i], NetLogWithSource()); |
829 | 832 |
830 // Setup a SpdySessionKey | 833 // Setup a SpdySessionKey |
831 test_hosts[i].key = SpdySessionKey( | 834 test_hosts[i].key = SpdySessionKey( |
832 HostPortPair(test_hosts[i].name, kTestPort), ProxyServer::Direct(), | 835 HostPortPair(test_hosts[i].name, kTestPort), ProxyServer::Direct(), |
833 PRIVACY_MODE_DISABLED); | 836 PRIVACY_MODE_DISABLED); |
834 } | 837 } |
835 | 838 |
836 MockRead reads[] = { | 839 MockRead reads[] = { |
837 MockRead(ASYNC, ERR_IO_PENDING), | 840 MockRead(ASYNC, ERR_IO_PENDING), |
838 }; | 841 }; |
839 StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0); | 842 StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0); |
840 socket_factory_.AddSocketDataProvider(&data); | 843 socket_factory_.AddSocketDataProvider(&data); |
841 SSLSocketDataProvider ssl(ASYNC, OK); | 844 SSLSocketDataProvider ssl(ASYNC, OK); |
842 ssl.cert = X509Certificate::CreateFromBytes( | 845 ssl.cert = X509Certificate::CreateFromBytes( |
843 reinterpret_cast<const char*>(webkit_der), sizeof(webkit_der)); | 846 reinterpret_cast<const char*>(webkit_der), sizeof(webkit_der)); |
844 ssl.next_proto = kProtoHTTP2; | 847 ssl.next_proto = kProtoHTTP2; |
845 socket_factory_.AddSSLSocketDataProvider(&ssl); | 848 socket_factory_.AddSSLSocketDataProvider(&ssl); |
846 | 849 |
847 CreatePool(true /* tcp pool */, false, false); | 850 CreatePool(true /* tcp pool */, false, false); |
848 base::WeakPtr<SpdySession> spdy_session = | 851 base::WeakPtr<SpdySession> spdy_session = CreateSecureSpdySession( |
849 CreateSecureSpdySession(session_.get(), test_hosts[0].key, BoundNetLog()); | 852 session_.get(), test_hosts[0].key, NetLogWithSource()); |
850 | 853 |
851 EXPECT_TRUE( | 854 EXPECT_TRUE( |
852 HasSpdySession(session_->spdy_session_pool(), test_hosts[0].key)); | 855 HasSpdySession(session_->spdy_session_pool(), test_hosts[0].key)); |
853 EXPECT_FALSE( | 856 EXPECT_FALSE( |
854 HasSpdySession(session_->spdy_session_pool(), test_hosts[1].key)); | 857 HasSpdySession(session_->spdy_session_pool(), test_hosts[1].key)); |
855 EXPECT_TRUE( | 858 EXPECT_TRUE( |
856 HasSpdySession(session_->spdy_session_pool(), test_hosts[2].key)); | 859 HasSpdySession(session_->spdy_session_pool(), test_hosts[2].key)); |
857 | 860 |
858 session_->spdy_session_pool()->CloseAllSessions(); | 861 session_->spdy_session_pool()->CloseAllSessions(); |
859 } | 862 } |
(...skipping 14 matching lines...) Expand all Loading... |
874 TestCompletionCallback callback; | 877 TestCompletionCallback callback; |
875 int rv; | 878 int rv; |
876 std::unique_ptr<HostResolver::Request> req[arraysize(test_hosts)]; | 879 std::unique_ptr<HostResolver::Request> req[arraysize(test_hosts)]; |
877 for (size_t i = 0; i < arraysize(test_hosts); i++) { | 880 for (size_t i = 0; i < arraysize(test_hosts); i++) { |
878 host_resolver_.rules()->AddIPLiteralRule( | 881 host_resolver_.rules()->AddIPLiteralRule( |
879 test_hosts[i].name, test_hosts[i].iplist, std::string()); | 882 test_hosts[i].name, test_hosts[i].iplist, std::string()); |
880 | 883 |
881 // This test requires that the HostResolver cache be populated. Normal | 884 // This test requires that the HostResolver cache be populated. Normal |
882 // code would have done this already, but we do it manually. | 885 // code would have done this already, but we do it manually. |
883 HostResolver::RequestInfo info(HostPortPair(test_hosts[i].name, kTestPort)); | 886 HostResolver::RequestInfo info(HostPortPair(test_hosts[i].name, kTestPort)); |
884 rv = | 887 rv = host_resolver_.Resolve(info, DEFAULT_PRIORITY, |
885 host_resolver_.Resolve(info, DEFAULT_PRIORITY, &test_hosts[i].addresses, | 888 &test_hosts[i].addresses, callback.callback(), |
886 callback.callback(), &req[i], BoundNetLog()); | 889 &req[i], NetLogWithSource()); |
887 EXPECT_THAT(callback.GetResult(rv), IsOk()); | 890 EXPECT_THAT(callback.GetResult(rv), IsOk()); |
888 | 891 |
889 // Setup a SpdySessionKey | 892 // Setup a SpdySessionKey |
890 test_hosts[i].key = SpdySessionKey( | 893 test_hosts[i].key = SpdySessionKey( |
891 HostPortPair(test_hosts[i].name, kTestPort), ProxyServer::Direct(), | 894 HostPortPair(test_hosts[i].name, kTestPort), ProxyServer::Direct(), |
892 PRIVACY_MODE_DISABLED); | 895 PRIVACY_MODE_DISABLED); |
893 } | 896 } |
894 | 897 |
895 MockRead reads[] = { | 898 MockRead reads[] = { |
896 MockRead(ASYNC, ERR_IO_PENDING), | 899 MockRead(ASYNC, ERR_IO_PENDING), |
897 }; | 900 }; |
898 StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0); | 901 StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0); |
899 socket_factory_.AddSocketDataProvider(&data); | 902 socket_factory_.AddSocketDataProvider(&data); |
900 socket_factory_.AddSSLSocketDataProvider(ssl); | 903 socket_factory_.AddSSLSocketDataProvider(ssl); |
901 | 904 |
902 CreatePool(true /* tcp pool */, false, false); | 905 CreatePool(true /* tcp pool */, false, false); |
903 base::WeakPtr<SpdySession> spdy_session = | 906 base::WeakPtr<SpdySession> spdy_session = CreateSecureSpdySession( |
904 CreateSecureSpdySession(session_.get(), test_hosts[0].key, BoundNetLog()); | 907 session_.get(), test_hosts[0].key, NetLogWithSource()); |
905 | 908 |
906 EXPECT_TRUE( | 909 EXPECT_TRUE( |
907 HasSpdySession(session_->spdy_session_pool(), test_hosts[0].key)); | 910 HasSpdySession(session_->spdy_session_pool(), test_hosts[0].key)); |
908 EXPECT_FALSE( | 911 EXPECT_FALSE( |
909 HasSpdySession(session_->spdy_session_pool(), test_hosts[1].key)); | 912 HasSpdySession(session_->spdy_session_pool(), test_hosts[1].key)); |
910 | 913 |
911 session_->spdy_session_pool()->CloseAllSessions(); | 914 session_->spdy_session_pool()->CloseAllSessions(); |
912 } | 915 } |
913 | 916 |
914 // Verifies that an SSL connection with client authentication disables SPDY IP | 917 // Verifies that an SSL connection with client authentication disables SPDY IP |
(...skipping 13 matching lines...) Expand all Loading... |
928 ssl.channel_id_sent = true; | 931 ssl.channel_id_sent = true; |
929 ssl.next_proto = kProtoHTTP2; | 932 ssl.next_proto = kProtoHTTP2; |
930 TestIPPoolingDisabled(&ssl); | 933 TestIPPoolingDisabled(&ssl); |
931 } | 934 } |
932 | 935 |
933 // It would be nice to also test the timeouts in SSLClientSocketPool. | 936 // It would be nice to also test the timeouts in SSLClientSocketPool. |
934 | 937 |
935 } // namespace | 938 } // namespace |
936 | 939 |
937 } // namespace net | 940 } // namespace net |
OLD | NEW |