Reland rest of r77399.

net/http/http_stream_factory_impl_job.cc

 // Copyright (c) 2011 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 "base/logging.h"
 #include "base/stl_util-inl.h"
-#include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "net/base/connection_type_histograms.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
 #include "net/base/ssl_cert_request_info.h"
 #include "net/http/http_basic_stream.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_proxy_client_socket.h"
 #include "net/http/http_proxy_client_socket_pool.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_stream_factory_impl_request.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/client_socket_pool.h"
 #include "net/socket/socks_client_socket_pool.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/socket/ssl_client_socket_pool.h"
 #include "net/socket/tcp_client_socket_pool.h"
 #include "net/spdy/spdy_http_stream.h"
 #include "net/spdy/spdy_session.h"
 #include "net/spdy/spdy_session_pool.h"
 
 namespace net {
 
 namespace {
 
-GURL UpgradeUrlToHttps(const GURL& original_url) {
-  GURL::Replacements replacements;
-  // new_sheme and new_port need to be in scope here because GURL::Replacements
-  // references the memory contained by them directly.
-  const std::string new_scheme = "https";
-  const std::string new_port = base::IntToString(443);
-  replacements.SetSchemeStr(new_scheme);
-  replacements.SetPortStr(new_port);
-  return original_url.ReplaceComponents(replacements);
-}
-
 }  // namespace
 
 HttpStreamFactoryImpl::Job::Job(HttpStreamFactoryImpl* stream_factory,
-                                HttpNetworkSession* session)
+                                HttpNetworkSession* session,
+                                const HttpRequestInfo& request_info,
+                                const SSLConfig& ssl_config,
+                                const BoundNetLog& net_log)
     : request_(NULL),
+      request_info_(request_info),
+      ssl_config_(ssl_config),
+      net_log_(BoundNetLog::Make(net_log.net_log(),
+                                 NetLog::SOURCE_HTTP_STREAM_JOB)),
       ALLOW_THIS_IN_INITIALIZER_LIST(io_callback_(this, &Job::OnIOComplete)),
       connection_(new ClientSocketHandle),
       session_(session),
       stream_factory_(stream_factory),
       next_state_(STATE_NONE),
       pac_request_(NULL),
+      blocking_job_(NULL),
+      dependent_job_(NULL),
       using_ssl_(false),
       using_spdy_(false),
       force_spdy_always_(HttpStreamFactory::force_spdy_always()),
       force_spdy_over_ssl_(HttpStreamFactory::force_spdy_over_ssl()),
       spdy_certificate_error_(OK),
-      alternate_protocol_(HttpAlternateProtocols::UNINITIALIZED),
       establishing_tunnel_(false),
-      was_alternate_protocol_available_(false),
       was_npn_negotiated_(false),
       num_streams_(0),
       spdy_session_direct_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {
   DCHECK(stream_factory);
   DCHECK(session);
-  if (HttpStreamFactory::use_alternate_protocols())
-    alternate_protocol_mode_ = kUnspecified;
-  else
-    alternate_protocol_mode_ = kDoNotUseAlternateProtocol;
 }
 
 HttpStreamFactoryImpl::Job::~Job() {
   net_log_.EndEvent(NetLog::TYPE_HTTP_STREAM_JOB, NULL);
 
   // 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();
     connection_.reset();
   }
 
   if (pac_request_)
     session_->proxy_service()->CancelPacRequest(pac_request_);
 
   // The stream could be in a partial state.  It is not reusable.
   if (stream_.get() && next_state_ != STATE_DONE)
     stream_->Close(true /* not reusable */);
 }
 
