Make SpdySessionKey a const member of HttpStreamFactoryImpl::Job

net/http/http_stream_factory_impl_job.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/http/http_stream_factory_impl_job.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 202 matching lines @@
                  origin_url_.SchemeIs(url::kWssScheme)),
       using_spdy_(false),
       using_quic_(false),
       should_reconsider_proxy_(false),
       quic_request_(session_->quic_stream_factory()),
       using_existing_quic_session_(false),
       establishing_tunnel_(false),
       was_alpn_negotiated_(false),
       negotiated_protocol_(kProtoUnknown),
       num_streams_(0),
-      spdy_session_direct_(false),
+      spdy_session_direct_(
+          !(proxy_info.is_https() && origin_url_.SchemeIs(url::kHttpScheme))),
+      spdy_session_key_(GetSpdySessionKey()),
       stream_type_(HttpStreamRequest::BIDIRECTIONAL_STREAM),
       ptr_factory_(this) {
   DCHECK(session);
   // The job can't have alternative service and alternative proxy server set at
   // the same time since alternative services are used for requests that are
   // fetched directly, while the alternative proxy server is used for requests
   // that should be fetched using proxy.
   DCHECK(alternative_service_.protocol == kProtoUnknown ||
          !alternative_proxy_server_.is_valid());
   DCHECK(!alternative_proxy_server_.is_valid() ||
@@ skipping 157 matching lines @@
   DCHECK(connection_.get() && connection_->socket());
   SSLClientSocket* ssl_socket =
       static_cast<SSLClientSocket*>(connection_->socket());
   ssl_socket->GetSSLInfo(&ssl_info_);
 }
 
 SpdySessionKey HttpStreamFactoryImpl::Job::GetSpdySessionKey() const {
   // In the case that we're using an HTTPS proxy for an HTTP url,
   // we look for a SPDY session *to* the proxy, instead of to the
   // origin server.
-  if (IsHttpsProxyAndHttpUrl()) {
+  if (!spdy_session_direct_) {
     return SpdySessionKey(proxy_info_.proxy_server().host_port_pair(),
                           ProxyServer::Direct(), PRIVACY_MODE_DISABLED);
   }
   return SpdySessionKey(HostPortPair::FromURL(origin_url_),
                         proxy_info_.proxy_server(), request_info_.privacy_mode);
 }
 
 bool HttpStreamFactoryImpl::Job::CanUseExistingSpdySession() const {
   // We need to make sure that if a spdy session was created for
   // https://somehost/ that we don't use that session for http://somehost:443/.
@@ skipping 456 matching lines @@
       // There's no available QUIC session. Inform the delegate how long to
       // delay the main job.
       if (rv == ERR_IO_PENDING) {
         delegate_->MaybeSetWaitTimeForMainJob(
             quic_request_.GetTimeDelayForWaitingJob());
       }
     }
     return rv;
   }
 
-  SpdySessionKey spdy_session_key = GetSpdySessionKey();
-
   // Check first if we have a spdy session for this group.  If so, then go
   // straight to using that.
   if (CanUseExistingSpdySession()) {
     base::WeakPtr<SpdySession> spdy_session =
         session_->spdy_session_pool()->FindAvailableSession(
-            spdy_session_key, origin_url_, enable_ip_based_pooling_, net_log_);
+            spdy_session_key_, origin_url_, enable_ip_based_pooling_, net_log_);
     if (spdy_session) {
       // If we're preconnecting, but we already have a SpdySession, we don't
       // actually need to preconnect any sockets, so we're done.
       if (job_type_ == PRECONNECT)
         return OK;
       using_spdy_ = true;
       next_state_ = STATE_CREATE_STREAM;
       existing_spdy_session_ = spdy_session;
       return OK;
     }
   }
   if (using_ssl_) {
     // Ask |delegate_delegate_| to update the spdy session key for the request
     // that launched this job.
-    delegate_->SetSpdySessionKey(this, spdy_session_key);
+    delegate_->SetSpdySessionKey(this, spdy_session_key_);
   }
 
   if (proxy_info_.is_http() || proxy_info_.is_https())
     establishing_tunnel_ = using_ssl_;
 
   const bool expect_spdy = IsSpdyAlternative();
 
   HttpServerProperties* http_server_properties =
       session_->http_server_properties();
   if (http_server_properties) {
@@ skipping 11 matching lines @@
         request_info_.load_flags, priority_, session_, proxy_info_, expect_spdy,
         server_ssl_config_, proxy_ssl_config_, request_info_.privacy_mode,
         net_log_, num_streams_);
   }
 
   // If we can't use a SPDY session, don't bother checking for one after
   // the hostname is resolved.
   OnHostResolutionCallback resolution_callback =
       CanUseExistingSpdySession()
           ? base::Bind(&Job::OnHostResolution, session_->spdy_session_pool(),
-                       spdy_session_key, origin_url_, enable_ip_based_pooling_)
+                       spdy_session_key_, origin_url_, enable_ip_based_pooling_)
           : OnHostResolutionCallback();
   if (delegate_->for_websockets()) {
     SSLConfig websocket_server_ssl_config = server_ssl_config_;
     websocket_server_ssl_config.alpn_protos.clear();
     return InitSocketHandleForWebSocketRequest(
         GetSocketGroup(), destination_, request_info_.extra_headers,
         request_info_.load_flags, priority_, session_, proxy_info_, expect_spdy,
         websocket_server_ssl_config, proxy_ssl_config_,
         request_info_.privacy_mode, net_log_, connection_.get(),
         resolution_callback, io_callback_);
@@ skipping 11 matching lines @@
   if (job_type_ == PRECONNECT) {
     if (using_quic_)
       return result;
     DCHECK_EQ(OK, result);
     return OK;
   }
 
   if (result == ERR_SPDY_SESSION_ALREADY_EXISTS) {
     // We found a SPDY connection after resolving the host. This is
     // probably an IP pooled connection.
-    SpdySessionKey spdy_session_key = GetSpdySessionKey();
     existing_spdy_session_ =
         session_->spdy_session_pool()->FindAvailableSession(
-            spdy_session_key, origin_url_, enable_ip_based_pooling_, net_log_);
+            spdy_session_key_, origin_url_, enable_ip_based_pooling_, net_log_);
     if (existing_spdy_session_) {
       using_spdy_ = true;
       next_state_ = STATE_CREATE_STREAM;
     } else {
       // It is possible that the spdy session no longer exists.
       ReturnToStateInitConnection(true /* close connection */);
     }
     return OK;
   }
 
