Remove the confusing request_url argument from the constructors

net/spdy/spdy_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/spdy/spdy_proxy_client_socket.h"
 
 #include <algorithm>  // min
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 10 matching lines @@
 #include "net/http/proxy_connect_redirect_http_stream.h"
 #include "net/spdy/spdy_http_utils.h"
 #include "url/gurl.h"
 
 namespace net {
 
 SpdyProxyClientSocket::SpdyProxyClientSocket(
     const base::WeakPtr<SpdyStream>& spdy_stream,
     const std::string& user_agent,
     const HostPortPair& endpoint,
-    const GURL& url,
     const HostPortPair& proxy_server,
     const BoundNetLog& source_net_log,
     HttpAuthCache* auth_cache,
     HttpAuthHandlerFactory* auth_handler_factory)
     : next_state_(STATE_DISCONNECTED),
       spdy_stream_(spdy_stream),
       endpoint_(endpoint),
       auth_(new HttpAuthController(HttpAuth::AUTH_PROXY,
                                    GURL("https://" + proxy_server.ToString()),
                                    auth_cache,
                                    auth_handler_factory)),
+      user_agent_(user_agent),
       user_buffer_len_(0),
       write_buffer_len_(0),
       was_ever_used_(false),
       redirect_has_load_timing_info_(false),
       net_log_(BoundNetLog::Make(spdy_stream->net_log().net_log(),
                                  NetLog::SOURCE_PROXY_CLIENT_SOCKET)),
       weak_factory_(this),
       write_callback_weak_factory_(this) {
   request_.method = "CONNECT";
-  request_.url = url;
-  if (!user_agent.empty())
-    request_.extra_headers.SetHeader(HttpRequestHeaders::kUserAgent,
-                                     user_agent);
-
+  request_.url = GURL("https://" + endpoint.ToString());
   net_log_.BeginEvent(NetLog::TYPE_SOCKET_ALIVE,
                       source_net_log.source().ToEventParametersCallback());
   net_log_.AddEvent(
       NetLog::TYPE_HTTP2_PROXY_CLIENT_SESSION,
       spdy_stream->net_log().source().ToEventParametersCallback());
 
   spdy_stream_->SetDelegate(this);
   was_ever_used_ = spdy_stream_->WasEverUsed();
 }
 
@@ skipping 279 matching lines @@
 
 int SpdyProxyClientSocket::DoSendRequest() {
   next_state_ = STATE_SEND_REQUEST_COMPLETE;
 
   // Add Proxy-Authentication header if necessary.
   HttpRequestHeaders authorization_headers;
   if (auth_->HaveAuth()) {
     auth_->AddAuthorizationHeader(&authorization_headers);
   }
 
-  std::string user_agent;
-  if (!request_.extra_headers.GetHeader(HttpRequestHeaders::kUserAgent,
-                                        &user_agent)) {
-    user_agent.clear();
-  }
   std::string request_line;
-  HttpRequestHeaders request_headers;
-  BuildTunnelRequest(endpoint_, authorization_headers, user_agent,
-                     &request_line, &request_headers);
+  BuildTunnelRequest(endpoint_, authorization_headers, user_agent_,
+                     &request_line, &request_.extra_headers);
 
   net_log_.AddEvent(
       NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
       base::Bind(&HttpRequestHeaders::NetLogCallback,
-                 base::Unretained(&request_headers),
-                 &request_line));
+                 base::Unretained(&request_.extra_headers), &request_line));
 
-  request_.extra_headers.MergeFrom(request_headers);
   scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock());
-  CreateSpdyHeadersFromHttpRequest(request_, request_headers,
+  CreateSpdyHeadersFromHttpRequest(request_, request_.extra_headers,
                                    spdy_stream_->GetProtocolVersion(), true,
                                    headers.get());
   // Reset the URL to be the endpoint of the connection
   if (spdy_stream_->GetProtocolVersion() > 2) {
     (*headers)[":path"] = endpoint_.ToString();
     headers->erase(":scheme");
   } else {
     (*headers)["url"] = endpoint_.ToString();
     headers->erase("scheme");
   }
@@ skipping 150 matching lines @@
   } else if (!read_callback_.is_null()) {
     // If we have a read_callback_, the we need to make sure we call it back.
     OnDataReceived(scoped_ptr<SpdyBuffer>());
   }
   // This may have been deleted by read_callback_, so check first.
   if (weak_ptr.get() && !write_callback.is_null())
     write_callback.Run(ERR_CONNECTION_CLOSED);
 }
 
 }  // namespace net