Remove the confusing request_url argument from the constructors

net/http/http_proxy_client_socket_pool.cc

 // Copyright (c) 2012 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/compiler_specific.h"
 #include "base/time/time.h"
@@ skipping 14 matching lines @@
 #include "net/spdy/spdy_session_pool.h"
 #include "net/spdy/spdy_stream.h"
 #include "net/ssl/ssl_cert_request_info.h"
 #include "url/gurl.h"
 
 namespace net {
 
 HttpProxySocketParams::HttpProxySocketParams(
     const scoped_refptr<TransportSocketParams>& transport_params,
     const scoped_refptr<SSLSocketParams>& ssl_params,
-    const GURL& request_url,
     const std::string& user_agent,
     const HostPortPair& endpoint,
     HttpAuthCache* http_auth_cache,
     HttpAuthHandlerFactory* http_auth_handler_factory,
     SpdySessionPool* spdy_session_pool,
     bool tunnel,
     ProxyDelegate* proxy_delegate)
     : transport_params_(transport_params),
       ssl_params_(ssl_params),
       spdy_session_pool_(spdy_session_pool),
-      request_url_(request_url),
       user_agent_(user_agent),
       endpoint_(endpoint),
       http_auth_cache_(tunnel ? http_auth_cache : NULL),
       http_auth_handler_factory_(tunnel ? http_auth_handler_factory : NULL),
       tunnel_(tunnel),
       proxy_delegate_(proxy_delegate) {
   DCHECK((transport_params.get() == NULL && ssl_params.get() != NULL) ||
          (transport_params.get() != NULL && ssl_params.get() == NULL));
   if (transport_params_.get()) {
     ignore_limits_ = transport_params->ignore_limits();
@@ skipping 222 matching lines @@
 }
 
 int HttpProxyConnectJob::DoHttpProxyConnect() {
   next_state_ = STATE_HTTP_PROXY_CONNECT_COMPLETE;
   const HostResolver::RequestInfo& tcp_destination = params_->destination();
   const HostPortPair& proxy_server = tcp_destination.host_port_pair();
 
   // 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_->http_auth_cache(),
                                 params_->http_auth_handler_factory(),
                                 params_->tunnel(),
                                 using_spdy_,
                                 protocol_negotiated_,
                                 params_->proxy_delegate(),
                                 params_->ssl_params().get() != NULL));
@@ skipping 31 matching lines @@
   } else {
     // Create a session direct to the proxy itself
     spdy_session =
         spdy_pool->CreateAvailableSessionFromSocket(
             key, transport_socket_handle_.Pass(),
             net_log(), OK, /*using_ssl_*/ true);
     DCHECK(spdy_session);
   }
 
   next_state_ = STATE_SPDY_PROXY_CREATE_STREAM_COMPLETE;
-  return spdy_stream_request_.StartRequest(SPDY_BIDIRECTIONAL_STREAM,
-                                           spdy_session,
-                                           params_->request_url(),
-                                           priority(),
-                                           spdy_session->net_log(),
-                                           callback_);
+  return spdy_stream_request_.StartRequest(
+      SPDY_BIDIRECTIONAL_STREAM, spdy_session,
+      GURL("https://" + params_->endpoint().ToString()), priority(),
+      spdy_session->net_log(), callback_);
 }
 
 int HttpProxyConnectJob::DoSpdyProxyCreateStreamComplete(int result) {
   if (result < 0)
     return result;
 
   next_state_ = STATE_HTTP_PROXY_CONNECT_COMPLETE;
   base::WeakPtr<SpdyStream> stream = spdy_stream_request_.ReleaseStream();
   DCHECK(stream.get());
   // |transport_socket_| will set itself as |stream|'s delegate.
   transport_socket_.reset(
       new SpdyProxyClientSocket(stream,
                                 params_->user_agent(),
                                 params_->endpoint(),
-                                params_->request_url(),
                                 params_->destination().host_port_pair(),
                                 net_log(),
                                 params_->http_auth_cache(),
                                 params_->http_auth_handler_factory()));
   return transport_socket_->Connect(callback_);
 }
 
 void HttpProxyConnectJob::NotifyProxyDelegateOfCompletion(int result) {
   if (!params_->proxy_delegate())
     return;
@@ skipping 185 matching lines @@
   base_.RemoveHigherLayeredPool(higher_pool);
 }
 
 bool HttpProxyClientSocketPool::CloseOneIdleConnection() {
   if (base_.CloseOneIdleSocket())
     return true;
   return base_.CloseOneIdleConnectionInHigherLayeredPool();
 }
 
 }  // namespace net