-void HttpStreamFactoryImpl::Job::Start(Request* request,
-                                       const HttpRequestInfo& request_info,
-                                       const SSLConfig& ssl_config,
-                                       const BoundNetLog& net_log) {
+void HttpStreamFactoryImpl::Job::Start(Request* request) {
   DCHECK(request);
   request_ = request;
-  StartInternal(request_info, ssl_config, net_log);
+  StartInternal();
 }
 
-int HttpStreamFactoryImpl::Job::Preconnect(int num_streams,
-                                           const HttpRequestInfo& request_info,
-                                           const SSLConfig& ssl_config,
-                                           const BoundNetLog& net_log) {
+int HttpStreamFactoryImpl::Job::Preconnect(int num_streams) {
   DCHECK_GT(num_streams, 0);
   num_streams_ = num_streams;
-  return StartInternal(request_info, ssl_config, net_log);
+  return StartInternal();
 }
 
 int HttpStreamFactoryImpl::Job::RestartTunnelWithProxyAuth(
     const string16& username, const string16& password) {
   DCHECK(establishing_tunnel_);
   next_state_ = STATE_RESTART_TUNNEL_AUTH;
   stream_.reset();
   return RunLoop(OK);
 }
 
 LoadState HttpStreamFactoryImpl::Job::GetLoadState() const {
   switch (next_state_) {
     case STATE_RESOLVE_PROXY_COMPLETE:
       return LOAD_STATE_RESOLVING_PROXY_FOR_URL;
     case STATE_CREATE_STREAM_COMPLETE:
       return connection_->GetLoadState();
     case STATE_INIT_CONNECTION_COMPLETE:
       return LOAD_STATE_SENDING_REQUEST;
     default:
       return LOAD_STATE_IDLE;
   }
 }
 
+void HttpStreamFactoryImpl::Job::MarkAsAlternate(const GURL& original_url) {
+  DCHECK(!original_url_.get());
+  original_url_.reset(new GURL(original_url));
+}
+
+void HttpStreamFactoryImpl::Job::WaitFor(Job* job) {
+  DCHECK_EQ(STATE_NONE, next_state_);
+  DCHECK_EQ(STATE_NONE, job->next_state_);
+  DCHECK(!blocking_job_);
+  DCHECK(!job->dependent_job_);
+  blocking_job_ = job;
+  job->dependent_job_ = this;
+}
+
+void HttpStreamFactoryImpl::Job::Resume(Job* job) {
+  DCHECK_EQ(blocking_job_, job);
+  blocking_job_ = NULL;
+
+  // We know we're blocked if the next_state_ is STATE_WAIT_FOR_JOB_COMPLETE.
+  // Unblock |this|.
+  if (next_state_ == STATE_WAIT_FOR_JOB_COMPLETE) {
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        method_factory_.NewRunnableMethod(
+            &HttpStreamFactoryImpl::Job::OnIOComplete, OK));
+  }
+}
+
 void HttpStreamFactoryImpl::Job::Orphan(const Request* request) {
   DCHECK_EQ(request_, request);
   request_ = NULL;
-}
-
-bool HttpStreamFactoryImpl::Job::was_alternate_protocol_available() const {
-  return was_alternate_protocol_available_;
+  // We've been orphaned, but there's a job we're blocked on. Don't bother
+  // racing, just cancel ourself.
+  if (blocking_job_) {
+    DCHECK(blocking_job_->dependent_job_);
+    blocking_job_->dependent_job_ = NULL;
+    blocking_job_ = NULL;
+    stream_factory_->OnOrphanedJobComplete(this);
+  }
 }
 
 bool HttpStreamFactoryImpl::Job::was_npn_negotiated() const {
   return was_npn_negotiated_;
 }
 
 bool HttpStreamFactoryImpl::Job::using_spdy() const {
   return using_spdy_;
 }
 
@@ skipping 13 matching lines @@
       static_cast<SSLClientSocket*>(connection_->socket());
   ssl_socket->GetSSLInfo(&ssl_info_);
 }
 
 void HttpStreamFactoryImpl::Job::OnStreamReadyCallback() {
   DCHECK(stream_.get());
   DCHECK(!IsPreconnecting());
   if (IsOrphaned()) {
     stream_factory_->OnOrphanedJobComplete(this);
   } else {
-    request_->Complete(was_alternate_protocol_available(),
-                       was_npn_negotiated(),
+    request_->Complete(was_npn_negotiated(),
                        using_spdy(),
                        net_log_.source());
     request_->OnStreamReady(this, ssl_config_, proxy_info_, stream_.release());
   }
   // |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::OnSpdySessionReadyCallback() {
   DCHECK(!stream_.get());
   DCHECK(!IsPreconnecting());
   DCHECK(using_spdy());
   DCHECK(new_spdy_session_);
   scoped_refptr<SpdySession> spdy_session = new_spdy_session_;
   new_spdy_session_ = NULL;
   if (IsOrphaned()) {
     stream_factory_->OnSpdySessionReady(
         spdy_session, spdy_session_direct_, ssl_config_, proxy_info_,
-        was_alternate_protocol_available(), was_npn_negotiated(),
-        using_spdy(), net_log_.source());
+        was_npn_negotiated(), using_spdy(), net_log_.source());
     stream_factory_->OnOrphanedJobComplete(this);
   } else {
     request_->OnSpdySessionReady(this, spdy_session, spdy_session_direct_);
   }
   // |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::OnStreamFailedCallback(int result) {
   DCHECK(!IsPreconnecting());
   if (IsOrphaned())
@@ skipping 45 matching lines @@
     request_->OnHttpsProxyTunnelResponse(
         this, response_info, ssl_config_, proxy_info_, stream);
   // |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::OnPreconnectsComplete() {
   DCHECK(!request_);
   if (new_spdy_session_) {
     stream_factory_->OnSpdySessionReady(
         new_spdy_session_, spdy_session_direct_, ssl_config_,
-        proxy_info_, was_alternate_protocol_available(),
-        was_npn_negotiated(), using_spdy(), net_log_.source());
+        proxy_info_, was_npn_negotiated(), using_spdy(), net_log_.source());
   }
   stream_factory_->OnPreconnectsComplete(this);
   // |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::OnIOComplete(int result) {
   RunLoop(result);
 }
 
 int HttpStreamFactoryImpl::Job::RunLoop(int result) {
@@ skipping 103 matching lines @@
     State state = next_state_;
     next_state_ = STATE_NONE;
     switch (state) {
       case STATE_RESOLVE_PROXY:
         DCHECK_EQ(OK, rv);
         rv = DoResolveProxy();
         break;
       case STATE_RESOLVE_PROXY_COMPLETE:
         rv = DoResolveProxyComplete(rv);
         break;
+      case STATE_WAIT_FOR_JOB:
+        DCHECK_EQ(OK, rv);
+        rv = DoWaitForJob();
+        break;
+      case STATE_WAIT_FOR_JOB_COMPLETE:
+        rv = DoWaitForJobComplete(rv);
+        break;
       case STATE_INIT_CONNECTION:
         DCHECK_EQ(OK, rv);
         rv = DoInitConnection();
         break;
       case STATE_INIT_CONNECTION_COMPLETE:
         rv = DoInitConnectionComplete(rv);
         break;
       case STATE_WAITING_USER_ACTION:
         rv = DoWaitingUserAction(rv);
         break;
@@ skipping 13 matching lines @@
         break;
       default:
         NOTREACHED() << "bad state";
         rv = ERR_FAILED;
         break;
     }
   } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);
   return rv;
 }
 
