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_request.h" 6 7#include "base/callback.h" 8#include "base/logging.h" 9#include "base/stl_util.h" 10#include "net/http/http_stream_factory_impl_job.h" 11#include "net/spdy/spdy_http_stream.h" 12#include "net/spdy/spdy_session.h" 13 14namespace net { 15 16HttpStreamFactoryImpl::Request::Request( 17 const GURL& url, 18 HttpStreamFactoryImpl* factory, 19 HttpStreamRequest::Delegate* delegate, 20 WebSocketStreamBase::Factory* websocket_stream_factory, 21 const BoundNetLog& net_log) 22 : url_(url), 23 factory_(factory), 24 websocket_stream_factory_(websocket_stream_factory), 25 delegate_(delegate), 26 net_log_(net_log), 27 completed_(false), 28 was_npn_negotiated_(false), 29 protocol_negotiated_(kProtoUnknown), 30 using_spdy_(false) { 31 DCHECK(factory_); 32 DCHECK(delegate_); 33 34 net_log_.BeginEvent(NetLog::TYPE_HTTP_STREAM_REQUEST); 35} 36 37HttpStreamFactoryImpl::Request::~Request() { 38 if (bound_job_.get()) 39 DCHECK(jobs_.empty()); 40 else 41 DCHECK(!jobs_.empty()); 42 43 net_log_.EndEvent(NetLog::TYPE_HTTP_STREAM_REQUEST); 44 45 for (std::set<Job*>::iterator it = jobs_.begin(); it != jobs_.end(); ++it) 46 factory_->request_map_.erase(*it); 47 48 RemoveRequestFromSpdySessionRequestMap(); 49 RemoveRequestFromHttpPipeliningRequestMap(); 50 51 STLDeleteElements(&jobs_); 52} 53 54void HttpStreamFactoryImpl::Request::SetSpdySessionKey( 55 const SpdySessionKey& spdy_session_key) { 56 DCHECK(!spdy_session_key_.get()); 57 spdy_session_key_.reset(new SpdySessionKey(spdy_session_key)); 58 RequestSet& request_set = 59 factory_->spdy_session_request_map_[spdy_session_key]; 60 DCHECK(!ContainsKey(request_set, this)); 61 request_set.insert(this); 62} 63 64bool HttpStreamFactoryImpl::Request::SetHttpPipeliningKey( 65 const HttpPipelinedHost::Key& http_pipelining_key) { 66 CHECK(!http_pipelining_key_.get()); 67 http_pipelining_key_.reset(new HttpPipelinedHost::Key(http_pipelining_key)); 68 bool was_new_key = !ContainsKey(factory_->http_pipelining_request_map_, 69 http_pipelining_key); 70 RequestVector& request_vector = 71 factory_->http_pipelining_request_map_[http_pipelining_key]; 72 request_vector.push_back(this); 73 return was_new_key; 74} 75 76void HttpStreamFactoryImpl::Request::AttachJob(Job* job) { 77 DCHECK(job); 78 jobs_.insert(job); 79 factory_->request_map_[job] = this; 80} 81 82void HttpStreamFactoryImpl::Request::Complete( 83 bool was_npn_negotiated, 84 NextProto protocol_negotiated, 85 bool using_spdy, 86 const BoundNetLog& job_net_log) { 87 DCHECK(!completed_); 88 completed_ = true; 89 was_npn_negotiated_ = was_npn_negotiated; 90 protocol_negotiated_ = protocol_negotiated; 91 using_spdy_ = using_spdy; 92 net_log_.AddEvent( 93 NetLog::TYPE_HTTP_STREAM_REQUEST_BOUND_TO_JOB, 94 job_net_log.source().ToEventParametersCallback()); 95 job_net_log.AddEvent( 96 NetLog::TYPE_HTTP_STREAM_JOB_BOUND_TO_REQUEST, 97 net_log_.source().ToEventParametersCallback()); 98} 99 100void HttpStreamFactoryImpl::Request::OnStreamReady( 101 Job* job, 102 const SSLConfig& used_ssl_config, 103 const ProxyInfo& used_proxy_info, 104 HttpStreamBase* stream) { 105 DCHECK(!factory_->for_websockets_); 106 DCHECK(stream); 107 DCHECK(completed_); 108 109 OnJobSucceeded(job); 110 delegate_->OnStreamReady(used_ssl_config, used_proxy_info, stream); 111} 112 113void HttpStreamFactoryImpl::Request::OnWebSocketStreamReady( 114 Job* job, 115 const SSLConfig& used_ssl_config, 116 const ProxyInfo& used_proxy_info, 117 WebSocketStreamBase* stream) { 118 DCHECK(factory_->for_websockets_); 119 DCHECK(stream); 120 DCHECK(completed_); 121 122 OnJobSucceeded(job); 123 delegate_->OnWebSocketStreamReady(used_ssl_config, used_proxy_info, stream); 124} 125 126void HttpStreamFactoryImpl::Request::OnStreamFailed( 127 Job* job, 128 int status, 129 const SSLConfig& used_ssl_config) { 130 DCHECK_NE(OK, status); 131 // |job| should only be NULL if we're being canceled by a late bound 132 // HttpPipelinedConnection (one that was not created by a job in our |jobs_| 133 // set). 134 if (!job) { 135 DCHECK(!bound_job_.get()); 136 DCHECK(!jobs_.empty()); 137 // NOTE(willchan): We do *NOT* call OrphanJobs() here. The reason is because 138 // we *WANT* to cancel the unnecessary Jobs from other requests if another 139 // Job completes first. 140 } else if (!bound_job_.get()) { 141 // Hey, we've got other jobs! Maybe one of them will succeed, let's just 142 // ignore this failure. 143 if (jobs_.size() > 1) { 144 jobs_.erase(job); 145 factory_->request_map_.erase(job); 146 delete job; 147 return; 148 } else { 149 bound_job_.reset(job); 150 jobs_.erase(job); 151 DCHECK(jobs_.empty()); 152 factory_->request_map_.erase(job); 153 } 154 } else { 155 DCHECK(jobs_.empty()); 156 } 157 delegate_->OnStreamFailed(status, used_ssl_config); 158} 159 160void HttpStreamFactoryImpl::Request::OnCertificateError( 161 Job* job, 162 int status, 163 const SSLConfig& used_ssl_config, 164 const SSLInfo& ssl_info) { 165 DCHECK_NE(OK, status); 166 if (!bound_job_.get()) 167 OrphanJobsExcept(job); 168 else 169 DCHECK(jobs_.empty()); 170 delegate_->OnCertificateError(status, used_ssl_config, ssl_info); 171} 172 173void HttpStreamFactoryImpl::Request::OnNeedsProxyAuth( 174 Job* job, 175 const HttpResponseInfo& proxy_response, 176 const SSLConfig& used_ssl_config, 177 const ProxyInfo& used_proxy_info, 178 HttpAuthController* auth_controller) { 179 if (!bound_job_.get()) 180 OrphanJobsExcept(job); 181 else 182 DCHECK(jobs_.empty()); 183 delegate_->OnNeedsProxyAuth( 184 proxy_response, used_ssl_config, used_proxy_info, auth_controller); 185} 186 187void HttpStreamFactoryImpl::Request::OnNeedsClientAuth( 188 Job* job, 189 const SSLConfig& used_ssl_config, 190 SSLCertRequestInfo* cert_info) { 191 if (!bound_job_.get()) 192 OrphanJobsExcept(job); 193 else 194 DCHECK(jobs_.empty()); 195 delegate_->OnNeedsClientAuth(used_ssl_config, cert_info); 196} 197 198void HttpStreamFactoryImpl::Request::OnHttpsProxyTunnelResponse( 199 Job *job, 200 const HttpResponseInfo& response_info, 201 const SSLConfig& used_ssl_config, 202 const ProxyInfo& used_proxy_info, 203 HttpStreamBase* stream) { 204 if (!bound_job_.get()) 205 OrphanJobsExcept(job); 206 else 207 DCHECK(jobs_.empty()); 208 delegate_->OnHttpsProxyTunnelResponse( 209 response_info, used_ssl_config, used_proxy_info, stream); 210} 211 212int HttpStreamFactoryImpl::Request::RestartTunnelWithProxyAuth( 213 const AuthCredentials& credentials) { 214 DCHECK(bound_job_.get()); 215 return bound_job_->RestartTunnelWithProxyAuth(credentials); 216} 217 218LoadState HttpStreamFactoryImpl::Request::GetLoadState() const { 219 if (bound_job_.get()) 220 return bound_job_->GetLoadState(); 221 DCHECK(!jobs_.empty()); 222 223 // Just pick the first one. 224 return (*jobs_.begin())->GetLoadState(); 225} 226 227bool HttpStreamFactoryImpl::Request::was_npn_negotiated() const { 228 DCHECK(completed_); 229 return was_npn_negotiated_; 230} 231 232NextProto HttpStreamFactoryImpl::Request::protocol_negotiated() 233 const { 234 DCHECK(completed_); 235 return protocol_negotiated_; 236} 237 238bool HttpStreamFactoryImpl::Request::using_spdy() const { 239 DCHECK(completed_); 240 return using_spdy_; 241} 242 243void 244HttpStreamFactoryImpl::Request::RemoveRequestFromSpdySessionRequestMap() { 245 if (spdy_session_key_.get()) { 246 SpdySessionRequestMap& spdy_session_request_map = 247 factory_->spdy_session_request_map_; 248 DCHECK(ContainsKey(spdy_session_request_map, *spdy_session_key_)); 249 RequestSet& request_set = 250 spdy_session_request_map[*spdy_session_key_]; 251 DCHECK(ContainsKey(request_set, this)); 252 request_set.erase(this); 253 if (request_set.empty()) 254 spdy_session_request_map.erase(*spdy_session_key_); 255 spdy_session_key_.reset(); 256 } 257} 258 259void 260HttpStreamFactoryImpl::Request::RemoveRequestFromHttpPipeliningRequestMap() { 261 if (http_pipelining_key_.get()) { 262 HttpPipeliningRequestMap& http_pipelining_request_map = 263 factory_->http_pipelining_request_map_; 264 DCHECK(ContainsKey(http_pipelining_request_map, *http_pipelining_key_)); 265 RequestVector& request_vector = 266 http_pipelining_request_map[*http_pipelining_key_]; 267 for (RequestVector::iterator it = request_vector.begin(); 268 it != request_vector.end(); ++it) { 269 if (*it == this) { 270 request_vector.erase(it); 271 break; 272 } 273 } 274 if (request_vector.empty()) 275 http_pipelining_request_map.erase(*http_pipelining_key_); 276 http_pipelining_key_.reset(); 277 } 278} 279 280void HttpStreamFactoryImpl::Request::OnNewSpdySessionReady( 281 Job* job, 282 const base::WeakPtr<SpdySession>& spdy_session, 283 bool direct) { 284 DCHECK(job); 285 DCHECK(job->using_spdy()); 286 287 // The first case is the usual case. 288 if (!bound_job_.get()) { 289 OrphanJobsExcept(job); 290 } else { // This is the case for HTTPS proxy tunneling. 291 DCHECK_EQ(bound_job_.get(), job); 292 DCHECK(jobs_.empty()); 293 } 294 295 // Cache these values in case the job gets deleted. 296 const SSLConfig used_ssl_config = job->server_ssl_config(); 297 const ProxyInfo used_proxy_info = job->proxy_info(); 298 const bool was_npn_negotiated = job->was_npn_negotiated(); 299 const NextProto protocol_negotiated = 300 job->protocol_negotiated(); 301 const bool using_spdy = job->using_spdy(); 302 const BoundNetLog net_log = job->net_log(); 303 304 Complete(was_npn_negotiated, protocol_negotiated, using_spdy, net_log); 305 306 // Cache this so we can still use it if the request is deleted. 307 HttpStreamFactoryImpl* factory = factory_; 308 if (factory->for_websockets_) { 309 DCHECK(websocket_stream_factory_); 310 bool use_relative_url = direct || url().SchemeIs("wss"); 311 delegate_->OnWebSocketStreamReady( 312 job->server_ssl_config(), 313 job->proxy_info(), 314 websocket_stream_factory_->CreateSpdyStream(spdy_session, 315 use_relative_url)); 316 } else { 317 bool use_relative_url = direct || url().SchemeIs("https"); 318 delegate_->OnStreamReady( 319 job->server_ssl_config(), 320 job->proxy_info(), 321 new SpdyHttpStream(spdy_session, use_relative_url)); 322 } 323 // |this| may be deleted after this point. 324 factory->OnNewSpdySessionReady(spdy_session, 325 direct, 326 used_ssl_config, 327 used_proxy_info, 328 was_npn_negotiated, 329 protocol_negotiated, 330 using_spdy, 331 net_log); 332} 333 334void HttpStreamFactoryImpl::Request::OrphanJobsExcept(Job* job) { 335 DCHECK(job); 336 DCHECK(!bound_job_.get()); 337 DCHECK(ContainsKey(jobs_, job)); 338 bound_job_.reset(job); 339 jobs_.erase(job); 340 factory_->request_map_.erase(job); 341 342 OrphanJobs(); 343} 344 345void HttpStreamFactoryImpl::Request::OrphanJobs() { 346 RemoveRequestFromSpdySessionRequestMap(); 347 RemoveRequestFromHttpPipeliningRequestMap(); 348 349 std::set<Job*> tmp; 350 tmp.swap(jobs_); 351 352 for (std::set<Job*>::iterator it = tmp.begin(); it != tmp.end(); ++it) 353 factory_->OrphanJob(*it, this); 354} 355 356void HttpStreamFactoryImpl::Request::OnJobSucceeded(Job* job) { 357 // |job| should only be NULL if we're being serviced by a late bound 358 // SpdySession or HttpPipelinedConnection (one that was not created by a job 359 // in our |jobs_| set). 360 if (!job) { 361 DCHECK(!bound_job_.get()); 362 DCHECK(!jobs_.empty()); 363 // NOTE(willchan): We do *NOT* call OrphanJobs() here. The reason is because 364 // we *WANT* to cancel the unnecessary Jobs from other requests if another 365 // Job completes first. 366 // TODO(mbelshe): Revisit this when we implement ip connection pooling of 367 // SpdySessions. Do we want to orphan the jobs for a different hostname so 368 // they complete? Or do we want to prevent connecting a new SpdySession if 369 // we've already got one available for a different hostname where the ip 370 // address matches up? 371 } else if (!bound_job_.get()) { 372 // We may have other jobs in |jobs_|. For example, if we start multiple jobs 373 // for Alternate-Protocol. 374 OrphanJobsExcept(job); 375 } else { 376 DCHECK(jobs_.empty()); 377 } 378} 379 380} // namespace net 381