Remove the confusing request_url argument from the constructors

net/http/http_proxy_client_socket.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.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/strings/string_util.h"
@@ skipping 10 matching lines @@
 #include "net/http/http_stream_parser.h"
 #include "net/http/proxy_connect_redirect_http_stream.h"
 #include "net/log/net_log.h"
 #include "net/socket/client_socket_handle.h"
 #include "url/gurl.h"
 
 namespace net {
 
 HttpProxyClientSocket::HttpProxyClientSocket(
     ClientSocketHandle* transport_socket,
-    const GURL& request_url,
     const std::string& user_agent,
     const HostPortPair& endpoint,
     const HostPortPair& proxy_server,
     HttpAuthCache* http_auth_cache,
     HttpAuthHandlerFactory* http_auth_handler_factory,
     bool tunnel,
     bool using_spdy,
     NextProto protocol_negotiated,
     ProxyDelegate* proxy_delegate,
     bool is_https_proxy)
@@ skipping 11 matching lines @@
           : NULL),
       tunnel_(tunnel),
       using_spdy_(using_spdy),
       protocol_negotiated_(protocol_negotiated),
       is_https_proxy_(is_https_proxy),
       redirect_has_load_timing_info_(false),
       proxy_server_(proxy_server),
       proxy_delegate_(proxy_delegate),
       net_log_(transport_socket->socket()->NetLog()) {
   // Synthesize the bits of a request that we actually use.
-  request_.url = request_url;
-  request_.method = "GET";
+  request_.url = GURL("https://" + endpoint.ToString());

[ramant (doing other things), 2015/04/06 05:27:53]

nit: should we support http and do (is_https_proxy ? "https://" : "http://") ala
auth_?

I am not an expert was GET used because of http? Just curious thanks.

[ramant (doing other things), 2015/04/06 05:34:13]

it looks like CONNECT could be used for port 80.

https://www.ietf.org/rfc/rfc2817.txt

[Ryan Hamilton, 2015/04/06 14:06:23]

So this class in only used when making CONNECT tunnels through a proxy. This
happens when an https:// URL is requested over a proxy. First the browser says:

  CONNECT host:port HTTP/1.1
  ...

to the proxy. The proxy makes a TCP connection to host:port and returns:

  HTTP/1.1 200 OK
  ...

Then it simply passes bytes in both directions. At this point, the browser can
do a TLS handshake (or whatever).

The only purpose that request_.url is serving here is to be used to populate the
"host:port" field in the request. You're right that someone may request:
https://host:80/ explicitly which will result in a CONNECT request to port 80.
But I don't think that changes what we want this code to do. You'll notice that
as a result of this change, there are some place in unit tests where we
explicitly set :80 in the Host: header, but as you see from the RFC, this
matches the spec.

What do you think?

+  request_.method = "CONNECT";
   if (!user_agent.empty())
     request_.extra_headers.SetHeader(HttpRequestHeaders::kUserAgent,
                                      user_agent);
 }
 
 HttpProxyClientSocket::~HttpProxyClientSocket() {
   Disconnect();
 }
 
 int HttpProxyClientSocket::RestartWithAuth(const CompletionCallback& callback) {
@@ skipping 481 matching lines @@
           "462784 HttpProxyClientSocket::DoTCPRestartComplete"));
 
   if (result != OK)
     return result;
 
   next_state_ = STATE_GENERATE_AUTH_TOKEN;
   return result;
 }
 
 }  // namespace net