Remove HttpStreamFactoryImpl::Job::MarkAsAlternate.

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 61 matching lines @@
   dict->SetString("proto", *proto);
   return dict.Pass();
 }
 
 HttpStreamFactoryImpl::Job::Job(HttpStreamFactoryImpl* stream_factory,
                                 HttpNetworkSession* session,
                                 const HttpRequestInfo& request_info,
                                 RequestPriority priority,
                                 const SSLConfig& server_ssl_config,
                                 const SSLConfig& proxy_ssl_config,
+                                AlternativeService alternative_service,
                                 NetLog* net_log)
     : request_(NULL),
       request_info_(request_info),
       priority_(priority),
       server_ssl_config_(server_ssl_config),
       proxy_ssl_config_(proxy_ssl_config),
       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_HTTP_STREAM_JOB)),
       io_callback_(base::Bind(&Job::OnIOComplete, base::Unretained(this))),
       connection_(new ClientSocketHandle),
       session_(session),
       stream_factory_(stream_factory),
       next_state_(STATE_NONE),
       pac_request_(NULL),
+      alternative_service_(alternative_service),
+      is_spdy_alternative_(
+          alternative_service_.protocol >= NPN_SPDY_MINIMUM_VERSION &&
+          alternative_service_.protocol <= NPN_SPDY_MAXIMUM_VERSION),
+      is_quic_alternative_(alternative_service_.protocol == QUIC),
       blocking_job_(NULL),
       waiting_job_(NULL),
       using_ssl_(false),
       using_spdy_(false),
-      using_quic_(false),
+      using_quic_(is_quic_alternative_),
       quic_request_(session_->quic_stream_factory()),
       using_existing_quic_session_(false),
       spdy_certificate_error_(OK),
       establishing_tunnel_(false),
       was_npn_negotiated_(false),
       protocol_negotiated_(kProtoUnknown),
       num_streams_(0),
       spdy_session_direct_(false),
       job_status_(STATUS_RUNNING),
       other_job_status_(STATUS_RUNNING),
       ptr_factory_(this) {
   DCHECK(stream_factory);
   DCHECK(session);
+  if (is_quic_alternative_)
+    DCHECK(session_->params().enable_quic);
 }
 
 HttpStreamFactoryImpl::Job::~Job() {
   net_log_.EndEvent(NetLog::TYPE_HTTP_STREAM_JOB);
 
   // When we're in a partially constructed state, waiting for the user to
   // provide certificate handling information or authentication, we can't reuse
   // this stream at all.
   if (next_state_ == STATE_WAITING_USER_ACTION) {
     connection_->socket()->Disconnect();
@@ skipping 41 matching lines @@
     case STATE_RESOLVE_PROXY_COMPLETE:
       return session_->proxy_service()->GetLoadState(pac_request_);
     case STATE_INIT_CONNECTION_COMPLETE:
     case STATE_CREATE_STREAM_COMPLETE:
       return using_quic_ ? LOAD_STATE_CONNECTING : connection_->GetLoadState();
     default:
       return LOAD_STATE_IDLE;
   }
 }
 
