| OLD | NEW |
|---|
| (Empty) |
| 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 "base/strings/string_number_conversions.h" | |
| 12 #include "net/base/net_log.h" | |
| 13 #include "net/base/net_util.h" | |
| 14 #include "net/http/http_network_session.h" | |
| 15 #include "net/http/http_server_properties.h" | |
| 16 #include "net/http/http_stream_factory_impl_job.h" | |
| 17 #include "net/http/http_stream_factory_impl_request.h" | |
| 18 #include "net/spdy/spdy_http_stream.h" | |
| 19 #include "url/gurl.h" | |
| 20 | |
| 21 namespace net { | |
| 22 | |
| 23 namespace { | |
| 24 | |
| 25 GURL UpgradeUrlToHttps(const GURL& original_url, int port) { | |
| 26 GURL::Replacements replacements; | |
| 27 // new_port needs to be in scope here because GURL::Replacements references | |
| 28 // the memory contained by it directly. | |
| 29 const std::string new_port = base::IntToString(port); | |
| 30 replacements.SetSchemeStr("https"); | |
| 31 replacements.SetPortStr(new_port); | |
| 32 return original_url.ReplaceComponents(replacements); | |
| 33 } | |
| 34 | |
| 35 } // namespace | |
| 36 | |
| 37 HttpStreamFactoryImpl::HttpStreamFactoryImpl(HttpNetworkSession* session, | |
| 38 bool for_websockets) | |
| 39 : session_(session), | |
| 40 for_websockets_(for_websockets) {} | |
| 41 | |
| 42 HttpStreamFactoryImpl::~HttpStreamFactoryImpl() { | |
| 43 DCHECK(request_map_.empty()); | |
| 44 DCHECK(spdy_session_request_map_.empty()); | |
| 45 | |
| 46 std::set<const Job*> tmp_job_set; | |
| 47 tmp_job_set.swap(orphaned_job_set_); | |
| 48 STLDeleteContainerPointers(tmp_job_set.begin(), tmp_job_set.end()); | |
| 49 DCHECK(orphaned_job_set_.empty()); | |
| 50 | |
| 51 tmp_job_set.clear(); | |
| 52 tmp_job_set.swap(preconnect_job_set_); | |
| 53 STLDeleteContainerPointers(tmp_job_set.begin(), tmp_job_set.end()); | |
| 54 DCHECK(preconnect_job_set_.empty()); | |
| 55 } | |
| 56 | |
| 57 HttpStreamRequest* HttpStreamFactoryImpl::RequestStream( | |
| 58 const HttpRequestInfo& request_info, | |
| 59 RequestPriority priority, | |
| 60 const SSLConfig& server_ssl_config, | |
| 61 const SSLConfig& proxy_ssl_config, | |
| 62 HttpStreamRequest::Delegate* delegate, | |
| 63 const BoundNetLog& net_log) { | |
| 64 DCHECK(!for_websockets_); | |
| 65 return RequestStreamInternal(request_info, | |
| 66 priority, | |
| 67 server_ssl_config, | |
| 68 proxy_ssl_config, | |
| 69 delegate, | |
| 70 NULL, | |
| 71 net_log); | |
| 72 } | |
| 73 | |
| 74 HttpStreamRequest* HttpStreamFactoryImpl::RequestWebSocketHandshakeStream( | |
| 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 WebSocketHandshakeStreamBase::CreateHelper* create_helper, | |
| 81 const BoundNetLog& net_log) { | |
| 82 DCHECK(for_websockets_); | |
| 83 DCHECK(create_helper); | |
| 84 return RequestStreamInternal(request_info, | |
| 85 priority, | |
| 86 server_ssl_config, | |
| 87 proxy_ssl_config, | |
| 88 delegate, | |
| 89 create_helper, | |
| 90 net_log); | |
| 91 } | |
| 92 | |
| 93 HttpStreamRequest* HttpStreamFactoryImpl::RequestStreamInternal( | |
| 94 const HttpRequestInfo& request_info, | |
| 95 RequestPriority priority, | |
| 96 const SSLConfig& server_ssl_config, | |
| 97 const SSLConfig& proxy_ssl_config, | |
| 98 HttpStreamRequest::Delegate* delegate, | |
| 99 WebSocketHandshakeStreamBase::CreateHelper* | |
| 100 websocket_handshake_stream_create_helper, | |
| 101 const BoundNetLog& net_log) { | |
| 102 Request* request = new Request(request_info.url, | |
| 103 this, | |
| 104 delegate, | |
| 105 websocket_handshake_stream_create_helper, | |
| 106 net_log); | |
| 107 | |
| 108 GURL alternate_url; | |
| 109 AlternateProtocolInfo alternate = | |
| 110 GetAlternateProtocolRequestFor(request_info.url, &alternate_url); | |
| 111 Job* alternate_job = NULL; | |
| 112 if (alternate.protocol != UNINITIALIZED_ALTERNATE_PROTOCOL) { | |
| 113 // Never share connection with other jobs for FTP requests. | |
| 114 DCHECK(!request_info.url.SchemeIs("ftp")); | |
| 115 | |
| 116 HttpRequestInfo alternate_request_info = request_info; | |
| 117 alternate_request_info.url = alternate_url; | |
| 118 alternate_job = | |
| 119 new Job(this, session_, alternate_request_info, priority, | |
| 120 server_ssl_config, proxy_ssl_config, net_log.net_log()); | |
| 121 request->AttachJob(alternate_job); | |
| 122 alternate_job->MarkAsAlternate(request_info.url, alternate); | |
| 123 } | |
| 124 | |
| 125 Job* job = new Job(this, session_, request_info, priority, | |
| 126 server_ssl_config, proxy_ssl_config, net_log.net_log()); | |
| 127 request->AttachJob(job); | |
| 128 if (alternate_job) { | |
| 129 // Never share connection with other jobs for FTP requests. | |
| 130 DCHECK(!request_info.url.SchemeIs("ftp")); | |
| 131 | |
| 132 job->WaitFor(alternate_job); | |
| 133 // Make sure to wait until we call WaitFor(), before starting | |
| 134 // |alternate_job|, otherwise |alternate_job| will not notify |job| | |
| 135 // appropriately. | |
| 136 alternate_job->Start(request); | |
| 137 } | |
| 138 // Even if |alternate_job| has already finished, it won't have notified the | |
| 139 // request yet, since we defer that to the next iteration of the MessageLoop, | |
| 140 // so starting |job| is always safe. | |
| 141 job->Start(request); | |
| 142 return request; | |
| 143 } | |
| 144 | |
| 145 void HttpStreamFactoryImpl::PreconnectStreams( | |
| 146 int num_streams, | |
| 147 const HttpRequestInfo& request_info, | |
| 148 RequestPriority priority, | |
| 149 const SSLConfig& server_ssl_config, | |
| 150 const SSLConfig& proxy_ssl_config) { | |
| 151 DCHECK(!for_websockets_); | |
| 152 GURL alternate_url; | |
| 153 AlternateProtocolInfo alternate = | |
| 154 GetAlternateProtocolRequestFor(request_info.url, &alternate_url); | |
| 155 Job* job = NULL; | |
| 156 if (alternate.protocol != UNINITIALIZED_ALTERNATE_PROTOCOL) { | |
| 157 HttpRequestInfo alternate_request_info = request_info; | |
| 158 alternate_request_info.url = alternate_url; | |
| 159 job = new Job(this, session_, alternate_request_info, priority, | |
| 160 server_ssl_config, proxy_ssl_config, session_->net_log()); | |
| 161 job->MarkAsAlternate(request_info.url, alternate); | |
| 162 } else { | |
| 163 job = new Job(this, session_, request_info, priority, | |
| 164 server_ssl_config, proxy_ssl_config, session_->net_log()); | |
| 165 } | |
| 166 preconnect_job_set_.insert(job); | |
| 167 job->Preconnect(num_streams); | |
| 168 } | |
| 169 | |
| 170 const HostMappingRules* HttpStreamFactoryImpl::GetHostMappingRules() const { | |
| 171 return session_->params().host_mapping_rules; | |
| 172 } | |
| 173 | |
| 174 AlternateProtocolInfo HttpStreamFactoryImpl::GetAlternateProtocolRequestFor( | |
| 175 const GURL& original_url, | |
| 176 GURL* alternate_url) { | |
| 177 const AlternateProtocolInfo kNoAlternateProtocol; | |
| 178 | |
| 179 if (!session_->params().use_alternate_protocols) | |
| 180 return kNoAlternateProtocol; | |
| 181 | |
| 182 if (original_url.SchemeIs("ftp")) | |
| 183 return kNoAlternateProtocol; | |
| 184 | |
| 185 HostPortPair origin = HostPortPair::FromURL(original_url); | |
| 186 HttpServerProperties& http_server_properties = | |
| 187 *session_->http_server_properties(); | |
| 188 const AlternateProtocolInfo alternate = | |
| 189 http_server_properties.GetAlternateProtocol(origin); | |
| 190 | |
| 191 if (alternate.protocol == UNINITIALIZED_ALTERNATE_PROTOCOL) | |
| 192 return kNoAlternateProtocol; | |
| 193 if (alternate.is_broken) { | |
| 194 HistogramAlternateProtocolUsage(ALTERNATE_PROTOCOL_USAGE_BROKEN); | |
| 195 return kNoAlternateProtocol; | |
| 196 } | |
| 197 if (!IsAlternateProtocolValid(alternate.protocol)) { | |
| 198 NOTREACHED(); | |
| 199 return kNoAlternateProtocol; | |
| 200 } | |
| 201 | |
| 202 // Some shared unix systems may have user home directories (like | |
| 203 // http://foo.com/~mike) which allow users to emit headers. This is a bad | |
| 204 // idea already, but with Alternate-Protocol, it provides the ability for a | |
| 205 // single user on a multi-user system to hijack the alternate protocol. | |
| 206 // These systems also enforce ports <1024 as restricted ports. So don't | |
| 207 // allow protocol upgrades to user-controllable ports. | |
| 208 const int kUnrestrictedPort = 1024; | |
| 209 if (!session_->params().enable_user_alternate_protocol_ports && | |
| 210 (alternate.port >= kUnrestrictedPort && | |
| 211 origin.port() < kUnrestrictedPort)) | |
| 212 return kNoAlternateProtocol; | |
| 213 | |
| 214 origin.set_port(alternate.port); | |
| 215 if (alternate.protocol >= NPN_SPDY_MINIMUM_VERSION && | |
| 216 alternate.protocol <= NPN_SPDY_MAXIMUM_VERSION) { | |
| 217 if (!HttpStreamFactory::spdy_enabled()) | |
| 218 return kNoAlternateProtocol; | |
| 219 | |
| 220 if (session_->HasSpdyExclusion(origin)) | |
| 221 return kNoAlternateProtocol; | |
| 222 | |
| 223 *alternate_url = UpgradeUrlToHttps(original_url, alternate.port); | |
| 224 } else { | |
| 225 DCHECK_EQ(QUIC, alternate.protocol); | |
| 226 if (!session_->params().enable_quic) | |
| 227 return kNoAlternateProtocol; | |
| 228 | |
| 229 // TODO(rch): Figure out how to make QUIC iteract with PAC | |
| 230 // scripts. By not re-writing the URL, we will query the PAC script | |
| 231 // for the proxy to use to reach the original URL via TCP. But | |
| 232 // the alternate request will be going via UDP to a different port. | |
| 233 *alternate_url = original_url; | |
| 234 } | |
| 235 return alternate; | |
| 236 } | |
| 237 | |
| 238 void HttpStreamFactoryImpl::OrphanJob(Job* job, const Request* request) { | |
| 239 DCHECK(ContainsKey(request_map_, job)); | |
| 240 DCHECK_EQ(request_map_[job], request); | |
| 241 DCHECK(!ContainsKey(orphaned_job_set_, job)); | |
| 242 | |
| 243 request_map_.erase(job); | |
| 244 | |
| 245 orphaned_job_set_.insert(job); | |
| 246 job->Orphan(request); | |
| 247 } | |
| 248 | |
| 249 void HttpStreamFactoryImpl::OnNewSpdySessionReady( | |
| 250 const base::WeakPtr<SpdySession>& spdy_session, | |
| 251 bool direct, | |
| 252 const SSLConfig& used_ssl_config, | |
| 253 const ProxyInfo& used_proxy_info, | |
| 254 bool was_npn_negotiated, | |
| 255 NextProto protocol_negotiated, | |
| 256 bool using_spdy, | |
| 257 const BoundNetLog& net_log) { | |
| 258 while (true) { | |
| 259 if (!spdy_session) | |
| 260 break; | |
| 261 const SpdySessionKey& spdy_session_key = spdy_session->spdy_session_key(); | |
| 262 // Each iteration may empty out the RequestSet for |spdy_session_key| in | |
| 263 // |spdy_session_request_map_|. So each time, check for RequestSet and use | |
| 264 // the first one. | |
| 265 // | |
| 266 // TODO(willchan): If it's important, switch RequestSet out for a FIFO | |
| 267 // queue (Order by priority first, then FIFO within same priority). Unclear | |
| 268 // that it matters here. | |
| 269 if (!ContainsKey(spdy_session_request_map_, spdy_session_key)) | |
| 270 break; | |
| 271 Request* request = *spdy_session_request_map_[spdy_session_key].begin(); | |
| 272 request->Complete(was_npn_negotiated, | |
| 273 protocol_negotiated, | |
| 274 using_spdy, | |
| 275 net_log); | |
| 276 if (for_websockets_) { | |
| 277 // TODO(ricea): Restore this code path when WebSocket over SPDY | |
| 278 // implementation is ready. | |
| 279 NOTREACHED(); | |
| 280 } else { | |
| 281 bool use_relative_url = direct || request->url().SchemeIs("https"); | |
| 282 request->OnStreamReady( | |
| 283 NULL, | |
| 284 used_ssl_config, | |
| 285 used_proxy_info, | |
| 286 new SpdyHttpStream(spdy_session, use_relative_url)); | |
| 287 } | |
| 288 } | |
| 289 // TODO(mbelshe): Alert other valid requests. | |
| 290 } | |
| 291 | |
| 292 void HttpStreamFactoryImpl::OnOrphanedJobComplete(const Job* job) { | |
| 293 orphaned_job_set_.erase(job); | |
| 294 delete job; | |
| 295 } | |
| 296 | |
| 297 void HttpStreamFactoryImpl::OnPreconnectsComplete(const Job* job) { | |
| 298 preconnect_job_set_.erase(job); | |
| 299 delete job; | |
| 300 OnPreconnectsCompleteInternal(); | |
| 301 } | |
| 302 | |
| 303 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master