-int HttpStreamFactoryImpl::Job::StartInternal(
-    const HttpRequestInfo& request_info,
-    const SSLConfig& ssl_config,
-    const BoundNetLog& net_log) {
+int HttpStreamFactoryImpl::Job::StartInternal() {
   CHECK_EQ(STATE_NONE, next_state_);
-  request_info_ = request_info;
-  ssl_config_ = ssl_config;
-  net_log_ = BoundNetLog::Make(net_log.net_log(),
-                               NetLog::SOURCE_HTTP_STREAM_JOB);
   net_log_.BeginEvent(NetLog::TYPE_HTTP_STREAM_JOB,
                       make_scoped_refptr(new NetLogStringParameter(
-                          "url", request_info.url.GetOrigin().spec())));
+                          "url", request_info_.url.GetOrigin().spec())));
   next_state_ = STATE_RESOLVE_PROXY;
   int rv = RunLoop(OK);
   DCHECK_EQ(ERR_IO_PENDING, rv);
   return rv;
 }
 
 int HttpStreamFactoryImpl::Job::DoResolveProxy() {
   DCHECK(!pac_request_);
 
   next_state_ = STATE_RESOLVE_PROXY_COMPLETE;
 
-  // |endpoint_| indicates the final destination endpoint.
-  endpoint_ = HostPortPair(request_info_.url.HostNoBrackets(),
-                           request_info_.url.EffectiveIntPort());
-
-  // Extra URL we might be attempting to resolve to.
-  GURL alternate_endpoint_url = request_info_.url;
-
-  // Tracks whether we are using |request_.url| or |alternate_endpoint_url|.
-  const GURL *curr_endpoint_url = &request_info_.url;
-
-  alternate_endpoint_url =
-      HttpStreamFactory::ApplyHostMappingRules(
-          alternate_endpoint_url, &endpoint_);
-
-  const HttpAlternateProtocols& alternate_protocols =
-      session_->alternate_protocols();
-  if (HttpStreamFactory::spdy_enabled() &&
-      alternate_protocols.HasAlternateProtocolFor(endpoint_)) {
-    was_alternate_protocol_available_ = true;
-    if (alternate_protocol_mode_ == kUnspecified) {
-      HttpAlternateProtocols::PortProtocolPair alternate =
-          alternate_protocols.GetAlternateProtocolFor(endpoint_);
-      if (alternate.protocol != HttpAlternateProtocols::BROKEN) {
-        DCHECK_LE(HttpAlternateProtocols::NPN_SPDY_1, alternate.protocol);
-        DCHECK_GT(HttpAlternateProtocols::NUM_ALTERNATE_PROTOCOLS,
-                  alternate.protocol);
-        endpoint_.set_port(alternate.port);
-        alternate_protocol_ = alternate.protocol;
-        alternate_protocol_mode_ = kUsingAlternateProtocol;
-        alternate_endpoint_url = UpgradeUrlToHttps(*curr_endpoint_url);
-        curr_endpoint_url = &alternate_endpoint_url;
-      }
-    }
-  }
+  origin_ = HostPortPair(request_info_.url.HostNoBrackets(),
+                         request_info_.url.EffectiveIntPort());
 
   if (request_info_.load_flags & LOAD_BYPASS_PROXY) {
     proxy_info_.UseDirect();
     return OK;
   }
 
   return session_->proxy_service()->ResolveProxy(
-      *curr_endpoint_url, &proxy_info_, &io_callback_, &pac_request_,
+      request_info_.url, &proxy_info_, &io_callback_, &pac_request_,
       net_log_);
 }
 
 int HttpStreamFactoryImpl::Job::DoResolveProxyComplete(int result) {
   pac_request_ = NULL;
 
-  if (result != OK)
-    return result;
+  if (result == OK) {
+    // Remove unsupported proxies from the list.
+    proxy_info_.RemoveProxiesWithoutScheme(
+        ProxyServer::SCHEME_DIRECT |
+        ProxyServer::SCHEME_HTTP | ProxyServer::SCHEME_HTTPS |
+        ProxyServer::SCHEME_SOCKS4 | ProxyServer::SCHEME_SOCKS5);
 
-  // TODO(mbelshe): consider retrying ResolveProxy if we came here via use of
-  // AlternateProtocol.
-
-  // Remove unsupported proxies from the list.
-  proxy_info_.RemoveProxiesWithoutScheme(
-      ProxyServer::SCHEME_DIRECT |
-      ProxyServer::SCHEME_HTTP | ProxyServer::SCHEME_HTTPS |
-      ProxyServer::SCHEME_SOCKS4 | ProxyServer::SCHEME_SOCKS5);
-
-  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.
-    return ERR_NO_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;
+    }
   }
 