-void HttpStreamFactoryImpl::Job::MarkAsAlternate(
-    AlternativeService alternative_service) {
-  DCHECK(!IsAlternate());
-  alternative_service_ = alternative_service;
-  if (alternative_service.protocol == QUIC) {
-    DCHECK(session_->params().enable_quic);
-    using_quic_ = true;
-  }
-}
-
 void HttpStreamFactoryImpl::Job::WaitFor(Job* job) {
   DCHECK_EQ(STATE_NONE, next_state_);
   DCHECK_EQ(STATE_NONE, job->next_state_);
   DCHECK(!blocking_job_);
   DCHECK(!job->waiting_job_);
   blocking_job_ = job;
   job->waiting_job_ = this;
 }
 
 void HttpStreamFactoryImpl::Job::Resume(Job* job) {
@@ skipping 88 matching lines @@
 
 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/.
   // The only time we can use an existing session is if the request URL is
   // https (the normal case) or if we're connection to a SPDY proxy.
   // https://crbug.com/133176
   // TODO(ricea): Add "wss" back to this list when SPDY WebSocket support is
   // working.
   return origin_url_.SchemeIs("https") ||
-         proxy_info_.proxy_server().is_https() || IsSpdyAlternate();
+         proxy_info_.proxy_server().is_https() || is_spdy_alternative_;
 }
 
 void HttpStreamFactoryImpl::Job::OnStreamReadyCallback() {
   DCHECK(stream_.get());
   DCHECK(!IsPreconnecting());
   DCHECK(!stream_factory_->for_websockets_);
 
   MaybeCopyConnectionAttemptsFromSocketOrHandle();
 
   if (IsOrphaned()) {
@@ skipping 245 matching lines @@
       } else {
         DCHECK(stream_.get());
         base::MessageLoop::current()->PostTask(
             FROM_HERE,
             base::Bind(&Job::OnStreamReadyCallback, ptr_factory_.GetWeakPtr()));
       }
       return ERR_IO_PENDING;
 
     default:
       DCHECK(result != ERR_ALTERNATIVE_CERT_NOT_VALID_FOR_ORIGIN ||
-             IsAlternate());
+             is_spdy_alternative_ || is_quic_alternative_);
       if (job_status_ != STATUS_BROKEN) {
         DCHECK_EQ(STATUS_RUNNING, job_status_);
         job_status_ = STATUS_FAILED;
         // TODO(bnc): If (result == ERR_ALTERNATIVE_CERT_NOT_VALID_FOR_ORIGIN),
         // then instead of marking alternative service broken, mark (origin,
         // alternative service) couple as invalid.
         MaybeMarkAlternativeServiceBroken();
       }
       base::MessageLoop::current()->PostTask(
           FROM_HERE,
@@ skipping 63 matching lines @@
 
 int HttpStreamFactoryImpl::Job::StartInternal() {
   CHECK_EQ(STATE_NONE, next_state_);
   next_state_ = STATE_START;
   int rv = RunLoop(OK);
   DCHECK_EQ(ERR_IO_PENDING, rv);
   return rv;
 }
 
 int HttpStreamFactoryImpl::Job::DoStart() {
-  if (IsAlternate()) {
+  if (is_spdy_alternative_ || is_quic_alternative_) {
     server_ = alternative_service_.host_port_pair();
   } else {
     server_ = HostPortPair::FromURL(request_info_.url);
   }
   origin_url_ =
       stream_factory_->ApplyHostMappingRules(request_info_.url, &server_);
   valid_spdy_session_pool_.reset(new ValidSpdySessionPool(
-      session_->spdy_session_pool(), origin_url_, IsSpdyAlternate()));
+      session_->spdy_session_pool(), origin_url_, is_spdy_alternative_));
 
   net_log_.BeginEvent(
       NetLog::TYPE_HTTP_STREAM_JOB,
       base::Bind(&NetLogHttpStreamJobCallback, &request_info_.url, &origin_url_,
                  &alternative_service_, priority_));
 
   // Don't connect to restricted ports.
   bool is_port_allowed = IsPortAllowedByDefault(server_.port());
   if (request_info_.url.SchemeIs("ftp")) {
     // Never share connection with other jobs for FTP requests.
@@ skipping 23 matching lines @@
     proxy_info_.UseDirect();
     return OK;
   }
 
   // TODO(rch): remove this code since Alt-Svc seems to prohibit it.
   GURL url_for_proxy = origin_url_;
   // For SPDY via Alt-Svc, set |alternative_service_url_| to
   // https://<alternative host>:<alternative port>/...
   // so the proxy resolution works with the actual destination, and so
   // that the correct socket pool is used.
-  if (IsSpdyAlternate()) {
+  if (is_spdy_alternative_) {
     // TODO(rch):  Figure out how to make QUIC iteract with PAC
     // scripts.  By not re-writing the URL, we will query the PAC script
     // for the proxy to use to reach the original URL via TCP.  But
     // the alternate request will be going via UDP to a different port.
     GURL::Replacements replacements;
     // new_port needs to be in scope here because GURL::Replacements references
     // the memory contained by it directly.
     const std::string new_port = base::IntToString(alternative_service_.port);
     replacements.SetSchemeStr("https");
     replacements.SetPortStr(new_port);
@@ skipping 20 matching lines @@
 
     proxy_info_.RemoveProxiesWithoutScheme(supported_proxies);
 
     if (proxy_info_.is_empty()) {
       // No proxies/direct to choose from. This happens when we don't support
       // any of the proxies in the returned list.
       result = ERR_NO_SUPPORTED_PROXIES;
     } else if (using_quic_ &&
                (!proxy_info_.is_quic() && !proxy_info_.is_direct())) {
       // QUIC can not be spoken to non-QUIC proxies.  This error should not be
-      // user visible, because the non-alternate job should be resumed.
+      // user visible, because the non-alternative Job should be resumed.
       result = ERR_NO_SUPPORTED_PROXIES;
     }
   }
 
   if (result != OK) {
     if (waiting_job_) {
       waiting_job_->Resume(this);
       waiting_job_ = NULL;
     }
     return result;
@@ skipping 29 matching lines @@
   // TODO(pkasting): Remove ScopedTracker below once crbug.com/462812 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "462812 HttpStreamFactoryImpl::Job::DoInitConnection"));
   DCHECK(!blocking_job_);
   DCHECK(!connection_->is_initialized());
   DCHECK(proxy_info_.proxy_server().is_valid());
   next_state_ = STATE_INIT_CONNECTION_COMPLETE;
 
   using_ssl_ = origin_url_.SchemeIs("https") || origin_url_.SchemeIs("wss") ||
-               IsSpdyAlternate();
+               is_spdy_alternative_;
   using_spdy_ = false;
 
   if (ShouldForceQuic())
     using_quic_ = true;
 
   DCHECK(!using_quic_ || session_->params().enable_quic);
 
   if (proxy_info_.is_quic()) {
     using_quic_ = true;
     DCHECK(session_->params().enable_quic_for_proxies);
@@ skipping 54 matching lines @@
   // OK, there's no available SPDY session. Let |waiting_job_| resume if it's
   // paused.
   if (waiting_job_) {
     waiting_job_->Resume(this);
     waiting_job_ = NULL;
   }
 
   if (proxy_info_.is_http() || proxy_info_.is_https())
     establishing_tunnel_ = using_ssl_;
 
-  // TODO(bnc): s/want_spdy_over_npn/expect_spdy_over_npn/
-  bool want_spdy_over_npn = IsAlternate();
-
   if (proxy_info_.is_https()) {
     InitSSLConfig(proxy_info_.proxy_server().host_port_pair(),
                   &proxy_ssl_config_,
                   true /* is a proxy server */);
     // Disable revocation checking for HTTPS proxies since the revocation
     // requests are probably going to need to go through the proxy too.
     proxy_ssl_config_.rev_checking_enabled = false;
   }
   if (using_ssl_) {
     InitSSLConfig(server_, &server_ssl_config_, false /* not a proxy server */);
   }
 
   base::WeakPtr<HttpServerProperties> http_server_properties =
       session_->http_server_properties();
   if (http_server_properties) {
     http_server_properties->MaybeForceHTTP11(server_, &server_ssl_config_);
     if (proxy_info_.is_http() || proxy_info_.is_https()) {
       http_server_properties->MaybeForceHTTP11(
           proxy_info_.proxy_server().host_port_pair(), &proxy_ssl_config_);
     }
   }
 
   if (IsPreconnecting()) {
     DCHECK(!stream_factory_->for_websockets_);
     return PreconnectSocketsForHttpRequest(
         GetSocketGroup(), server_, request_info_.extra_headers,
         request_info_.load_flags, priority_, session_, proxy_info_,
-        want_spdy_over_npn, server_ssl_config_, proxy_ssl_config_,
-        request_info_.privacy_mode, net_log_, num_streams_);
+        /*want_spdy_over_npn=*/is_spdy_alternative_, 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)
           : OnHostResolutionCallback();
   if (stream_factory_->for_websockets_) {
     // TODO(ricea): Re-enable NPN when WebSockets over SPDY is supported.
     SSLConfig websocket_server_ssl_config = server_ssl_config_;
     websocket_server_ssl_config.next_protos.clear();
     return InitSocketHandleForWebSocketRequest(
         GetSocketGroup(), server_, request_info_.extra_headers,
         request_info_.load_flags, priority_, session_, proxy_info_,
-        want_spdy_over_npn, websocket_server_ssl_config, proxy_ssl_config_,
+        /*want_spdy_over_npn=*/is_spdy_alternative_,
+        websocket_server_ssl_config, proxy_ssl_config_,
         request_info_.privacy_mode, net_log_, connection_.get(),
         resolution_callback, io_callback_);
   }
 
   return InitSocketHandleForHttpRequest(
       GetSocketGroup(), server_, request_info_.extra_headers,
       request_info_.load_flags, priority_, session_, proxy_info_,
-      want_spdy_over_npn, server_ssl_config_, proxy_ssl_config_,
-      request_info_.privacy_mode, net_log_, connection_.get(),
-      resolution_callback, io_callback_);
+      /*want_spdy_over_npn=*/is_spdy_alternative_, server_ssl_config_,
+      proxy_ssl_config_, request_info_.privacy_mode, net_log_,
+      connection_.get(), resolution_callback, io_callback_);
 }
 
 int HttpStreamFactoryImpl::Job::DoInitConnectionComplete(int result) {
   if (IsPreconnecting()) {
     if (using_quic_)
       return result;
     DCHECK_EQ(OK, result);
     return OK;
   }
 
@@ skipping 78 matching lines @@
     // Other state (i.e. |using_ssl_|) suggests that |connection_| will have an
     // SSL socket, but there was an error before that could happen.  This
     // puts the in progress HttpProxy socket into |connection_| in order to
     // complete the auth (or read the response body).  The tunnel restart code
     // is careful to remove it before returning control to the rest of this
     // class.
     connection_.reset(connection_->release_pending_http_proxy_connection());
     return result;
   }
 
-  if (IsSpdyAlternate() && !using_spdy_) {
+  if (is_spdy_alternative_ && !using_spdy_) {
     job_status_ = STATUS_BROKEN;
     MaybeMarkAlternativeServiceBroken();
     return ERR_NPN_NEGOTIATION_FAILED;
   }
 
-  if (!ssl_started && result < 0 && IsAlternate()) {
+  if (!ssl_started && result < 0 &&
+      (is_spdy_alternative_ || is_quic_alternative_)) {
     job_status_ = STATUS_BROKEN;
     // TODO(bnc): if (result == ERR_ALTERNATIVE_CERT_NOT_VALID_FOR_ORIGIN), then
     // instead of marking alternative service broken, mark (origin, alternative
     // service) couple as invalid.
     MaybeMarkAlternativeServiceBroken();
     return result;
   }
 
   if (using_quic_) {
     if (result < 0) {
@@ skipping 15 matching lines @@
     if (!connection_->is_reused()) {
       ConnectionType type = using_spdy_ ? CONNECTION_SPDY : CONNECTION_HTTP;
       UpdateConnectionTypeHistograms(type);
     }
   }
 
   // Handle SSL errors below.
   if (using_ssl_) {
     DCHECK(ssl_started);
     if (IsCertificateError(result)) {
-      if (using_spdy_ && IsAlternate() && origin_url_.SchemeIs("http")) {
+      if (is_spdy_alternative_ && origin_url_.SchemeIs("http")) {
         // We ignore certificate errors for http over spdy.
         spdy_certificate_error_ = result;
         result = OK;
       } else {
         result = HandleCertificateError(result);
         if (result == OK && !connection_->socket()->IsConnectedAndIdle()) {
           ReturnToStateInitConnection(true /* close connection */);
           return result;
         }
       }
@@ skipping 30 matching lines @@
   stream_.reset(new SpdyHttpStream(session, use_relative_url));
   return OK;
 }
 
 int HttpStreamFactoryImpl::Job::DoCreateStream() {
   // TODO(pkasting): Remove ScopedTracker below once crbug.com/462811 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "462811 HttpStreamFactoryImpl::Job::DoCreateStream"));
   DCHECK(connection_->socket() || existing_spdy_session_.get() || using_quic_);
-  if (IsAlternate())
-    DCHECK(IsSpdyAlternate());
+  DCHECK(!is_quic_alternative_);
 
   next_state_ = STATE_CREATE_STREAM_COMPLETE;
 
   // We only set the socket motivation if we're the first to use
   // this socket.  Is there a race for two SPDY requests?  We really
   // need to plumb this through to the connect level.
   if (connection_->socket() && !connection_->is_reused())
     SetSocketMotivation();
 
   if (!using_spdy_) {
-    DCHECK(!IsSpdyAlternate());
+    DCHECK(!is_spdy_alternative_);
     // We may get ftp scheme when fetching ftp resources through proxy.
     bool using_proxy = (proxy_info_.is_http() || proxy_info_.is_https()) &&
                        (request_info_.url.SchemeIs("http") ||
                         request_info_.url.SchemeIs("ftp"));
     if (stream_factory_->for_websockets_) {
       DCHECK(request_);
       DCHECK(request_->websocket_handshake_stream_create_helper());
       websocket_stream_.reset(
           request_->websocket_handshake_stream_create_helper()
               ->CreateBasicStream(connection_.Pass(), using_proxy));
@@ skipping 109 matching lines @@
   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;
-  if (IsAlternate()) {
+  if (is_spdy_alternative_ || is_quic_alternative_) {
     // We currently only support Alternate-Protocol where the original scheme
     // is http.
     DCHECK(origin_url_.SchemeIs("http"));
     return origin_url_.SchemeIs("http");
   }
   return request_info_.url.SchemeIs("http");
 }
 
-bool HttpStreamFactoryImpl::Job::IsAlternate() const {
-  return alternative_service_.protocol != UNINITIALIZED_ALTERNATE_PROTOCOL;
-}
-
-bool HttpStreamFactoryImpl::Job::IsSpdyAlternate() const {
-  return alternative_service_.protocol >= NPN_SPDY_MINIMUM_VERSION &&
-         alternative_service_.protocol <= NPN_SPDY_MAXIMUM_VERSION;
-}
-
 void HttpStreamFactoryImpl::Job::InitSSLConfig(const HostPortPair& server,
                                                SSLConfig* ssl_config,
                                                bool is_proxy) const {
   if (!is_proxy) {
     // Prior to HTTP/2 and SPDY, some servers use TLS renegotiation to request
     // TLS client authentication after the HTTP request was sent. Allow
     // renegotiation for only those connections.
     //
     // Note that this does NOT implement the provision in
     // https://http2.github.io/http2-spec/#rfc.section.9.2.1 which allows the
@@ skipping 150 matching lines @@
 
 bool HttpStreamFactoryImpl::Job::IsOrphaned() const {
   return !IsPreconnecting() && !request_;
 }
 
 void HttpStreamFactoryImpl::Job::ReportJobSucceededForRequest() {
   if (using_existing_quic_session_) {
     // If an existing session was used, then no TCP connection was
     // started.
     HistogramAlternateProtocolUsage(ALTERNATE_PROTOCOL_USAGE_NO_RACE);
-  } else if (IsAlternate()) {
-    // This job was the alternate protocol job, and hence won the race.
+  } else if (is_spdy_alternative_ || is_quic_alternative_) {
+    // This Job was the alternative Job, and hence won the race.
     HistogramAlternateProtocolUsage(ALTERNATE_PROTOCOL_USAGE_WON_RACE);
   } else {
-    // This job was the normal job, and hence the alternate protocol job lost
-    // the race.
+    // This Job was the normal Job, and hence the alternative Job lost the race.
     HistogramAlternateProtocolUsage(ALTERNATE_PROTOCOL_USAGE_LOST_RACE);
   }
 }
 
 void HttpStreamFactoryImpl::Job::MarkOtherJobComplete(const Job& job) {
   DCHECK_EQ(STATUS_RUNNING, other_job_status_);
   other_job_status_ = job.job_status_;
   other_job_alternative_service_ = job.alternative_service_;
   MaybeMarkAlternativeServiceBroken();
 }
 
 void HttpStreamFactoryImpl::Job::MaybeMarkAlternativeServiceBroken() {
   if (job_status_ == STATUS_RUNNING || other_job_status_ == STATUS_RUNNING)
     return;
 
-  if (IsAlternate()) {
+  if (is_spdy_alternative_ || is_quic_alternative_) {
     if (job_status_ == STATUS_BROKEN && other_job_status_ == STATUS_SUCCEEDED) {
       HistogramBrokenAlternateProtocolLocation(
           BROKEN_ALTERNATE_PROTOCOL_LOCATION_HTTP_STREAM_FACTORY_IMPL_JOB_ALT);
       session_->http_server_properties()->MarkAlternativeServiceBroken(
           alternative_service_);
     }
     return;
   }
 
   if (job_status_ == STATUS_SUCCEEDED && other_job_status_ == STATUS_BROKEN) {
     HistogramBrokenAlternateProtocolLocation(
         BROKEN_ALTERNATE_PROTOCOL_LOCATION_HTTP_STREAM_FACTORY_IMPL_JOB_MAIN);
     session_->http_server_properties()->MarkAlternativeServiceBroken(
         other_job_alternative_service_);
   }
 }
 
 HttpStreamFactoryImpl::Job::ValidSpdySessionPool::ValidSpdySessionPool(
     SpdySessionPool* spdy_session_pool,
     GURL& origin_url,
-    bool is_spdy_alternate)
+    bool is_spdy_alternative)
     : spdy_session_pool_(spdy_session_pool),
       origin_url_(origin_url),
-      is_spdy_alternate_(is_spdy_alternate) {
+      is_spdy_alternative_(is_spdy_alternative) {
 }
 
 int HttpStreamFactoryImpl::Job::ValidSpdySessionPool::FindAvailableSession(
     const SpdySessionKey& key,
     const BoundNetLog& net_log,
     base::WeakPtr<SpdySession>* spdy_session) {
   *spdy_session = spdy_session_pool_->FindAvailableSession(key, net_log);
   return CheckAlternativeServiceValidityForOrigin(*spdy_session);
 }
 
 int HttpStreamFactoryImpl::Job::ValidSpdySessionPool::
     CreateAvailableSessionFromSocket(const SpdySessionKey& key,
                                      scoped_ptr<ClientSocketHandle> connection,
                                      const BoundNetLog& net_log,
                                      int certificate_error_code,
                                      bool is_secure,
                                      base::WeakPtr<SpdySession>* spdy_session) {
   *spdy_session = spdy_session_pool_->CreateAvailableSessionFromSocket(
       key, connection.Pass(), net_log, certificate_error_code, is_secure);
   return CheckAlternativeServiceValidityForOrigin(*spdy_session);
 }
 
 int HttpStreamFactoryImpl::Job::ValidSpdySessionPool::
     CheckAlternativeServiceValidityForOrigin(
         base::WeakPtr<SpdySession> spdy_session) {
-  // For a SPDY alternate Job, server_.host() might be different than
+  // For an alternative Job, server_.host() might be different than
   // origin_url_.host(), therefore it needs to be verified that the former
   // provides a certificate that is valid for the latter.
-  if (!is_spdy_alternate_ || !spdy_session ||
+  if (!is_spdy_alternative_ || !spdy_session ||
       spdy_session->VerifyDomainAuthentication(origin_url_.host())) {
     return OK;
   }
   return ERR_ALTERNATIVE_CERT_NOT_VALID_FOR_ORIGIN;
 }
 
 ClientSocketPoolManager::SocketGroupType
 HttpStreamFactoryImpl::Job::GetSocketGroup() const {
   std::string scheme = origin_url_.scheme();
-  if (scheme == "https" || scheme == "wss" || IsSpdyAlternate())
+  if (scheme == "https" || scheme == "wss" || is_spdy_alternative_)
     return ClientSocketPoolManager::SSL_GROUP;
 
   if (scheme == "ftp")
     return ClientSocketPoolManager::FTP_GROUP;
 
   return ClientSocketPoolManager::NORMAL_GROUP;
 }
 
 // If the connection succeeds, failed connection attempts leading up to the
 // success will be returned via the successfully connected socket. If the
 // connection fails, failed connection attempts will be returned via the
 // ClientSocketHandle. Check whether a socket was returned and copy the
 // connection attempts from the proper place.
 void HttpStreamFactoryImpl::Job::
     MaybeCopyConnectionAttemptsFromSocketOrHandle() {
   if (IsOrphaned() || !connection_)
     return;
 
   if (connection_->socket()) {
     ConnectionAttempts socket_attempts;
     connection_->socket()->GetConnectionAttempts(&socket_attempts);
     request_->AddConnectionAttempts(socket_attempts);
   } else {
     request_->AddConnectionAttempts(connection_->connection_attempts());
   }
 }
 
 }  // namespace net