SPDY: Fix Alternate-Protocol.

net/http/http_network_transaction.cc

 // Copyright (c) 2010 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_network_transaction.h"
 
 #include "base/compiler_specific.h"
 #include "base/field_trial.h"
 #include "base/format_macros.h"
 #include "base/histogram.h"
@@ skipping 692 matching lines @@
   else if (proxy_info_.proxy_server().is_socks())
     proxy_mode_ = kSOCKSProxy;
   else if (using_ssl_)
     proxy_mode_ = kHTTPProxyUsingTunnel;
   else
     proxy_mode_ = kHTTPProxy;
 
   // Build the string used to uniquely identify connections of this type.
   // Determine the host and port to connect to.
   std::string connection_group;
-  std::string host;
-  int port;
+
+  // |endpoint| indicates the final destination endpoint.
+  HostPortPair endpoint;
+  endpoint.host = request_->url.HostNoBrackets();
+  endpoint.port = request_->url.EffectiveIntPort();
+
   if (proxy_mode_ != kDirectConnection) {
     ProxyServer proxy_server = proxy_info_.proxy_server();
     connection_group = "proxy/" + proxy_server.ToURI() + "/";
-    host = proxy_server.HostNoBrackets();
-    port = proxy_server.port();
+    peer_.host = proxy_server.HostNoBrackets();
+    peer_.port = proxy_server.port();
   } else {
-    host = request_->url.HostNoBrackets();
-    port = request_->url.EffectiveIntPort();
+    peer_ = endpoint;
     if (alternate_protocol_mode_ == kUnspecified) {
       const HttpAlternateProtocols& alternate_protocols =
           session_->alternate_protocols();
-      if (alternate_protocols.HasAlternateProtocolFor(host, port)) {
+      if (alternate_protocols.HasAlternateProtocolFor(peer_)) {
         HttpAlternateProtocols::PortProtocolPair alternate =
-            alternate_protocols.GetAlternateProtocolFor(host, port);
+            alternate_protocols.GetAlternateProtocolFor(peer_);
         if (alternate.protocol != HttpAlternateProtocols::BROKEN) {
           DCHECK_EQ(HttpAlternateProtocols::NPN_SPDY_1, alternate.protocol);
-          port = alternate.port;
+          peer_.port = alternate.port;
           using_ssl_ = true;
           alternate_protocol_ = HttpAlternateProtocols::NPN_SPDY_1;
           alternate_protocol_mode_ = kUsingAlternateProtocol;
         }
       }
     }
   }
 
   // Use the fixed testing ports if they've been provided.
   if (using_ssl_) {
     if (session_->fixed_https_port() != 0)
-      port = session_->fixed_https_port();
+      peer_.port = session_->fixed_https_port();
   } else if (session_->fixed_http_port() != 0) {
-    port = session_->fixed_http_port();
+    peer_.port = session_->fixed_http_port();
   }
 
   // Check first if we have a spdy session for this group.  If so, then go
   // straight to using that.
-  HostPortPair host_port_pair(host, port);
-  if (session_->spdy_session_pool()->HasSession(host_port_pair)) {
+  if (session_->spdy_session_pool()->HasSession(peer_)) {
     using_spdy_ = true;
     return OK;
   }
 
   // For a connection via HTTP proxy not using CONNECT, the connection
   // is to the proxy server only. For all other cases
-  // (direct, HTTP proxy CONNECT, SOCKS), the connection is upto the
+  // (direct, HTTP proxy CONNECT, SOCKS), the connection is up to the
   // url endpoint. Hence we append the url data into the connection_group.
-  if (proxy_mode_ != kHTTPProxy)
-    connection_group.append(request_->url.GetOrigin().spec());
+  // Note that the url endpoint may be different in the Alternate-Protocol case.
+  if (proxy_mode_ == kDirectConnection)
+    connection_group = peer_.ToString();
+  else if (proxy_mode_ != kHTTPProxy)
+    connection_group.append(endpoint.ToString());
 
   DCHECK(!connection_group.empty());
 
   // If the user is refreshing the page, bypass the host cache.
   bool disable_resolver_cache = request_->load_flags & LOAD_BYPASS_CACHE ||
     request_->load_flags & LOAD_DISABLE_CACHE;
 
-  TCPSocketParams tcp_params(host, port, request_->priority, request_->referrer,
-                             disable_resolver_cache);
+  TCPSocketParams tcp_params(peer_.host, peer_.port, request_->priority,
+                             request_->referrer, disable_resolver_cache);
 
   int rv;
   if (proxy_mode_ != kSOCKSProxy) {
     rv = connection_->Init(connection_group, tcp_params, request_->priority,
                            &io_callback_, session_->tcp_socket_pool(),
                            net_log_);
   } else {
     bool socks_v5 = proxy_info_.proxy_server().scheme() ==
                     ProxyServer::SCHEME_SOCKS5;
     SOCKSSocketParams socks_params(tcp_params, socks_v5,
@@ skipping 462 matching lines @@
 }
 
 int HttpNetworkTransaction::DoSpdySendRequest() {
   next_state_ = STATE_SPDY_SEND_REQUEST_COMPLETE;
   CHECK(!spdy_stream_.get());
 
   // First we get a SPDY session.  Theoretically, we've just negotiated one, but
   // if one already exists, then screw it, use the existing one!  Otherwise,
   // use the existing TCP socket.
 
-  HostPortPair host_port_pair(request_->url.HostNoBrackets(),
-                              request_->url.EffectiveIntPort());
   const scoped_refptr<SpdySessionPool> spdy_pool =
       session_->spdy_session_pool();
   scoped_refptr<SpdySession> spdy_session;
 
-  if (spdy_pool->HasSession(host_port_pair)) {
-    spdy_session = spdy_pool->Get(host_port_pair, session_);
+  if (spdy_pool->HasSession(peer_)) {
+    spdy_session = spdy_pool->Get(peer_, session_);
   } else {
     // SPDY is negotiated using the TLS next protocol negotiation (NPN)
     // extension, so |connection_| must contain an SSLClientSocket.
     DCHECK(using_ssl_);
+    CHECK(connection_->socket());
     spdy_session = spdy_pool->GetSpdySessionFromSSLSocket(
-        host_port_pair, session_, connection_.release());
+        peer_, session_, connection_.release());
   }
 
   CHECK(spdy_session.get());
 
   UploadDataStream* upload_data = NULL;
   if (request_->upload_data) {
     int error_code = OK;
     upload_data = UploadDataStream::Create(request_->upload_data, &error_code);
     if (!upload_data)
       return error_code;
@@ skipping 710 matching lines @@
       http_host_port_pair);
 
   alternate_protocol_mode_ = kDoNotUseAlternateProtocol;
   if (connection_->socket())
     connection_->socket()->Disconnect();
   connection_->Reset();
   next_state_ = STATE_INIT_CONNECTION;
 }
 
 }  // namespace net