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

net/http/http_proxy_client_socket_pool.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_proxy_client_socket_pool.h"
 
 #include <algorithm>
 
 #include "base/time.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_proxy_client_socket.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/client_socket_pool_base.h"
 #include "net/socket/tcp_client_socket_pool.h"
+#include "net/socket/ssl_client_socket.h"
 
 namespace net {
 
 HttpProxySocketParams::HttpProxySocketParams(
     const scoped_refptr<TCPSocketParams>& tcp_params,
     const scoped_refptr<SSLSocketParams>& ssl_params,
     const GURL& request_url,
     const std::string& user_agent,
     HostPortPair endpoint,
     scoped_refptr<HttpNetworkSession> session,
@@ skipping 31 matching lines @@
     const scoped_refptr<HostResolver>& host_resolver,
     Delegate* delegate,
     NetLog* net_log)
     : ConnectJob(group_name, timeout_duration, delegate,
                  BoundNetLog::Make(net_log, NetLog::SOURCE_CONNECT_JOB)),
       params_(params),
       tcp_pool_(tcp_pool),
       ssl_pool_(ssl_pool),
       resolver_(host_resolver),
       ALLOW_THIS_IN_INITIALIZER_LIST(
-          callback_(this, &HttpProxyConnectJob::OnIOComplete)) {
+          callback_(this, &HttpProxyConnectJob::OnIOComplete)),
+      using_spdy_(false) {
 }
 
 HttpProxyConnectJob::~HttpProxyConnectJob() {}
 
 LoadState HttpProxyConnectJob::GetLoadState() const {
   switch (next_state_) {
     case kStateTCPConnect:
     case kStateTCPConnectComplete:
     case kStateSSLConnect:
     case kStateSSLConnectComplete:
@@ skipping 94 matching lines @@
 int HttpProxyConnectJob::DoSSLConnectComplete(int result) {
   if (IsCertificateError(result) &&
       params_->ssl_params()->load_flags() & LOAD_IGNORE_ALL_CERT_ERRORS)
     result = OK;
   if (result < 0) {
     if (transport_socket_handle_->socket())
       transport_socket_handle_->socket()->Disconnect();
     return result;
   }
 
+  SSLClientSocket* ssl =
+      static_cast<SSLClientSocket*>(transport_socket_handle_->socket());
+  using_spdy_ = ssl->was_spdy_negotiated();
+
   // Reset the timer to just the length of time allowed for HttpProxy handshake
   // so that a fast SSL connection plus a slow HttpProxy failure doesn't take
   // longer to timeout than it should.
   ResetTimer(base::TimeDelta::FromSeconds(
       kHttpProxyConnectJobTimeoutInSeconds));
   next_state_ = kStateHttpProxyConnect;
   return result;
 }
 
 int HttpProxyConnectJob::DoHttpProxyConnect() {
   next_state_ = kStateHttpProxyConnectComplete;
   const HostResolver::RequestInfo& tcp_destination = params_->destination();
   HostPortPair proxy_server(tcp_destination.hostname(),
                             tcp_destination.port());
 
   // Add a HttpProxy connection on top of the tcp socket.
   transport_socket_.reset(
       new HttpProxyClientSocket(transport_socket_handle_.release(),
                                 params_->request_url(),
                                 params_->user_agent(),
                                 params_->endpoint(),
                                 proxy_server, params_->session(),
-                                params_->tunnel()));
+                                params_->tunnel(),
+                                using_spdy_));
   int result = transport_socket_->Connect(&callback_);
 
   // Clear the circular reference to HttpNetworkSession (|params_| reference
   // HttpNetworkSession, which reference HttpProxyClientSocketPool, which
   // references |this|) here because it is safe to do so now but not at other
   // points.  This may cancel this ConnectJob.
   params_ = NULL;
   return result;
 }
 
@@ skipping 88 matching lines @@
     const std::string& group_name) const {
   return base_.IdleSocketCountInGroup(group_name);
 }
 
 LoadState HttpProxyClientSocketPool::GetLoadState(
     const std::string& group_name, const ClientSocketHandle* handle) const {
   return base_.GetLoadState(group_name, handle);
 }
 
 }  // namespace net