Remove proxy_mode_ from the HttpNetworkTransaction since it...

net/http/http_network_transaction.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_network_transaction.h"
 
 #include "base/compiler_specific.h"
 #include "base/field_trial.h"
 #include "base/format_macros.h"
 #include "base/histogram.h"
@@ skipping 204 matching lines @@
           io_callback_(this, &HttpNetworkTransaction::OnIOComplete)),
       user_callback_(NULL),
       session_(session),
       request_(NULL),
       pac_request_(NULL),
       connection_(new ClientSocketHandle),
       reused_socket_(false),
       headers_valid_(false),
       logged_response_time(false),
       using_ssl_(false),
-      proxy_mode_(kDirectConnection),
       establishing_tunnel_(false),
       using_spdy_(false),
       alternate_protocol_mode_(
           g_use_alternate_protocols ? kUnspecified :
           kDoNotUseAlternateProtocol),
       embedded_identity_used_(false),
       default_credentials_used_(false),
       read_buf_len_(0),
       next_state_(STATE_NONE) {
   session->ssl_config_service()->GetSSLConfig(&ssl_config_);
@@ skipping 454 matching lines @@
 
 int HttpNetworkTransaction::DoInitConnection() {
   DCHECK(!connection_->is_initialized());
   DCHECK(proxy_info_.proxy_server().is_valid());
 
   next_state_ = STATE_INIT_CONNECTION_COMPLETE;
 
   using_ssl_ = request_->url.SchemeIs("https");
   using_spdy_ = false;
 
-  // TODO(vandebo) get rid of proxy_mode_, it's redundant
-  if (proxy_info_.is_direct())
-    proxy_mode_ = kDirectConnection;
-  else if (proxy_info_.proxy_server().is_socks())
-    proxy_mode_ = kSOCKSProxy;
-  else if (using_ssl_)
-    proxy_mode_ = kHTTPProxyUsingTunnel;
-  else
-    proxy_mode_ = kHTTPProxy;
-
   // Build the string used to uniquely identify connections of this type.
   // Determine the host and port to connect to.
   std::string connection_group;
 
   // |endpoint| indicates the final destination endpoint.
   HostPortPair endpoint;
   endpoint.host = request_->url.HostNoBrackets();
   endpoint.port = request_->url.EffectiveIntPort();
 
-  if (proxy_mode_ != kDirectConnection) {
+  if (!proxy_info_.is_direct()) {
     ProxyServer proxy_server = proxy_info_.proxy_server();
     connection_group = "proxy/" + proxy_server.ToURI() + "/";
     peer_.host = proxy_server.HostNoBrackets();
     peer_.port = proxy_server.port();
   } else {
     peer_ = endpoint;
     if (alternate_protocol_mode_ == kUnspecified) {
       const HttpAlternateProtocols& alternate_protocols =
           session_->alternate_protocols();
       if (alternate_protocols.HasAlternateProtocolFor(peer_)) {
@@ skipping 23 matching lines @@
   if (session_->spdy_session_pool()->HasSession(peer_)) {
     using_spdy_ = true;
     return OK;
   }
 
   // For a connection via HTTP proxy not using CONNECT, the connection
   // is to the proxy server only. For all other cases
   // (direct, HTTP proxy CONNECT, SOCKS), the connection is up to the
   // url endpoint. Hence we append the url data into the connection_group.
   // Note that the url endpoint may be different in the Alternate-Protocol case.
-  if (proxy_mode_ == kDirectConnection)
+  if (proxy_info_.is_direct())
     connection_group = peer_.ToString();
-  else if (proxy_mode_ != kHTTPProxy)
+  else if (using_ssl_ || proxy_info_.is_socks())
     connection_group.append(endpoint.ToString());
 
   DCHECK(!connection_group.empty());
 
   // If the user is refreshing the page, bypass the host cache.
   bool disable_resolver_cache = request_->load_flags & LOAD_BYPASS_CACHE ||
     request_->load_flags & LOAD_DISABLE_CACHE;
 
   TCPSocketParams tcp_params(peer_.host, peer_.port, request_->priority,
                              request_->referrer, disable_resolver_cache);
 
   int rv;
-  if (proxy_mode_ != kSOCKSProxy) {
+  if (!proxy_info_.is_socks()) {
     rv = connection_->Init(connection_group, tcp_params, request_->priority,
                            &io_callback_, session_->tcp_socket_pool(),
                            net_log_);
   } else {
     bool socks_v5 = proxy_info_.proxy_server().scheme() ==
                     ProxyServer::SCHEME_SOCKS5;
     SOCKSSocketParams socks_params(tcp_params, socks_v5,
                                    request_->url.HostNoBrackets(),
                                    request_->url.EffectiveIntPort(),
                                    request_->priority, request_->referrer);
@@ skipping 30 matching lines @@
   // Set the reused_socket_ flag to indicate that we are using a keep-alive
   // connection.  This flag is used to handle errors that occur while we are
   // trying to reuse a keep-alive connection.
   reused_socket_ = connection_->is_reused();
   if (reused_socket_) {
     next_state_ = STATE_SEND_REQUEST;
   } else {
     // Now we have a TCP connected socket.  Perform other connection setup as
     // needed.
     UpdateConnectionTypeHistograms(CONNECTION_HTTP);
-    if (using_ssl_ && (proxy_mode_ == kDirectConnection ||
-                       proxy_mode_ == kSOCKSProxy)) {
+    if (using_ssl_ && (proxy_info_.is_direct() || proxy_info_.is_socks())) {
       next_state_ = STATE_SSL_CONNECT;
     } else {
       next_state_ = STATE_SEND_REQUEST;
-      if (proxy_mode_ == kHTTPProxyUsingTunnel)
+      if (using_ssl_)
         establishing_tunnel_ = true;
     }
   }
 
   return OK;
 }
 
 int HttpNetworkTransaction::DoSSLConnect() {
   next_state_ = STATE_SSL_CONNECT_COMPLETE;
 
@@ skipping 117 matching lines @@
     if (have_proxy_auth)
       AddAuthorizationHeader(HttpAuth::AUTH_PROXY, &authorization_headers);
     if (have_server_auth)
       AddAuthorizationHeader(HttpAuth::AUTH_SERVER, &authorization_headers);
 
     if (establishing_tunnel_) {
       BuildTunnelRequest(request_, authorization_headers, &request_line,
                          &request_headers);
     } else {
       BuildRequestHeaders(request_, authorization_headers, request_body,
-                          proxy_mode_ == kHTTPProxy, &request_line,
+                          !using_ssl_ && proxy_info_.is_http(), &request_line,
                           &request_headers);
     }
 
     request_headers_ = request_line + request_headers.ToString();
   }
 
   headers_valid_ = false;
   http_stream_.reset(new HttpBasicStream(connection_.get(), net_log_));
 
   return http_stream_->SendRequest(request_, request_headers_,
@@ skipping 686 matching lines @@
     // there was nothing left to fall-back to, so fail the transaction
     // with the last connection error we got.
     // TODO(eroman): This is a confusing contract, make it more obvious.
     rv = error;
   }
 
   return rv;
 }
 
 bool HttpNetworkTransaction::ShouldApplyProxyAuth() const {
-  return (proxy_mode_ == kHTTPProxy) || establishing_tunnel_;
+  return (!using_ssl_ && proxy_info_.is_http()) || establishing_tunnel_;
 }
 
 bool HttpNetworkTransaction::ShouldApplyServerAuth() const {
   return !establishing_tunnel_ &&
       !(request_->load_flags & LOAD_DO_NOT_SEND_AUTH_DATA);
 }
 
 void HttpNetworkTransaction::AddAuthorizationHeader(
     HttpAuth::Target target, HttpRequestHeaders* authorization_headers) const {
   DCHECK(HaveAuth(target));
@@ skipping 301 matching lines @@
       http_host_port_pair);
 
   alternate_protocol_mode_ = kDoNotUseAlternateProtocol;
   if (connection_->socket())
     connection_->socket()->Disconnect();
   connection_->Reset();
   next_state_ = STATE_INIT_CONNECTION;
 }
 
 }  // namespace net