Integrate the SpdyProxyClientSocket into the HttpStreamRequest...

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 "base/stringprintf.h"
@@ skipping 442 matching lines @@
   // 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()) {
+  if (IsHttpsProxyAndHttpUrl()) {
     HostPortProxyPair proxy(proxy_info()->proxy_server().host_port_pair(),
-                            proxy_info()->proxy_server());
+                            ProxyServer::Direct());
     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();
@@ skipping 54 matching lines @@
       }
 
       http_proxy_params =
           new HttpProxySocketParams(proxy_tcp_params,
                                     ssl_params,
                                     authentication_url,
                                     user_agent,
                                     endpoint_,
                                     session_->auth_cache(),
                                     session_->http_auth_handler_factory(),
+                                    session_->spdy_session_pool(),
+                                    session_->mutable_spdy_settings(),
                                     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());
@@ skipping 168 matching lines @@
   SpdySessionPool* spdy_pool = session_->spdy_session_pool();
   scoped_refptr<SpdySession> spdy_session;
 
   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 =
         spdy_pool->Get(pair, session_->mutable_spdy_settings(), net_log_);
-  } else if (proxy_info()->is_https()) {
+  } 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(), proxy_server);
+    pair = HostPortProxyPair(proxy_server.host_port_pair(),
+                             ProxyServer::Direct());
     if (spdy_pool->HasSession(pair)) {
       spdy_session =
           spdy_pool->Get(pair, session_->mutable_spdy_settings(), 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_->mutable_spdy_settings(), connection_.release(),
         net_log_, spdy_certificate_error_, &spdy_session, using_ssl_);
     if (error != OK)
       return error;
   }
 
   if (spdy_session->IsClosed())
     return ERR_CONNECTION_CLOSED;
 
-  stream_.reset(new SpdyHttpStream(spdy_session, direct));
+  bool useRelativeUrl = direct || request_info().url.SchemeIs("https");

[willchan no longer on Chromium, 2010/12/02 22:44:31]

is this WebKit style sneaking in here? :P
s/useRelativeUrl/use_relative_url/

+  stream_.reset(new SpdyHttpStream(spdy_session, useRelativeUrl));
   return OK;
 }
 
 int HttpStreamRequest::DoCreateStreamComplete(int result) {
   if (result < 0)
     return result;
 
   next_state_ = STATE_NONE;
   return OK;
 }
@@ skipping 26 matching lines @@
 }
 
 void HttpStreamRequest::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 HttpStreamRequest::IsHttpsProxyAndHttpUrl() {
+  return proxy_info()->is_https() && request_info().url.SchemeIs("http");
+}
+
 // Returns a newly create SSLSocketParams, and sets several
 // fields of ssl_config_.
 scoped_refptr<SSLSocketParams> HttpStreamRequest::GenerateSslParams(
     scoped_refptr<TCPSocketParams> tcp_params,
     scoped_refptr<HttpProxySocketParams> http_proxy_params,
     scoped_refptr<SOCKSSocketParams> socks_params,
     ProxyServer::Scheme proxy_scheme,
     std::string hostname,
     bool want_spdy_over_npn) {
 
@@ skipping 195 matching lines @@
                                  base::TimeDelta::FromMinutes(6),
                                  100);
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
 }  // namespace net