@@ skipping 180 matching lines @@
     } else {
       stream_ = base::MakeUnique<HttpBasicStream>(
           std::move(connection_), using_proxy,
           session_->params().http_09_on_non_default_ports_enabled);
     }
     return OK;
   }
 
   CHECK(!stream_.get());
 
-  SpdySessionKey spdy_session_key = GetSpdySessionKey();
   if (!existing_spdy_session_) {
     existing_spdy_session_ =
         session_->spdy_session_pool()->FindAvailableSession(
-            spdy_session_key, origin_url_, enable_ip_based_pooling_, net_log_);
+            spdy_session_key_, origin_url_, enable_ip_based_pooling_, net_log_);
   }
-  bool direct = !IsHttpsProxyAndHttpUrl();
   if (existing_spdy_session_.get()) {
     // We picked up an existing session, so we don't need our socket.
     if (connection_->socket())
       connection_->socket()->Disconnect();
     connection_->Reset();
 
     int set_result = SetSpdyHttpStreamOrBidirectionalStreamImpl(
-        existing_spdy_session_, direct);
+        existing_spdy_session_, spdy_session_direct_);
     existing_spdy_session_.reset();
     return set_result;
   }
 
   // Close idle sockets in this group, since subsequent requests will go over
   // |spdy_session|.
   if (connection_->socket()->IsConnected())
     connection_->CloseIdleSocketsInGroup();
 
   base::WeakPtr<SpdySession> spdy_session =
       session_->spdy_session_pool()->CreateAvailableSessionFromSocket(
-          spdy_session_key, std::move(connection_), net_log_, using_ssl_);
+          spdy_session_key_, std::move(connection_), net_log_, using_ssl_);
 
   if (!spdy_session->HasAcceptableTransportSecurity()) {
     spdy_session->CloseSessionOnError(
         ERR_SPDY_INADEQUATE_TRANSPORT_SECURITY, "");
     return ERR_SPDY_INADEQUATE_TRANSPORT_SECURITY;
   }
 
   new_spdy_session_ = spdy_session;
