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.
5 #include "net/http/http_stream_factory_impl_request.h"
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"
16 HttpStreamFactoryImpl::Request::Request(
18 HttpStreamFactoryImpl
* factory
,
19 HttpStreamRequest::Delegate
* delegate
,
20 WebSocketHandshakeStreamBase::CreateHelper
*
21 websocket_handshake_stream_create_helper
,
22 const BoundNetLog
& net_log
)
25 websocket_handshake_stream_create_helper_(
26 websocket_handshake_stream_create_helper
),
30 was_npn_negotiated_(false),
31 protocol_negotiated_(kProtoUnknown
),
36 net_log_
.BeginEvent(NetLog::TYPE_HTTP_STREAM_REQUEST
);
39 HttpStreamFactoryImpl::Request::~Request() {
41 DCHECK(jobs_
.empty());
43 DCHECK(!jobs_
.empty());
45 net_log_
.EndEvent(NetLog::TYPE_HTTP_STREAM_REQUEST
);
47 for (std::set
<Job
*>::iterator it
= jobs_
.begin(); it
!= jobs_
.end(); ++it
)
48 factory_
->request_map_
.erase(*it
);
50 RemoveRequestFromSpdySessionRequestMap();
52 STLDeleteElements(&jobs_
);
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);
65 void HttpStreamFactoryImpl::Request::AttachJob(Job
* job
) {
68 factory_
->request_map_
[job
] = this;
71 void HttpStreamFactoryImpl::Request::Complete(
72 bool was_npn_negotiated
,
73 NextProto protocol_negotiated
,
75 const BoundNetLog
& job_net_log
) {
78 was_npn_negotiated_
= was_npn_negotiated
;
79 protocol_negotiated_
= protocol_negotiated
;
80 using_spdy_
= using_spdy
;
82 NetLog::TYPE_HTTP_STREAM_REQUEST_BOUND_TO_JOB
,
83 job_net_log
.source().ToEventParametersCallback());
85 NetLog::TYPE_HTTP_STREAM_JOB_BOUND_TO_REQUEST
,
86 net_log_
.source().ToEventParametersCallback());
89 void HttpStreamFactoryImpl::Request::OnStreamReady(
91 const SSLConfig
& used_ssl_config
,
92 const ProxyInfo
& used_proxy_info
,
94 DCHECK(!factory_
->for_websockets_
);
99 delegate_
->OnStreamReady(used_ssl_config
, used_proxy_info
, stream
);
102 void HttpStreamFactoryImpl::Request::OnWebSocketHandshakeStreamReady(
104 const SSLConfig
& used_ssl_config
,
105 const ProxyInfo
& used_proxy_info
,
106 WebSocketHandshakeStreamBase
* stream
) {
107 DCHECK(factory_
->for_websockets_
);
112 delegate_
->OnWebSocketHandshakeStreamReady(
113 used_ssl_config
, used_proxy_info
, stream
);
116 void HttpStreamFactoryImpl::Request::OnStreamFailed(
119 const SSLConfig
& used_ssl_config
,
120 SSLFailureState ssl_failure_state
) {
121 DCHECK_NE(OK
, status
);
123 if (!bound_job_
.get()) {
124 // Hey, we've got other jobs! Maybe one of them will succeed, let's just
125 // ignore this failure.
126 if (jobs_
.size() > 1) {
128 factory_
->request_map_
.erase(job
);
129 // Notify all the other jobs that this one failed.
130 for (std::set
<Job
*>::iterator it
= jobs_
.begin(); it
!= jobs_
.end(); ++it
)
131 (*it
)->MarkOtherJobComplete(*job
);
135 bound_job_
.reset(job
);
137 DCHECK(jobs_
.empty());
138 factory_
->request_map_
.erase(job
);
141 DCHECK(jobs_
.empty());
143 delegate_
->OnStreamFailed(status
, used_ssl_config
, ssl_failure_state
);
146 void HttpStreamFactoryImpl::Request::OnCertificateError(
149 const SSLConfig
& used_ssl_config
,
150 const SSLInfo
& ssl_info
) {
151 DCHECK_NE(OK
, status
);
152 if (!bound_job_
.get())
153 OrphanJobsExcept(job
);
155 DCHECK(jobs_
.empty());
156 delegate_
->OnCertificateError(status
, used_ssl_config
, ssl_info
);
159 void HttpStreamFactoryImpl::Request::OnNeedsProxyAuth(
161 const HttpResponseInfo
& proxy_response
,
162 const SSLConfig
& used_ssl_config
,
163 const ProxyInfo
& used_proxy_info
,
164 HttpAuthController
* auth_controller
) {
165 if (!bound_job_
.get())
166 OrphanJobsExcept(job
);
168 DCHECK(jobs_
.empty());
169 delegate_
->OnNeedsProxyAuth(
170 proxy_response
, used_ssl_config
, used_proxy_info
, auth_controller
);
173 void HttpStreamFactoryImpl::Request::OnNeedsClientAuth(
175 const SSLConfig
& used_ssl_config
,
176 SSLCertRequestInfo
* cert_info
) {
177 if (!bound_job_
.get())
178 OrphanJobsExcept(job
);
180 DCHECK(jobs_
.empty());
181 delegate_
->OnNeedsClientAuth(used_ssl_config
, cert_info
);
184 void HttpStreamFactoryImpl::Request::OnHttpsProxyTunnelResponse(
186 const HttpResponseInfo
& response_info
,
187 const SSLConfig
& used_ssl_config
,
188 const ProxyInfo
& used_proxy_info
,
189 HttpStream
* stream
) {
190 if (!bound_job_
.get())
191 OrphanJobsExcept(job
);
193 DCHECK(jobs_
.empty());
194 delegate_
->OnHttpsProxyTunnelResponse(
195 response_info
, used_ssl_config
, used_proxy_info
, stream
);
198 int HttpStreamFactoryImpl::Request::RestartTunnelWithProxyAuth(
199 const AuthCredentials
& credentials
) {
200 DCHECK(bound_job_
.get());
201 return bound_job_
->RestartTunnelWithProxyAuth(credentials
);
204 void HttpStreamFactoryImpl::Request::SetPriority(RequestPriority priority
) {
205 for (std::set
<HttpStreamFactoryImpl::Job
*>::const_iterator it
= jobs_
.begin();
206 it
!= jobs_
.end(); ++it
) {
207 (*it
)->SetPriority(priority
);
210 bound_job_
->SetPriority(priority
);
213 LoadState
HttpStreamFactoryImpl::Request::GetLoadState() const {
214 if (bound_job_
.get())
215 return bound_job_
->GetLoadState();
216 DCHECK(!jobs_
.empty());
218 // Just pick the first one.
219 return (*jobs_
.begin())->GetLoadState();
222 bool HttpStreamFactoryImpl::Request::was_npn_negotiated() const {
224 return was_npn_negotiated_
;
227 NextProto
HttpStreamFactoryImpl::Request::protocol_negotiated()
230 return protocol_negotiated_
;
233 bool HttpStreamFactoryImpl::Request::using_spdy() const {
238 const ConnectionAttempts
& HttpStreamFactoryImpl::Request::connection_attempts()
240 return connection_attempts_
;
244 HttpStreamFactoryImpl::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();
259 bool HttpStreamFactoryImpl::Request::HasSpdySessionKey() const {
260 return spdy_session_key_
.get() != NULL
;
263 // TODO(jgraettinger): Currently, HttpStreamFactoryImpl::Job notifies a
264 // Request that the session is ready, which in turn notifies it's delegate,
265 // and then it notifies HttpStreamFactoryImpl so that /other/ requests may
266 // be woken, but only if the spdy_session is still okay. This is tough to grok.
267 // Instead, see if Job can notify HttpStreamFactoryImpl only, and have one
268 // path for notifying any requests waiting for the session (including the
269 // request which spawned it).
270 void HttpStreamFactoryImpl::Request::OnNewSpdySessionReady(
272 scoped_ptr
<HttpStream
> stream
,
273 const base::WeakPtr
<SpdySession
>& spdy_session
,
276 DCHECK(job
->using_spdy());
278 // Note: |spdy_session| may be NULL. In that case, |delegate_| should still
279 // receive |stream| so the error propogates up correctly, however there is no
280 // point in broadcasting |spdy_session| to other requests.
282 // The first case is the usual case.
283 if (!bound_job_
.get()) {
284 OrphanJobsExcept(job
);
285 } else { // This is the case for HTTPS proxy tunneling.
286 DCHECK_EQ(bound_job_
.get(), job
);
287 DCHECK(jobs_
.empty());
290 // Cache these values in case the job gets deleted.
291 const SSLConfig used_ssl_config
= job
->server_ssl_config();
292 const ProxyInfo used_proxy_info
= job
->proxy_info();
293 const bool was_npn_negotiated
= job
->was_npn_negotiated();
294 const NextProto protocol_negotiated
=
295 job
->protocol_negotiated();
296 const bool using_spdy
= job
->using_spdy();
297 const BoundNetLog net_log
= job
->net_log();
299 Complete(was_npn_negotiated
, protocol_negotiated
, using_spdy
, net_log
);
301 // Cache this so we can still use it if the request is deleted.
302 HttpStreamFactoryImpl
* factory
= factory_
;
303 if (factory
->for_websockets_
) {
304 // TODO(ricea): Re-instate this code when WebSockets over SPDY is
308 delegate_
->OnStreamReady(job
->server_ssl_config(), job
->proxy_info(),
311 // |this| may be deleted after this point.
312 if (spdy_session
&& spdy_session
->IsAvailable()) {
313 factory
->OnNewSpdySessionReady(spdy_session
,
324 void HttpStreamFactoryImpl::Request::AddConnectionAttempts(
325 const ConnectionAttempts
& attempts
) {
326 for (const auto& attempt
: attempts
)
327 connection_attempts_
.push_back(attempt
);
330 void HttpStreamFactoryImpl::Request::OrphanJobsExcept(Job
* job
) {
332 DCHECK(!bound_job_
.get());
333 DCHECK(ContainsKey(jobs_
, job
));
334 bound_job_
.reset(job
);
336 factory_
->request_map_
.erase(job
);
341 void HttpStreamFactoryImpl::Request::OrphanJobs() {
342 RemoveRequestFromSpdySessionRequestMap();
347 for (std::set
<Job
*>::iterator it
= tmp
.begin(); it
!= tmp
.end(); ++it
)
348 factory_
->OrphanJob(*it
, this);
351 void HttpStreamFactoryImpl::Request::OnJobSucceeded(Job
* job
) {
352 // |job| should only be NULL if we're being serviced by a late bound
353 // SpdySession (one that was not created by a job in our |jobs_| set).
355 DCHECK(!bound_job_
.get());
356 DCHECK(!jobs_
.empty());
357 // NOTE(willchan): We do *NOT* call OrphanJobs() here. The reason is because
358 // we *WANT* to cancel the unnecessary Jobs from other requests if another
359 // Job completes first.
360 // TODO(mbelshe): Revisit this when we implement ip connection pooling of
361 // SpdySessions. Do we want to orphan the jobs for a different hostname so
362 // they complete? Or do we want to prevent connecting a new SpdySession if
363 // we've already got one available for a different hostname where the ip
364 // address matches up?
367 if (!bound_job_
.get()) {
368 if (jobs_
.size() > 1)
369 job
->ReportJobSucceededForRequest();
370 // Notify all the other jobs that this one succeeded.
371 for (std::set
<Job
*>::iterator it
= jobs_
.begin(); it
!= jobs_
.end(); ++it
) {
373 (*it
)->MarkOtherJobComplete(*job
);
376 // We may have other jobs in |jobs_|. For example, if we start multiple jobs
377 // for Alternate-Protocol.
378 OrphanJobsExcept(job
);
381 DCHECK(jobs_
.empty());