net/http/http_stream_factory_impl.cc

   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
   5 #include "net/http/http_stream_factory_impl.h"
   6
   7 #include <string>
   8
   9 #include "base/logging.h"
  10 #include "base/stl_util.h"
  11 #include "net/base/net_util.h"
  12 #include "net/http/http_network_session.h"
  13 #include "net/http/http_server_properties.h"
  14 #include "net/http/http_stream_factory_impl_job.h"
  15 #include "net/http/http_stream_factory_impl_request.h"
  16 #include "net/log/net_log.h"
  17 #include "net/spdy/spdy_http_stream.h"
  18 #include "url/gurl.h"
  19
  20 namespace net {
  21
  22 HttpStreamFactoryImpl::HttpStreamFactoryImpl(HttpNetworkSession* session,
  23                                              bool for_websockets)
  24     : session_(session),
  25       for_websockets_(for_websockets) {}
  26
  27 HttpStreamFactoryImpl::~HttpStreamFactoryImpl() {
  28   DCHECK(request_map_.empty());
  29   DCHECK(spdy_session_request_map_.empty());
  30
  31   std::set<const Job*> tmp_job_set;
  32   tmp_job_set.swap(orphaned_job_set_);
  33   STLDeleteContainerPointers(tmp_job_set.begin(), tmp_job_set.end());
  34   DCHECK(orphaned_job_set_.empty());
  35
  36   tmp_job_set.clear();
  37   tmp_job_set.swap(preconnect_job_set_);
  38   STLDeleteContainerPointers(tmp_job_set.begin(), tmp_job_set.end());
  39   DCHECK(preconnect_job_set_.empty());
  40 }
  41
  42 HttpStreamRequest* HttpStreamFactoryImpl::RequestStream(
  43     const HttpRequestInfo& request_info,
  44     RequestPriority priority,
  45     const SSLConfig& server_ssl_config,
  46     const SSLConfig& proxy_ssl_config,
  47     HttpStreamRequest::Delegate* delegate,
  48     const BoundNetLog& net_log) {
  49   DCHECK(!for_websockets_);
  50   return RequestStreamInternal(request_info,
  51                                priority,
  52                                server_ssl_config,
  53                                proxy_ssl_config,
  54                                delegate,
  55                                NULL,
  56                                net_log);
  57 }
  58
  59 HttpStreamRequest* HttpStreamFactoryImpl::RequestWebSocketHandshakeStream(
  60     const HttpRequestInfo& request_info,
  61     RequestPriority priority,
  62     const SSLConfig& server_ssl_config,
  63     const SSLConfig& proxy_ssl_config,
  64     HttpStreamRequest::Delegate* delegate,
  65     WebSocketHandshakeStreamBase::CreateHelper* create_helper,
  66     const BoundNetLog& net_log) {
  67   DCHECK(for_websockets_);
  68   DCHECK(create_helper);
  69   return RequestStreamInternal(request_info,
  70                                priority,
  71                                server_ssl_config,
  72                                proxy_ssl_config,
  73                                delegate,
  74                                create_helper,
  75                                net_log);
  76 }
  77
  78 HttpStreamRequest* HttpStreamFactoryImpl::RequestStreamInternal(
  79     const HttpRequestInfo& request_info,
  80     RequestPriority priority,
  81     const SSLConfig& server_ssl_config,
  82     const SSLConfig& proxy_ssl_config,
  83     HttpStreamRequest::Delegate* delegate,
  84     WebSocketHandshakeStreamBase::CreateHelper*
  85         websocket_handshake_stream_create_helper,
  86     const BoundNetLog& net_log) {
  87   Request* request = new Request(request_info.url,
  88                                  this,
  89                                  delegate,
  90                                  websocket_handshake_stream_create_helper,
  91                                  net_log);
  92   Job* job = new Job(this, session_, request_info, priority, server_ssl_config,
  93                      proxy_ssl_config, net_log.net_log());
  94   request->AttachJob(job);
  95
  96   const AlternativeServiceVector alternative_service_vector =
  97       GetAlternativeServicesFor(request_info.url);
  98   if (!alternative_service_vector.empty()) {
  99     // TODO(bnc): Pass on multiple alternative services to Job.
 100     const AlternativeService& alternative_service =
 101         alternative_service_vector[0];
 102     // Never share connection with other jobs for FTP requests.
 103     DCHECK(!request_info.url.SchemeIs("ftp"));
 104
 105     Job* alternative_job =
 106         new Job(this, session_, request_info, priority, server_ssl_config,
 107                 proxy_ssl_config, alternative_service, net_log.net_log());
 108     request->AttachJob(alternative_job);
 109
 110     job->WaitFor(alternative_job);
 111     // Make sure to wait until we call WaitFor(), before starting
 112     // |alternative_job|, otherwise |alternative_job| will not notify |job|
 113     // appropriately.
 114     alternative_job->Start(request);
 115   }
 116
 117   // Even if |alternative_job| has already finished, it will not have notified
 118   // the request yet, since we defer that to the next iteration of the
 119   // MessageLoop, so starting |job| is always safe.
 120   job->Start(request);
 121   return request;
 122 }
 123
 124 void HttpStreamFactoryImpl::PreconnectStreams(
 125     int num_streams,
 126     const HttpRequestInfo& request_info,
 127     const SSLConfig& server_ssl_config,
 128     const SSLConfig& proxy_ssl_config) {
 129   DCHECK(!for_websockets_);
 130   AlternativeService alternative_service;
 131   AlternativeServiceVector alternative_service_vector =
 132       GetAlternativeServicesFor(request_info.url);
 133   if (!alternative_service_vector.empty()) {
 134     // TODO(bnc): Pass on multiple alternative services to Job.
 135     alternative_service = alternative_service_vector[0];
 136   }
 137
 138   // Due to how the socket pools handle priorities and idle sockets, only IDLE
 139   // priority currently makes sense for preconnects. The priority for
 140   // preconnects is currently ignored (see RequestSocketsForPool()), but could
 141   // be used at some point for proxy resolution or something.
 142   Job* job =
 143       new Job(this, session_, request_info, IDLE, server_ssl_config,
 144               proxy_ssl_config, alternative_service, session_->net_log());
 145   preconnect_job_set_.insert(job);
 146   job->Preconnect(num_streams);
 147 }
 148
 149 const HostMappingRules* HttpStreamFactoryImpl::GetHostMappingRules() const {
 150   return session_->params().host_mapping_rules;
 151 }
 152
 153 AlternativeServiceVector HttpStreamFactoryImpl::GetAlternativeServicesFor(
 154     const GURL& original_url) {
 155   if (original_url.SchemeIs("ftp"))
 156     return AlternativeServiceVector();
 157
 158   HostPortPair origin = HostPortPair::FromURL(original_url);
 159   HttpServerProperties& http_server_properties =
 160       *session_->http_server_properties();
 161   const AlternativeServiceVector alternative_service_vector =
 162       http_server_properties.GetAlternativeServices(origin);
 163   if (alternative_service_vector.empty())
 164     return AlternativeServiceVector();
 165
 166   const bool enable_different_host =
 167       session_->params().use_alternative_services;
 168
 169   AlternativeServiceVector enabled_alternative_service_vector;
 170   for (const AlternativeService& alternative_service :
 171        alternative_service_vector) {
 172     DCHECK(IsAlternateProtocolValid(alternative_service.protocol));
 173     if (http_server_properties.IsAlternativeServiceBroken(
 174             alternative_service)) {
 175       HistogramAlternateProtocolUsage(ALTERNATE_PROTOCOL_USAGE_BROKEN);
 176       continue;
 177     }
 178
 179     if (origin.host() != alternative_service.host && !enable_different_host)
 180       continue;
 181
 182     // Some shared unix systems may have user home directories (like
 183     // http://foo.com/~mike) which allow users to emit headers.  This is a bad
 184     // idea already, but with Alternate-Protocol, it provides the ability for a
 185     // single user on a multi-user system to hijack the alternate protocol.
 186     // These systems also enforce ports <1024 as restricted ports.  So don't
 187     // allow protocol upgrades to user-controllable ports.
 188     const int kUnrestrictedPort = 1024;
 189     if (!session_->params().enable_user_alternate_protocol_ports &&
 190         (alternative_service.port >= kUnrestrictedPort &&
 191          origin.port() < kUnrestrictedPort))
 192       continue;
 193
 194     origin.set_port(alternative_service.port);
 195     if (alternative_service.protocol >= NPN_SPDY_MINIMUM_VERSION &&
 196         alternative_service.protocol <= NPN_SPDY_MAXIMUM_VERSION) {
 197       if (!HttpStreamFactory::spdy_enabled())
 198         continue;
 199
 200       if (session_->HasSpdyExclusion(origin))
 201         continue;
 202
 203       enabled_alternative_service_vector.push_back(alternative_service);
 204       continue;
 205     }
 206
 207     DCHECK_EQ(QUIC, alternative_service.protocol);
 208     if (!session_->params().enable_quic)
 209       continue;
 210
 211     if (session_->quic_stream_factory()->IsQuicDisabled(origin.port()))
 212       continue;
 213
 214     if (!session_->params().enable_insecure_quic &&
 215         !original_url.SchemeIs("https")) {
 216       continue;
 217     }
 218
 219     enabled_alternative_service_vector.push_back(alternative_service);
 220   }
 221   return enabled_alternative_service_vector;
 222 }
 223
 224 void HttpStreamFactoryImpl::OrphanJob(Job* job, const Request* request) {
 225   DCHECK(ContainsKey(request_map_, job));
 226   DCHECK_EQ(request_map_[job], request);
 227   DCHECK(!ContainsKey(orphaned_job_set_, job));
 228
 229   request_map_.erase(job);
 230
 231   orphaned_job_set_.insert(job);
 232   job->Orphan(request);
 233 }
 234
 235 void HttpStreamFactoryImpl::OnNewSpdySessionReady(
 236     const base::WeakPtr<SpdySession>& spdy_session,
 237     bool direct,
 238     const SSLConfig& used_ssl_config,
 239     const ProxyInfo& used_proxy_info,
 240     bool was_npn_negotiated,
 241     NextProto protocol_negotiated,
 242     bool using_spdy,
 243     const BoundNetLog& net_log) {
 244   while (true) {
 245     if (!spdy_session)
 246       break;
 247     const SpdySessionKey& spdy_session_key = spdy_session->spdy_session_key();
 248     // Each iteration may empty out the RequestSet for |spdy_session_key| in
 249     // |spdy_session_request_map_|. So each time, check for RequestSet and use
 250     // the first one.
 251     //
 252     // TODO(willchan): If it's important, switch RequestSet out for a FIFO
 253     // queue (Order by priority first, then FIFO within same priority). Unclear
 254     // that it matters here.
 255     if (!ContainsKey(spdy_session_request_map_, spdy_session_key))
 256       break;
 257     Request* request = *spdy_session_request_map_[spdy_session_key].begin();
 258     request->Complete(was_npn_negotiated, protocol_negotiated, using_spdy);
 259     if (for_websockets_) {
 260       // TODO(ricea): Restore this code path when WebSocket over SPDY
 261       // implementation is ready.
 262       NOTREACHED();
 263     } else {
 264       bool use_relative_url = direct || request->url().SchemeIs("https");
 265       request->OnStreamReady(
 266           NULL,
 267           used_ssl_config,
 268           used_proxy_info,
 269           new SpdyHttpStream(spdy_session, use_relative_url));
 270     }
 271   }
 272   // TODO(mbelshe): Alert other valid requests.
 273 }
 274
 275 void HttpStreamFactoryImpl::OnOrphanedJobComplete(const Job* job) {
 276   orphaned_job_set_.erase(job);
 277   delete job;
 278 }
 279
 280 void HttpStreamFactoryImpl::OnPreconnectsComplete(const Job* job) {
 281   preconnect_job_set_.erase(job);
 282   delete job;
 283   OnPreconnectsCompleteInternal();
 284 }
 285
 286 }  // namespace net