Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(820)

Side by Side Diff: net/socket/ssl_client_socket_pool_unittest.cc

Issue 2351513002: net: rename BoundNetLog to NetLogWithSource (Closed)
Patch Set: one more fix, content bound_net_log_ Created 4 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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
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
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
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
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
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
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
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
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698