OLD | NEW |
1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2013 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/spdy/chromium/spdy_test_util_common.h" | 5 #include "net/spdy/chromium/spdy_test_util_common.h" |
6 | 6 |
7 #include <stdint.h> | 7 #include <stdint.h> |
8 | 8 |
9 #include <cstddef> | 9 #include <cstddef> |
10 #include <utility> | 10 #include <utility> |
(...skipping 358 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
369 SpdySessionDependencies* session_deps) { | 369 SpdySessionDependencies* session_deps) { |
370 return SpdyCreateSessionWithSocketFactory(session_deps, | 370 return SpdyCreateSessionWithSocketFactory(session_deps, |
371 session_deps->socket_factory.get()); | 371 session_deps->socket_factory.get()); |
372 } | 372 } |
373 | 373 |
374 // static | 374 // static |
375 std::unique_ptr<HttpNetworkSession> | 375 std::unique_ptr<HttpNetworkSession> |
376 SpdySessionDependencies::SpdyCreateSessionWithSocketFactory( | 376 SpdySessionDependencies::SpdyCreateSessionWithSocketFactory( |
377 SpdySessionDependencies* session_deps, | 377 SpdySessionDependencies* session_deps, |
378 ClientSocketFactory* factory) { | 378 ClientSocketFactory* factory) { |
379 HttpNetworkSession::Params params = CreateSessionParams(session_deps); | 379 HttpNetworkSession::Params session_params = CreateSessionParams(session_deps); |
380 params.client_socket_factory = factory; | 380 HttpNetworkSession::Context session_context = |
381 auto http_session = base::MakeUnique<HttpNetworkSession>(params); | 381 CreateSessionContext(session_deps); |
| 382 session_context.client_socket_factory = factory; |
| 383 auto http_session = |
| 384 base::MakeUnique<HttpNetworkSession>(session_params, session_context); |
382 SpdySessionPoolPeer pool_peer(http_session->spdy_session_pool()); | 385 SpdySessionPoolPeer pool_peer(http_session->spdy_session_pool()); |
383 pool_peer.SetEnableSendingInitialData(false); | 386 pool_peer.SetEnableSendingInitialData(false); |
384 return http_session; | 387 return http_session; |
385 } | 388 } |
386 | 389 |
387 // static | 390 // static |
388 HttpNetworkSession::Params SpdySessionDependencies::CreateSessionParams( | 391 HttpNetworkSession::Params SpdySessionDependencies::CreateSessionParams( |
389 SpdySessionDependencies* session_deps) { | 392 SpdySessionDependencies* session_deps) { |
390 HttpNetworkSession::Params params; | 393 HttpNetworkSession::Params params; |
391 params.host_resolver = session_deps->host_resolver.get(); | |
392 params.cert_verifier = session_deps->cert_verifier.get(); | |
393 params.channel_id_service = session_deps->channel_id_service.get(); | |
394 params.transport_security_state = | |
395 session_deps->transport_security_state.get(); | |
396 params.cert_transparency_verifier = | |
397 session_deps->cert_transparency_verifier.get(); | |
398 params.ct_policy_enforcer = session_deps->ct_policy_enforcer.get(); | |
399 params.proxy_service = session_deps->proxy_service.get(); | |
400 params.ssl_config_service = session_deps->ssl_config_service.get(); | |
401 params.http_auth_handler_factory = | |
402 session_deps->http_auth_handler_factory.get(); | |
403 params.http_server_properties = session_deps->http_server_properties.get(); | |
404 params.enable_spdy_ping_based_connection_checking = session_deps->enable_ping; | 394 params.enable_spdy_ping_based_connection_checking = session_deps->enable_ping; |
405 params.enable_user_alternate_protocol_ports = | 395 params.enable_user_alternate_protocol_ports = |
406 session_deps->enable_user_alternate_protocol_ports; | 396 session_deps->enable_user_alternate_protocol_ports; |
407 params.enable_quic = session_deps->enable_quic; | 397 params.enable_quic = session_deps->enable_quic; |
408 params.enable_server_push_cancellation = | 398 params.enable_server_push_cancellation = |
409 session_deps->enable_server_push_cancellation; | 399 session_deps->enable_server_push_cancellation; |
410 params.spdy_session_max_recv_window_size = | 400 params.spdy_session_max_recv_window_size = |
411 session_deps->session_max_recv_window_size; | 401 session_deps->session_max_recv_window_size; |
412 params.http2_settings = session_deps->http2_settings; | 402 params.http2_settings = session_deps->http2_settings; |
413 params.time_func = session_deps->time_func; | 403 params.time_func = session_deps->time_func; |
414 params.proxy_delegate = session_deps->proxy_delegate.get(); | |
415 params.enable_http2_alternative_service = | 404 params.enable_http2_alternative_service = |
416 session_deps->enable_http2_alternative_service; | 405 session_deps->enable_http2_alternative_service; |
417 params.net_log = session_deps->net_log; | |
418 params.http_09_on_non_default_ports_enabled = | 406 params.http_09_on_non_default_ports_enabled = |
419 session_deps->http_09_on_non_default_ports_enabled; | 407 session_deps->http_09_on_non_default_ports_enabled; |
420 return params; | 408 return params; |
421 } | 409 } |
422 | 410 |
| 411 HttpNetworkSession::Context SpdySessionDependencies::CreateSessionContext( |
| 412 SpdySessionDependencies* session_deps) { |
| 413 HttpNetworkSession::Context context; |
| 414 context.host_resolver = session_deps->host_resolver.get(); |
| 415 context.cert_verifier = session_deps->cert_verifier.get(); |
| 416 context.channel_id_service = session_deps->channel_id_service.get(); |
| 417 context.transport_security_state = |
| 418 session_deps->transport_security_state.get(); |
| 419 context.cert_transparency_verifier = |
| 420 session_deps->cert_transparency_verifier.get(); |
| 421 context.ct_policy_enforcer = session_deps->ct_policy_enforcer.get(); |
| 422 context.proxy_service = session_deps->proxy_service.get(); |
| 423 context.ssl_config_service = session_deps->ssl_config_service.get(); |
| 424 context.http_auth_handler_factory = |
| 425 session_deps->http_auth_handler_factory.get(); |
| 426 context.http_server_properties = session_deps->http_server_properties.get(); |
| 427 context.proxy_delegate = session_deps->proxy_delegate.get(); |
| 428 context.net_log = session_deps->net_log; |
| 429 return context; |
| 430 } |
| 431 |
423 class AllowAnyCertCTPolicyEnforcer : public CTPolicyEnforcer { | 432 class AllowAnyCertCTPolicyEnforcer : public CTPolicyEnforcer { |
424 public: | 433 public: |
425 AllowAnyCertCTPolicyEnforcer() {} | 434 AllowAnyCertCTPolicyEnforcer() {} |
426 ~AllowAnyCertCTPolicyEnforcer() override = default; | 435 ~AllowAnyCertCTPolicyEnforcer() override = default; |
427 | 436 |
428 ct::CertPolicyCompliance DoesConformToCertPolicy( | 437 ct::CertPolicyCompliance DoesConformToCertPolicy( |
429 X509Certificate* cert, | 438 X509Certificate* cert, |
430 const SCTList& verified_scts, | 439 const SCTList& verified_scts, |
431 const NetLogWithSource& net_log) override { | 440 const NetLogWithSource& net_log) override { |
432 return ct::CertPolicyCompliance::CERT_POLICY_COMPLIES_VIA_SCTS; | 441 return ct::CertPolicyCompliance::CERT_POLICY_COMPLIES_VIA_SCTS; |
(...skipping 18 matching lines...) Expand all Loading... |
451 storage_.set_ct_policy_enforcer( | 460 storage_.set_ct_policy_enforcer( |
452 base::WrapUnique(new AllowAnyCertCTPolicyEnforcer())); | 461 base::WrapUnique(new AllowAnyCertCTPolicyEnforcer())); |
453 storage_.set_cert_transparency_verifier( | 462 storage_.set_cert_transparency_verifier( |
454 base::WrapUnique(new DoNothingCTVerifier())); | 463 base::WrapUnique(new DoNothingCTVerifier())); |
455 storage_.set_ssl_config_service(new SSLConfigServiceDefaults); | 464 storage_.set_ssl_config_service(new SSLConfigServiceDefaults); |
456 storage_.set_http_auth_handler_factory( | 465 storage_.set_http_auth_handler_factory( |
457 HttpAuthHandlerFactory::CreateDefault(host_resolver())); | 466 HttpAuthHandlerFactory::CreateDefault(host_resolver())); |
458 storage_.set_http_server_properties( | 467 storage_.set_http_server_properties( |
459 std::unique_ptr<HttpServerProperties>(new HttpServerPropertiesImpl())); | 468 std::unique_ptr<HttpServerProperties>(new HttpServerPropertiesImpl())); |
460 storage_.set_job_factory(base::MakeUnique<URLRequestJobFactoryImpl>()); | 469 storage_.set_job_factory(base::MakeUnique<URLRequestJobFactoryImpl>()); |
461 HttpNetworkSession::Params params; | 470 HttpNetworkSession::Params session_params; |
462 params.client_socket_factory = &socket_factory_; | 471 session_params.enable_spdy_ping_based_connection_checking = false; |
463 params.host_resolver = host_resolver(); | 472 |
464 params.cert_verifier = cert_verifier(); | 473 HttpNetworkSession::Context session_context; |
465 params.transport_security_state = transport_security_state(); | 474 session_context.client_socket_factory = &socket_factory_; |
466 params.proxy_service = proxy_service(); | 475 session_context.host_resolver = host_resolver(); |
467 params.ct_policy_enforcer = ct_policy_enforcer(); | 476 session_context.cert_verifier = cert_verifier(); |
468 params.cert_transparency_verifier = cert_transparency_verifier(); | 477 session_context.transport_security_state = transport_security_state(); |
469 params.ssl_config_service = ssl_config_service(); | 478 session_context.proxy_service = proxy_service(); |
470 params.http_auth_handler_factory = http_auth_handler_factory(); | 479 session_context.ct_policy_enforcer = ct_policy_enforcer(); |
471 params.enable_spdy_ping_based_connection_checking = false; | 480 session_context.cert_transparency_verifier = cert_transparency_verifier(); |
472 params.http_server_properties = http_server_properties(); | 481 session_context.ssl_config_service = ssl_config_service(); |
| 482 session_context.http_auth_handler_factory = http_auth_handler_factory(); |
| 483 session_context.http_server_properties = http_server_properties(); |
473 storage_.set_http_network_session( | 484 storage_.set_http_network_session( |
474 base::MakeUnique<HttpNetworkSession>(params)); | 485 base::MakeUnique<HttpNetworkSession>(session_params, session_context)); |
475 SpdySessionPoolPeer pool_peer( | 486 SpdySessionPoolPeer pool_peer( |
476 storage_.http_network_session()->spdy_session_pool()); | 487 storage_.http_network_session()->spdy_session_pool()); |
477 pool_peer.SetEnableSendingInitialData(false); | 488 pool_peer.SetEnableSendingInitialData(false); |
478 storage_.set_http_transaction_factory(base::MakeUnique<HttpCache>( | 489 storage_.set_http_transaction_factory(base::MakeUnique<HttpCache>( |
479 storage_.http_network_session(), HttpCache::DefaultBackend::InMemory(0), | 490 storage_.http_network_session(), HttpCache::DefaultBackend::InMemory(0), |
480 false)); | 491 false)); |
481 } | 492 } |
482 | 493 |
483 SpdyURLRequestContext::~SpdyURLRequestContext() { | 494 SpdyURLRequestContext::~SpdyURLRequestContext() { |
484 AssertNoURLRequests(); | 495 AssertNoURLRequests(); |
(...skipping 670 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1155 headers[GetSchemeKey()] = scheme.c_str(); | 1166 headers[GetSchemeKey()] = scheme.c_str(); |
1156 headers[GetPathKey()] = path.c_str(); | 1167 headers[GetPathKey()] = path.c_str(); |
1157 if (content_length) { | 1168 if (content_length) { |
1158 SpdyString length_str = base::Int64ToString(*content_length); | 1169 SpdyString length_str = base::Int64ToString(*content_length); |
1159 headers["content-length"] = length_str; | 1170 headers["content-length"] = length_str; |
1160 } | 1171 } |
1161 return headers; | 1172 return headers; |
1162 } | 1173 } |
1163 | 1174 |
1164 } // namespace net | 1175 } // namespace net |
OLD | NEW |