http_stream_factory.cc 7.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200
  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
  3. // found in the LICENSE file.
  4. #include "net/http/http_stream_factory.h"
  5. #include <tuple>
  6. #include <utility>
  7. #include "base/check.h"
  8. #include "base/metrics/histogram_macros.h"
  9. #include "base/notreached.h"
  10. #include "base/strings/string_number_conversions.h"
  11. #include "base/strings/string_split.h"
  12. #include "base/strings/string_util.h"
  13. #include "base/strings/stringprintf.h"
  14. #include "base/time/time.h"
  15. #include "net/base/host_mapping_rules.h"
  16. #include "net/base/host_port_pair.h"
  17. #include "net/base/network_isolation_key.h"
  18. #include "net/base/parse_number.h"
  19. #include "net/base/port_util.h"
  20. #include "net/http/http_network_session.h"
  21. #include "net/http/http_response_headers.h"
  22. #include "net/http/http_server_properties.h"
  23. #include "net/http/http_stream_factory_job.h"
  24. #include "net/http/http_stream_factory_job_controller.h"
  25. #include "net/http/transport_security_state.h"
  26. #include "net/quic/quic_http_utils.h"
  27. #include "net/spdy/bidirectional_stream_spdy_impl.h"
  28. #include "net/spdy/spdy_http_stream.h"
  29. #include "net/third_party/quiche/src/quiche/quic/core/quic_packets.h"
  30. #include "net/third_party/quiche/src/quiche/quic/core/quic_server_id.h"
  31. #include "net/third_party/quiche/src/quiche/spdy/core/spdy_alt_svc_wire_format.h"
  32. #include "url/gurl.h"
  33. #include "url/scheme_host_port.h"
  34. #include "url/url_constants.h"
  35. namespace net {
  36. namespace {
  37. const char kAlternativeServiceHeader[] = "Alt-Svc";
  38. } // namespace
  39. HttpStreamFactory::HttpStreamFactory(HttpNetworkSession* session)
  40. : session_(session), job_factory_(std::make_unique<JobFactory>()) {}
  41. HttpStreamFactory::~HttpStreamFactory() = default;
  42. void HttpStreamFactory::ProcessAlternativeServices(
  43. HttpNetworkSession* session,
  44. const net::NetworkIsolationKey& network_isolation_key,
  45. const HttpResponseHeaders* headers,
  46. const url::SchemeHostPort& http_server) {
  47. if (!headers->HasHeader(kAlternativeServiceHeader))
  48. return;
  49. std::string alternative_service_str;
  50. headers->GetNormalizedHeader(kAlternativeServiceHeader,
  51. &alternative_service_str);
  52. spdy::SpdyAltSvcWireFormat::AlternativeServiceVector
  53. alternative_service_vector;
  54. if (!spdy::SpdyAltSvcWireFormat::ParseHeaderFieldValue(
  55. alternative_service_str, &alternative_service_vector)) {
  56. return;
  57. }
  58. session->http_server_properties()->SetAlternativeServices(
  59. RewriteHost(http_server), network_isolation_key,
  60. net::ProcessAlternativeServices(
  61. alternative_service_vector, session->params().enable_http2,
  62. session->params().enable_quic,
  63. session->context().quic_context->params()->supported_versions));
  64. }
  65. url::SchemeHostPort HttpStreamFactory::RewriteHost(
  66. const url::SchemeHostPort& server) {
  67. HostPortPair host_port_pair(server.host(), server.port());
  68. const HostMappingRules* mapping_rules = GetHostMappingRules();
  69. if (mapping_rules)
  70. mapping_rules->RewriteHost(&host_port_pair);
  71. return url::SchemeHostPort(server.scheme(), host_port_pair.host(),
  72. host_port_pair.port());
  73. }
  74. std::unique_ptr<HttpStreamRequest> HttpStreamFactory::RequestStream(
  75. const HttpRequestInfo& request_info,
  76. RequestPriority priority,
  77. const SSLConfig& server_ssl_config,
  78. const SSLConfig& proxy_ssl_config,
  79. HttpStreamRequest::Delegate* delegate,
  80. bool enable_ip_based_pooling,
  81. bool enable_alternative_services,
  82. const NetLogWithSource& net_log) {
  83. return RequestStreamInternal(
  84. request_info, priority, server_ssl_config, proxy_ssl_config, delegate,
  85. nullptr, HttpStreamRequest::HTTP_STREAM, false /* is_websocket */,
  86. enable_ip_based_pooling, enable_alternative_services, net_log);
  87. }
  88. std::unique_ptr<HttpStreamRequest>
  89. HttpStreamFactory::RequestWebSocketHandshakeStream(
  90. const HttpRequestInfo& request_info,
  91. RequestPriority priority,
  92. const SSLConfig& server_ssl_config,
  93. const SSLConfig& proxy_ssl_config,
  94. HttpStreamRequest::Delegate* delegate,
  95. WebSocketHandshakeStreamBase::CreateHelper* create_helper,
  96. bool enable_ip_based_pooling,
  97. bool enable_alternative_services,
  98. const NetLogWithSource& net_log) {
  99. DCHECK(create_helper);
  100. return RequestStreamInternal(
  101. request_info, priority, server_ssl_config, proxy_ssl_config, delegate,
  102. create_helper, HttpStreamRequest::HTTP_STREAM, true /* is_websocket */,
  103. enable_ip_based_pooling, enable_alternative_services, net_log);
  104. }
  105. std::unique_ptr<HttpStreamRequest>
  106. HttpStreamFactory::RequestBidirectionalStreamImpl(
  107. const HttpRequestInfo& request_info,
  108. RequestPriority priority,
  109. const SSLConfig& server_ssl_config,
  110. const SSLConfig& proxy_ssl_config,
  111. HttpStreamRequest::Delegate* delegate,
  112. bool enable_ip_based_pooling,
  113. bool enable_alternative_services,
  114. const NetLogWithSource& net_log) {
  115. DCHECK(request_info.url.SchemeIs(url::kHttpsScheme));
  116. return RequestStreamInternal(
  117. request_info, priority, server_ssl_config, proxy_ssl_config, delegate,
  118. nullptr, HttpStreamRequest::BIDIRECTIONAL_STREAM,
  119. false /* is_websocket */, enable_ip_based_pooling,
  120. enable_alternative_services, net_log);
  121. }
  122. std::unique_ptr<HttpStreamRequest> HttpStreamFactory::RequestStreamInternal(
  123. const HttpRequestInfo& request_info,
  124. RequestPriority priority,
  125. const SSLConfig& server_ssl_config,
  126. const SSLConfig& proxy_ssl_config,
  127. HttpStreamRequest::Delegate* delegate,
  128. WebSocketHandshakeStreamBase::CreateHelper*
  129. websocket_handshake_stream_create_helper,
  130. HttpStreamRequest::StreamType stream_type,
  131. bool is_websocket,
  132. bool enable_ip_based_pooling,
  133. bool enable_alternative_services,
  134. const NetLogWithSource& net_log) {
  135. auto job_controller = std::make_unique<JobController>(
  136. this, delegate, session_, job_factory_.get(), request_info,
  137. /* is_preconnect = */ false, is_websocket, enable_ip_based_pooling,
  138. enable_alternative_services,
  139. session_->context()
  140. .quic_context->params()
  141. ->delay_main_job_with_available_spdy_session,
  142. server_ssl_config, proxy_ssl_config);
  143. JobController* job_controller_raw_ptr = job_controller.get();
  144. job_controller_set_.insert(std::move(job_controller));
  145. return job_controller_raw_ptr->Start(delegate,
  146. websocket_handshake_stream_create_helper,
  147. net_log, stream_type, priority);
  148. }
  149. void HttpStreamFactory::PreconnectStreams(int num_streams,
  150. const HttpRequestInfo& request_info) {
  151. DCHECK(request_info.url.is_valid());
  152. auto job_controller = std::make_unique<JobController>(
  153. this, nullptr, session_, job_factory_.get(), request_info,
  154. /*is_preconnect=*/true,
  155. /*is_websocket=*/false,
  156. /*enable_ip_based_pooling=*/true,
  157. /*enable_alternative_services=*/true,
  158. session_->context()
  159. .quic_context->params()
  160. ->delay_main_job_with_available_spdy_session,
  161. /*server_ssl_config=*/SSLConfig(),
  162. /*proxy_ssl_config=*/SSLConfig());
  163. JobController* job_controller_raw_ptr = job_controller.get();
  164. job_controller_set_.insert(std::move(job_controller));
  165. job_controller_raw_ptr->Preconnect(num_streams);
  166. }
  167. const HostMappingRules* HttpStreamFactory::GetHostMappingRules() const {
  168. return &session_->params().host_mapping_rules;
  169. }
  170. void HttpStreamFactory::OnJobControllerComplete(JobController* controller) {
  171. auto it = job_controller_set_.find(controller);
  172. if (it != job_controller_set_.end()) {
  173. job_controller_set_.erase(it);
  174. } else {
  175. NOTREACHED();
  176. }
  177. }
  178. } // namespace net