+  if (result != OK) {
+    if (dependent_job_)
+      dependent_job_->Resume(this);
+    return result;
+  }
+
+  if (blocking_job_)
+    next_state_ = STATE_WAIT_FOR_JOB;
+  else
+    next_state_ = STATE_INIT_CONNECTION;
+  return OK;
+}
+
+bool HttpStreamFactoryImpl::Job::ShouldForceSpdySSL() const {
+  return force_spdy_always_ && force_spdy_over_ssl_;
+}
+
+bool HttpStreamFactoryImpl::Job::ShouldForceSpdyWithoutSSL() const {
+  return force_spdy_always_ && !force_spdy_over_ssl_;
+}
+
+int HttpStreamFactoryImpl::Job::DoWaitForJob() {
+  DCHECK(blocking_job_);
+  next_state_ = STATE_WAIT_FOR_JOB_COMPLETE;
+  return ERR_IO_PENDING;
+}
+
+int HttpStreamFactoryImpl::Job::DoWaitForJobComplete(int result) {
+  DCHECK(!blocking_job_);
+  DCHECK_EQ(OK, result);
   next_state_ = STATE_INIT_CONNECTION;
   return OK;
 }
 
-static bool HasSpdyExclusion(const HostPortPair& endpoint) {
-  std::list<HostPortPair>* exclusions =
-      HttpStreamFactory::forced_spdy_exclusions();
-  if (!exclusions)
-    return false;
-
-  std::list<HostPortPair>::const_iterator it;
-  for (it = exclusions->begin(); it != exclusions->end(); it++)
-    if (it->Equals(endpoint))
-      return true;
-  return false;
-}
-
-bool HttpStreamFactoryImpl::Job::ShouldForceSpdySSL() {
-  bool rv = force_spdy_always_ && force_spdy_over_ssl_;
-  return rv && !HasSpdyExclusion(endpoint_);
-}
-
-bool HttpStreamFactoryImpl::Job::ShouldForceSpdyWithoutSSL() {
-   bool rv = force_spdy_always_ && !force_spdy_over_ssl_;
-  return rv && !HasSpdyExclusion(endpoint_);
-}
-
 int HttpStreamFactoryImpl::Job::DoInitConnection() {
+  DCHECK(!blocking_job_);
   DCHECK(!connection_->is_initialized());
   DCHECK(proxy_info_.proxy_server().is_valid());
   next_state_ = STATE_INIT_CONNECTION_COMPLETE;
 
-  bool want_spdy_over_npn =
-      alternate_protocol_mode_ == kUsingAlternateProtocol &&
-      alternate_protocol_ == HttpAlternateProtocols::NPN_SPDY_2;
-  using_ssl_ = request_info_.url.SchemeIs("https") ||
-      ShouldForceSpdySSL() || want_spdy_over_npn;
+  using_ssl_ = request_info_.url.SchemeIs("https") || ShouldForceSpdySSL();
   using_spdy_ = false;
 
-  // If spdy has been turned off on-the-fly, then there may be SpdySessions
-  // still active.  But don't use them unless spdy is currently on.
-  if (HttpStreamFactory::spdy_enabled() && !HasSpdyExclusion(endpoint_)) {
-    // Check first if we have a spdy session for this group.  If so, then go
-    // straight to using that.
-    HostPortProxyPair spdy_session_key;
-    if (IsHttpsProxyAndHttpUrl()) {
-      spdy_session_key =
-          HostPortProxyPair(proxy_info_.proxy_server().host_port_pair(),
-                            ProxyServer::Direct());
-    } else {
-      spdy_session_key =
-          HostPortProxyPair(endpoint_, proxy_info_.proxy_server());
-    }
-    if (session_->spdy_session_pool()->HasSession(spdy_session_key)) {
-      // If we're preconnecting, but we already have a SpdySession, we don't
-      // actually need to preconnect any sockets, so we're done.
-      if (IsPreconnecting())
-        return OK;
-      using_spdy_ = true;
-      next_state_ = STATE_CREATE_STREAM;
+  // Check first if we have a spdy session for this group.  If so, then go
+  // straight to using that.
+  HostPortProxyPair spdy_session_key;
+  if (IsHttpsProxyAndHttpUrl()) {
+    spdy_session_key =
+        HostPortProxyPair(proxy_info_.proxy_server().host_port_pair(),
+                          ProxyServer::Direct());
+  } else {
+    spdy_session_key = HostPortProxyPair(origin_, proxy_info_.proxy_server());
+  }
+  if (session_->spdy_session_pool()->HasSession(spdy_session_key)) {
+    // If we're preconnecting, but we already have a SpdySession, we don't
+    // actually need to preconnect any sockets, so we're done.
+    if (IsPreconnecting())
       return OK;
-    } else if (request_) {
-      // Update the spdy session key for the request that launched this job.
-      request_->SetSpdySessionKey(spdy_session_key);
-    }
+    using_spdy_ = true;
+    next_state_ = STATE_CREATE_STREAM;
+    return OK;
+  } else if (request_ && (using_ssl_ || ShouldForceSpdyWithoutSSL())) {
+    // Update the spdy session key for the request that launched this job.
+    request_->SetSpdySessionKey(spdy_session_key);
+  }
+
+  // OK, there's no available SPDY session. Let |dependent_job_| resume if it's
+  // paused.
+
+  if (dependent_job_) {
+    dependent_job_->Resume(this);
+    dependent_job_ = NULL;
   }
 
   // Build the string used to uniquely identify connections of this type.
   // Determine the host and port to connect to.
-  std::string connection_group = endpoint_.ToString();
+  std::string connection_group = origin_.ToString();
   DCHECK(!connection_group.empty());
 
   if (using_ssl_)
     connection_group = base::StringPrintf("ssl/%s", connection_group.c_str());
 
   // If the user is refreshing the page, bypass the host cache.
   bool disable_resolver_cache =
       request_info_.load_flags & LOAD_BYPASS_CACHE ||
       request_info_.load_flags & LOAD_VALIDATE_CACHE ||
       request_info_.load_flags & LOAD_DISABLE_CACHE;
 
   // Build up the connection parameters.
   scoped_refptr<TCPSocketParams> tcp_params;
   scoped_refptr<HttpProxySocketParams> http_proxy_params;
   scoped_refptr<SOCKSSocketParams> socks_params;
   scoped_ptr<HostPortPair> proxy_host_port;
 
   if (proxy_info_.is_direct()) {
-    tcp_params = new TCPSocketParams(endpoint_, request_info_.priority,
+    tcp_params = new TCPSocketParams(origin_, request_info_.priority,
                                      request_info_.referrer,
                                      disable_resolver_cache);
   } else {
     ProxyServer proxy_server = proxy_info_.proxy_server();
     proxy_host_port.reset(new HostPortPair(proxy_server.host_port_pair()));
     scoped_refptr<TCPSocketParams> proxy_tcp_params(
         new TCPSocketParams(*proxy_host_port, request_info_.priority,
                             request_info_.referrer, disable_resolver_cache));
 
     if (proxy_info_.is_http() || proxy_info_.is_https()) {
-      GURL authentication_url = request_info_.url;
-      if (using_ssl_ && !authentication_url.SchemeIs("https")) {
-        // If a proxy tunnel connection needs to be established due to
-        // an Alternate-Protocol, the URL needs to be changed to indicate
-        // https or digest authentication attempts will fail.
-        // For example, suppose the initial request was for
-        // "http://www.example.com/index.html". If this is an SSL
-        // upgrade due to alternate protocol, the digest authorization
-        // should have a uri="www.example.com:443" field rather than a
-        // "/index.html" entry, even though the original request URL has not
-        // changed.
-        authentication_url = UpgradeUrlToHttps(authentication_url);
-      }
       establishing_tunnel_ = using_ssl_;
       std::string user_agent;
       request_info_.extra_headers.GetHeader(HttpRequestHeaders::kUserAgent,
                                              &user_agent);
       scoped_refptr<SSLSocketParams> ssl_params;
       if (proxy_info_.is_https()) {
         // Set ssl_params, and unset proxy_tcp_params
         ssl_params = GenerateSSLParams(proxy_tcp_params, NULL, NULL,
                                        ProxyServer::SCHEME_DIRECT,
                                        *proxy_host_port.get(),
-                                       want_spdy_over_npn);
+                                       original_url_.get() ? true : false);
         proxy_tcp_params = NULL;
       }
 
       http_proxy_params =
           new HttpProxySocketParams(proxy_tcp_params,
                                     ssl_params,
-                                    authentication_url,
+                                    request_info_.url,
                                     user_agent,
-                                    endpoint_,
+                                    origin_,
                                     session_->http_auth_cache(),
                                     session_->http_auth_handler_factory(),
                                     session_->spdy_session_pool(),
                                     using_ssl_);
     } else {
       DCHECK(proxy_info_.is_socks());
       char socks_version;
       if (proxy_server.scheme() == ProxyServer::SCHEME_SOCKS5)
         socks_version = '5';
       else
         socks_version = '4';
       connection_group = base::StringPrintf(
           "socks%c/%s", socks_version, connection_group.c_str());
 
       socks_params = new SOCKSSocketParams(proxy_tcp_params,
                                            socks_version == '5',
-                                           endpoint_,
+                                           origin_,
                                            request_info_.priority,
                                            request_info_.referrer);
     }
   }
 
   // Deal with SSL - which layers on top of any given proxy.
   if (using_ssl_) {
     scoped_refptr<SSLSocketParams> ssl_params =
         GenerateSSLParams(tcp_params, http_proxy_params, socks_params,
                           proxy_info_.proxy_server().scheme(),
-                          HostPortPair::FromURL(request_info_.url),
-                          want_spdy_over_npn);
+                          origin_, original_url_.get() ? true : false);
     SSLClientSocketPool* ssl_pool = NULL;
     if (proxy_info_.is_direct())
       ssl_pool = session_->ssl_socket_pool();
     else
       ssl_pool = session_->GetSocketPoolForSSLWithProxy(*proxy_host_port);
 
     if (IsPreconnecting()) {
       RequestSocketsForPool(ssl_pool, connection_group, ssl_params,
                             num_streams_, net_log_);
       return OK;
@@ skipping 46 matching lines @@
                            request_info_.priority, &io_callback_,
                            pool, net_log_);
 }
 
 int HttpStreamFactoryImpl::Job::DoInitConnectionComplete(int result) {
   if (IsPreconnecting()) {
     DCHECK_EQ(OK, result);
     return OK;
   }
 
+  // TODO(willchan): Make this a bit more exact. Maybe there are recoverable
+  // errors, such as ignoring certificate errors for Alternate-Protocol.
+  if (result < 0 && dependent_job_) {
+    dependent_job_->Resume(this);
+    dependent_job_ = NULL;
+  }
+
   // |result| may be the result of any of the stacked pools. The following
   // logic is used when determining how to interpret an error.
   // If |result| < 0:
   //   and connection_->socket() != NULL, then the SSL handshake ran and it
   //     is a potentially recoverable error.
   //   and connection_->socket == NULL and connection_->is_ssl_error() is true,
   //     then the SSL handshake ran with an unrecoverable error.
   //   otherwise, the error came from one of the other pools.
   bool ssl_started = using_ssl_ && (result == OK || connection_->socket() ||
                                     connection_->is_ssl_error());
@@ skipping 28 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 ((!ssl_started && result < 0 &&
-       alternate_protocol_mode_ == kUsingAlternateProtocol) ||
-      result == ERR_NPN_NEGOTIATION_FAILED) {
+  if (!ssl_started && result < 0 && original_url_.get()) {
     // Mark the alternate protocol as broken and fallback.
-    MarkBrokenAlternateProtocolAndFallback();
-    return OK;
+    session_->mutable_alternate_protocols()->MarkBrokenAlternateProtocolFor(
+        HostPortPair::FromURL(*original_url_));
+    return result;
   }
 
   if (result < 0 && !ssl_started)
     return ReconsiderProxyAfterError(result);
   establishing_tunnel_ = false;
 
   if (connection_->socket()) {
     LogHttpConnectedMetrics(*connection_);
 
     // We officially have a new connection.  Record the type.
     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_ && request_info_.url.SchemeIs("http")) {
+      if (using_spdy_ && original_url_.get() &&
+          original_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 33 matching lines @@
                                       using_proxy));
     return OK;
   }
 
   CHECK(!stream_.get());
 
   bool direct = true;
   SpdySessionPool* spdy_pool = session_->spdy_session_pool();
   scoped_refptr<SpdySession> spdy_session;
 
-  HostPortProxyPair pair(endpoint_, proxy_server);
+  HostPortProxyPair pair(origin_, proxy_server);
   if (spdy_pool->HasSession(pair)) {
     // We have a SPDY session to the origin server.  This might be a direct
     // connection, or it might be a SPDY session through an HTTP or HTTPS proxy.
     spdy_session = spdy_pool->Get(pair, net_log_);
   } else if (IsHttpsProxyAndHttpUrl()) {
     // If we don't have a direct SPDY session, and we're using an HTTPS
     // proxy, then we might have a SPDY session to the proxy.
     pair = HostPortProxyPair(proxy_server.host_port_pair(),
                              ProxyServer::Direct());
     if (spdy_pool->HasSession(pair)) {
@@ skipping 83 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() {
-  return proxy_info_.is_https() && request_info_.url.SchemeIs("http");
+  if (!proxy_info_.is_https())
+    return false;
+  if (original_url_.get()) {
+    // We currently only support Alternate-Protocol where the original scheme
+    // is http.
+    DCHECK(original_url_->SchemeIs("http"));
+    return original_url_->SchemeIs("http");
+  }
+  return request_info_.url.SchemeIs("http");
 }
 
 // Returns a newly create SSLSocketParams, and sets several
 // fields of ssl_config_.
 scoped_refptr<SSLSocketParams> HttpStreamFactoryImpl::Job::GenerateSSLParams(
     scoped_refptr<TCPSocketParams> tcp_params,
     scoped_refptr<HttpProxySocketParams> http_proxy_params,
     scoped_refptr<SOCKSSocketParams> socks_params,
     ProxyServer::Scheme proxy_scheme,
-    const HostPortPair& host_and_port,
+    const HostPortPair& origin_server,
     bool want_spdy_over_npn) {
 
-  if (stream_factory_->IsTLSIntolerantServer(request_info_.url)) {
+  if (stream_factory_->IsTLSIntolerantServer(origin_server)) {
     LOG(WARNING) << "Falling back to SSLv3 because host is TLS intolerant: "
-        << GetHostAndPort(request_info_.url);
+        << origin_server.ToString();
     ssl_config_.ssl3_fallback = true;
     ssl_config_.tls1_enabled = false;
   }
 
   if (proxy_info_.is_https() && ssl_config_.send_client_cert) {
     // When connecting through an HTTPS proxy, disable TLS False Start so
     // that client authentication errors can be distinguished between those
     // originating from the proxy server (ERR_PROXY_CONNECTION_FAILED) and
     // those originating from the endpoint (ERR_SSL_PROTOCOL_ERROR /
     // ERR_BAD_SSL_CLIENT_AUTH_CERT).
@@ skipping 12 matching lines @@
   if (request_info_.load_flags & LOAD_VERIFY_EV_CERT)
     ssl_config_.verify_ev_cert = true;
 
   if (proxy_info_.proxy_server().scheme() == ProxyServer::SCHEME_HTTP ||
       proxy_info_.proxy_server().scheme() == ProxyServer::SCHEME_HTTPS) {
     ssl_config_.mitm_proxies_allowed = true;
   }
 
   scoped_refptr<SSLSocketParams> ssl_params(
       new SSLSocketParams(tcp_params, socks_params, http_proxy_params,
-                          proxy_scheme, host_and_port,
+                          proxy_scheme, origin_server,
                           ssl_config_, load_flags,
                           ShouldForceSpdySSL(),
                           want_spdy_over_npn));
 
   return ssl_params;
 }
 
 
-void HttpStreamFactoryImpl::Job::MarkBrokenAlternateProtocolAndFallback() {
-  // We have to:
-  // * Reset the endpoint to be the unmodified URL specified destination.
-  // * Mark the endpoint as broken so we don't try again.
-  // * Set the alternate protocol mode to kDoNotUseAlternateProtocol so we
-  // ignore future Alternate-Protocol headers from the HostPortPair.
-  // * Reset the connection and go back to STATE_INIT_CONNECTION.
-
-  endpoint_ = HostPortPair(request_info_.url.HostNoBrackets(),
-                           request_info_.url.EffectiveIntPort());
-
-  session_->mutable_alternate_protocols()->MarkBrokenAlternateProtocolFor(
-      endpoint_);
-
-  alternate_protocol_mode_ = kDoNotUseAlternateProtocol;
-  ReturnToStateInitConnection(false /* close connection */);
-}
-
 int HttpStreamFactoryImpl::Job::ReconsiderProxyAfterError(int error) {
   DCHECK(!pac_request_);
 
   // A failure to resolve the hostname or any error related to establishing a
   // TCP connection could be grounds for trying a new proxy configuration.
   //
   // Why do this when a hostname cannot be resolved?  Some URLs only make sense
   // to proxy servers.  The hostname in those URLs might fail to resolve if we
   // are still using a non-proxy config.  We need to check if a proxy config
   // now exists that corresponds to a proxy server that could load the URL.
@@ skipping 124 matching lines @@
 bool HttpStreamFactoryImpl::Job::IsPreconnecting() const {
   DCHECK_GE(num_streams_, 0);
   return num_streams_ > 0;
 }
 
 bool HttpStreamFactoryImpl::Job::IsOrphaned() const {
   return !IsPreconnecting() && !request_;
 }
 
 }  // namespace net