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