-  spdy_session_direct_ = direct;
-  const HostPortPair host_port_pair = spdy_session_key.host_port_pair();
   url::SchemeHostPort scheme_host_port(
-      using_ssl_ ? url::kHttpsScheme : url::kHttpScheme, host_port_pair.host(),
-      host_port_pair.port());
+      using_ssl_ ? url::kHttpsScheme : url::kHttpScheme,
+      spdy_session_key_.host_port_pair().host(),
+      spdy_session_key_.host_port_pair().port());
 
   HttpServerProperties* http_server_properties =
       session_->http_server_properties();
   if (http_server_properties)
     http_server_properties->SetSupportsSpdy(scheme_host_port, true);
 
   // Create a SpdyHttpStream or a BidirectionalStreamImpl attached to the
   // session; OnNewSpdySessionReadyCallback is not called until an event loop
   // iteration later, so if the SpdySession is closed between then, allow
   // reuse state from the underlying socket, sampled by SpdyHttpStream,
@@ skipping 50 matching lines @@
 }
 
 void HttpStreamFactoryImpl::Job::SetSocketMotivation() {
   if (request_info_.motivation == HttpRequestInfo::PRECONNECT_MOTIVATED)
     connection_->socket()->SetSubresourceSpeculation();
   else if (request_info_.motivation == HttpRequestInfo::OMNIBOX_MOTIVATED)
     connection_->socket()->SetOmniboxSpeculation();
   // TODO(mbelshe): Add other motivations (like EARLY_LOAD_MOTIVATED).
 }
 
-bool HttpStreamFactoryImpl::Job::IsHttpsProxyAndHttpUrl() const {
-  if (!proxy_info_.is_https())
-    return false;
-  DCHECK(!IsSpdyAlternative());
-  if (IsQuicAlternative()) {
-    // We currently only support Alternate-Protocol where the original scheme
-    // is http.
-    // TODO(bnc): This comment is probably incorrect.
-    DCHECK(origin_url_.SchemeIs(url::kHttpScheme));
-    return origin_url_.SchemeIs(url::kHttpScheme);
-  }
-  return request_info_.url.SchemeIs(url::kHttpScheme);
-}
-
 bool HttpStreamFactoryImpl::Job::IsSpdyAlternative() const {
   return alternative_service_.protocol == kProtoHTTP2;
 }
 
 bool HttpStreamFactoryImpl::Job::IsQuicAlternative() const {
   return alternative_service_.protocol == kProtoQUIC;
 }
 
 void HttpStreamFactoryImpl::Job::InitSSLConfig(SSLConfig* ssl_config,
                                                bool is_proxy) const {
@@ skipping 202 matching lines @@
     bool enable_ip_based_pooling,
     NetLog* net_log) {
   return base::MakeUnique<HttpStreamFactoryImpl::Job>(
       delegate, job_type, session, request_info, priority, proxy_info,
       server_ssl_config, proxy_ssl_config, destination, origin_url,
       AlternativeService(), alternative_proxy_server, enable_ip_based_pooling,
       net_log);
 }
 
 }  // namespace net