Add support for speaking SPDY to an HTTPS proxy....

net/http/http_stream_request.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_stream_request.h"
 
 #include "base/stl_util-inl.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "net/base/connection_type_histograms.h"
@@ skipping 409 matching lines @@
   using_spdy_ = false;
 
   // Check first if we have a spdy session for this group.  If so, then go
   // straight to using that.
   HostPortProxyPair pair(endpoint_, proxy_info()->proxy_server());
   if (session_->spdy_session_pool()->HasSession(pair)) {
     using_spdy_ = true;
     next_state_ = STATE_CREATE_STREAM;
     return OK;
   }
+  // Check next if we have a spdy session for this proxy.  If so, then go
+  // straight to using that.
+  if (proxy_info()->is_https()) {
+    HostPortProxyPair proxy(proxy_info()->proxy_server().host_port_pair(),
+                            proxy_info()->proxy_server());
+    if (session_->spdy_session_pool()->HasSession(proxy)) {
+      using_spdy_ = true;
+      next_state_ = STATE_CREATE_STREAM;
+      return OK;
+    }
+  }
 
   // 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();
   DCHECK(!connection_group.empty());
 
   if (using_ssl_)
     connection_group = StringPrintf("ssl/%s", connection_group.c_str());
 
   // If the user is refreshing the page, bypass the host cache.
@@ skipping 122 matching lines @@
   if (ssl_started && (result == OK || IsCertificateError(result))) {
     SSLClientSocket* ssl_socket =
       static_cast<SSLClientSocket*>(connection_->socket());
     if (ssl_socket->was_npn_negotiated()) {
       was_npn_negotiated_ = true;
       if (ssl_socket->was_spdy_negotiated())
         using_spdy_ = true;
     }
     if (force_spdy_over_ssl_ && force_spdy_always_)
       using_spdy_ = true;
+  } else if (proxy_info()->is_https() && connection_->socket() &&
+        result == OK) {
+    HttpProxyClientSocket* proxy_socket =
+      static_cast<HttpProxyClientSocket*>(connection_->socket());
+    if (proxy_socket->using_spdy()) {
+      was_npn_negotiated_ = true;
+      using_spdy_ = true;
+    }
   }
 
   // We may be using spdy without SSL
   if (!force_spdy_over_ssl_ && force_spdy_always_)
     using_spdy_ = true;
 
   if (result == ERR_PROXY_AUTH_REQUESTED) {
     DCHECK(!ssl_started);
     // Other state (i.e. |using_ssl_|) suggests that |connection_| will have an
     // SSL socket, but there was an error before that could happen.  This
@@ skipping 65 matching lines @@
   next_state_ = STATE_CREATE_STREAM_COMPLETE;
 
   if (!using_spdy_) {
     HttpBasicStream* stream = new HttpBasicStream(connection_.get());
     stream_.reset(new HttpStreamHandle(connection_.release(), stream));
     return OK;
   }
 
   CHECK(!stream_.get());
 
+  bool direct = true;
   const scoped_refptr<SpdySessionPool> spdy_pool =
       session_->spdy_session_pool();
   scoped_refptr<SpdySession> spdy_session;
 
-  HostPortProxyPair pair(endpoint_, proxy_info()->proxy_server());
-  if (session_->spdy_session_pool()->HasSession(pair)) {
+  const ProxyServer& proxy_server = proxy_info()->proxy_server();
+  HostPortProxyPair pair(endpoint_, 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 =
-        session_->spdy_session_pool()->Get(pair, session_, net_log_);
-  } else {
+        spdy_pool->Get(pair, session_, net_log_);
+  } else if (proxy_info()->is_https()) {
+    // 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(), proxy_server);
+    if (spdy_pool->HasSession(pair)) {
+      spdy_session = spdy_pool->Get(pair, session_, net_log_);
+    }
+    direct = false;
+  }
+
+  if (!spdy_session.get()) {
     // SPDY can be negotiated using the TLS next protocol negotiation (NPN)
     // extension, or just directly using SSL. Either way, |connection_| must
     // contain an SSLClientSocket.
     CHECK(connection_->socket());
     int error = spdy_pool->GetSpdySessionFromSocket(
         pair, session_, connection_.release(), net_log_,
         spdy_certificate_error_, &spdy_session, using_ssl_);
     if (error != OK)
       return error;
   }
 
   if (spdy_session->IsClosed())
     return ERR_CONNECTION_CLOSED;
 
-  SpdyHttpStream* stream = new SpdyHttpStream(spdy_session);
+  SpdyHttpStream* stream = new SpdyHttpStream(spdy_session, direct);
   stream_.reset(new HttpStreamHandle(NULL, stream));
   return OK;
 }
 
 int HttpStreamRequest::DoCreateStreamComplete(int result) {
   if (result < 0)
     return result;
 
   next_state_ = STATE_NONE;
   return OK;
@@ skipping 232 matching lines @@
                                  base::TimeDelta::FromMinutes(6),
                                  100);
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
 }  // namespace net