Revert "Revert "Revert "Add connected socket function to ClientSocketPool and ClientSocketHandle."""

net/http/http_network_transaction.cc

 // Copyright (c) 2006-2008 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/scoped_ptr.h"
 #include "base/compiler_specific.h"
 #include "base/field_trial.h"
 #include "base/string_util.h"
@@ skipping 164 matching lines @@
   if (rv == ERR_IO_PENDING)
     user_callback_ = callback;
   return rv;
 }
 
 int HttpNetworkTransaction::RestartIgnoringLastError(
     CompletionCallback* callback) {
   if (connection_.socket()->IsConnected()) {
     next_state_ = STATE_WRITE_HEADERS;
   } else {
-    connection_.socket()->Disconnect();
+    connection_.set_socket(NULL);
     connection_.Reset();
     next_state_ = STATE_INIT_CONNECTION;
   }
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
     user_callback_ = callback;
   return rv;
 }
 
 int HttpNetworkTransaction::RestartWithAuth(
@@ skipping 103 matching lines @@
   // the response body.
   DidDrainBodyForAuthRestart(keep_alive);
 }
 
 void HttpNetworkTransaction::DidDrainBodyForAuthRestart(bool keep_alive) {
   if (keep_alive) {
     next_state_ = STATE_WRITE_HEADERS;
     reused_socket_ = true;
   } else {
     next_state_ = STATE_INIT_CONNECTION;
-    connection_.socket()->Disconnect();
+    connection_.set_socket(NULL);
     connection_.Reset();
   }
 
   // Reset the other member variables.
   ResetStateForRestart();
 }
 
 int HttpNetworkTransaction::Read(IOBuffer* buf, int buf_len,
                                  CompletionCallback* callback) {
   DCHECK(response_.headers);
@@ skipping 29 matching lines @@
 const HttpResponseInfo* HttpNetworkTransaction::GetResponseInfo() const {
   return (response_.headers || response_.ssl_info.cert) ? &response_ : NULL;
 }
 
 LoadState HttpNetworkTransaction::GetLoadState() const {
   // TODO(wtc): Define a new LoadState value for the
   // STATE_INIT_CONNECTION_COMPLETE state, which delays the HTTP request.
   switch (next_state_) {
     case STATE_RESOLVE_PROXY_COMPLETE:
       return LOAD_STATE_RESOLVING_PROXY_FOR_URL;
-    case STATE_INIT_CONNECTION_COMPLETE:
-      return connection_.GetLoadState();
+    case STATE_RESOLVE_HOST_COMPLETE:
+      return LOAD_STATE_RESOLVING_HOST;
+    case STATE_TCP_CONNECT_COMPLETE:
+      return LOAD_STATE_CONNECTING;
     case STATE_WRITE_HEADERS_COMPLETE:
     case STATE_WRITE_BODY_COMPLETE:
       return LOAD_STATE_SENDING_REQUEST;
     case STATE_READ_HEADERS_COMPLETE:
       return LOAD_STATE_WAITING_FOR_RESPONSE;
     case STATE_READ_BODY_COMPLETE:
       return LOAD_STATE_READING_RESPONSE;
     default:
       return LOAD_STATE_IDLE;
   }
 }
 
 uint64 HttpNetworkTransaction::GetUploadProgress() const {
   if (!request_body_stream_.get())
     return 0;
 
   return request_body_stream_->position();
 }
 
 HttpNetworkTransaction::~HttpNetworkTransaction() {
-  // If we still have an open socket, then make sure to disconnect it so we
-  // don't try to reuse it later on.
+  // If we still have an open socket, then make sure to close it so we don't
+  // try to reuse it later on.
   if (connection_.is_initialized())
-    connection_.socket()->Disconnect();
+    connection_.set_socket(NULL);
 
   if (pac_request_)
     session_->proxy_service()->CancelPacRequest(pac_request_);
 }
 
 void HttpNetworkTransaction::DoCallback(int rv) {
   DCHECK(rv != ERR_IO_PENDING);
   DCHECK(user_callback_);
 
   // Since Run may result in Read being called, clear user_callback_ up front.
@@ skipping 27 matching lines @@
         break;
       case STATE_INIT_CONNECTION:
         DCHECK_EQ(OK, rv);
         TRACE_EVENT_BEGIN("http.init_conn", request_, request_->url.spec());
         rv = DoInitConnection();
         break;
       case STATE_INIT_CONNECTION_COMPLETE:
         rv = DoInitConnectionComplete(rv);
         TRACE_EVENT_END("http.init_conn", request_, request_->url.spec());
         break;
+      case STATE_RESOLVE_HOST:
+        DCHECK_EQ(OK, rv);
+        TRACE_EVENT_BEGIN("http.resolve_host", request_, request_->url.spec());
+        rv = DoResolveHost();
+        break;
+      case STATE_RESOLVE_HOST_COMPLETE:
+        rv = DoResolveHostComplete(rv);
+        TRACE_EVENT_END("http.resolve_host", request_, request_->url.spec());
+        break;
+      case STATE_TCP_CONNECT:
+        DCHECK_EQ(OK, rv);
+        TRACE_EVENT_BEGIN("http.connect", request_, request_->url.spec());
+        rv = DoTCPConnect();
+        break;
+      case STATE_TCP_CONNECT_COMPLETE:
+        rv = DoTCPConnectComplete(rv);
+        TRACE_EVENT_END("http.connect", request_, request_->url.spec());
+        break;
       case STATE_SSL_CONNECT:
         DCHECK_EQ(OK, rv);
         TRACE_EVENT_BEGIN("http.ssl_connect", request_, request_->url.spec());
         rv = DoSSLConnect();
         break;
       case STATE_SSL_CONNECT_COMPLETE:
         rv = DoSSLConnectComplete(rv);
         TRACE_EVENT_END("http.ssl_connect", request_, request_->url.spec());
         break;
       case STATE_WRITE_HEADERS:
@@ skipping 89 matching lines @@
   DCHECK(!connection_.is_initialized());
 
   next_state_ = STATE_INIT_CONNECTION_COMPLETE;
 
   using_ssl_ = request_->url.SchemeIs("https");
   using_proxy_ = !proxy_info_.is_direct() && !using_ssl_;
   using_tunnel_ = !proxy_info_.is_direct() && using_ssl_;
 
   // Build the string used to uniquely identify connections of this type.
   std::string connection_group;
-  std::string host;
-  int port;
-  if (using_proxy_ || using_tunnel_) {
-    ProxyServer proxy_server = proxy_info_.proxy_server();
-    connection_group = "proxy/" + proxy_server.ToURI() + "/";
-    host = proxy_server.HostNoBrackets();
-    port = proxy_server.port();
-  } else {
-    host = request_->url.HostNoBrackets();
-    port = request_->url.EffectiveIntPort();
-  }
+  if (using_proxy_ || using_tunnel_)
+    connection_group = "proxy/" + proxy_info_.proxy_server().ToURI() + "/";
   if (!using_proxy_)
     connection_group.append(request_->url.GetOrigin().spec());
 
   DCHECK(!connection_group.empty());
-  int rv = connection_.Init(connection_group, host, port, request_->priority,
-                            &io_callback_);
-  return rv;
+  return connection_.Init(connection_group, request_->priority, &io_callback_);
 }
 
 int HttpNetworkTransaction::DoInitConnectionComplete(int result) {
   if (result < 0)
-    return ReconsiderProxyAfterError(result);
+    return result;
 
   DCHECK(connection_.is_initialized());
 
   // 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();
+  reused_socket_ = (connection_.socket() != NULL);
   if (reused_socket_) {
     next_state_ = STATE_WRITE_HEADERS;
   } else {
-    // Now we have a TCP connected socket.  Perform other connection setup as
-    // needed.
+    next_state_ = STATE_RESOLVE_HOST;
+  }
+  return OK;
+}
+
+int HttpNetworkTransaction::DoResolveHost() {
+  next_state_ = STATE_RESOLVE_HOST_COMPLETE;
+
+  std::string host;
+  int port;
+
+  // Determine the host and port to connect to.
+  if (using_proxy_ || using_tunnel_) {
+    ProxyServer proxy_server = proxy_info_.proxy_server();
+    host = proxy_server.HostNoBrackets();
+    port = proxy_server.port();
+  } else {
+    // Direct connection
+    host = request_->url.HostNoBrackets();
+    port = request_->url.EffectiveIntPort();
+  }
+
+  host_resolution_start_time_ = base::Time::Now();
+
+  DidStartDnsResolution(host, this);
+  return resolver_.Resolve(host, port, &addresses_, &io_callback_);
+}
+
+int HttpNetworkTransaction::DoResolveHostComplete(int result) {
+  bool ok = (result == OK);
+  DidFinishDnsResolutionWithStatus(ok, request_->referrer, this);
+  if (ok) {
+    next_state_ = STATE_TCP_CONNECT;
+  } else {
+    result = ReconsiderProxyAfterError(result);
+  }
+  return result;
+}
+
+int HttpNetworkTransaction::DoTCPConnect() {
+  next_state_ = STATE_TCP_CONNECT_COMPLETE;
+
+  DCHECK(!connection_.socket());
+
+  connect_start_time_ = base::Time::Now();
+
+  ClientSocket* s = socket_factory_->CreateTCPClientSocket(addresses_);
+  connection_.set_socket(s);
+  return connection_.socket()->Connect(&io_callback_);
+}
+
+int HttpNetworkTransaction::DoTCPConnectComplete(int result) {
+  // If we are using a direct SSL connection, then go ahead and establish the
+  // SSL connection, now.  Otherwise, we need to first issue a CONNECT request.
+  if (result == OK) {
     LogTCPConnectedMetrics();
     if (using_ssl_ && !using_tunnel_) {
       next_state_ = STATE_SSL_CONNECT;
     } else {
       next_state_ = STATE_WRITE_HEADERS;
       if (using_tunnel_)
         establishing_tunnel_ = true;
     }
+  } else {
+    result = ReconsiderProxyAfterError(result);
   }
-  return OK;
+  return result;
 }
 
 int HttpNetworkTransaction::DoSSLConnect() {
   next_state_ = STATE_SSL_CONNECT_COMPLETE;
 
   // Add a SSL socket on top of our existing transport socket.
   ClientSocket* s = connection_.release_socket();
   s = socket_factory_->CreateSSLClientSocket(
       s, request_->url.HostNoBrackets(), ssl_config_);
   connection_.set_socket(s);
@@ skipping 280 matching lines @@
           (response_body_length_ != -1 &&
            response_body_read_ > response_body_length_))
         keep_alive = false;
     }
   }
 
   // Clean up connection_ if we are done.
   if (done) {
     LogTransactionMetrics();
     if (!keep_alive)
-      connection_.socket()->Disconnect();
+      connection_.set_socket(NULL);
     connection_.Reset();
     // The next Read call will return 0 (EOF).
   }
 
   // Clear these to avoid leaving around old state.
   read_buf_ = NULL;
   read_buf_len_ = 0;
 
   return result;
 }
@@ skipping 51 matching lines @@
     DidDrainBodyForAuthRestart(keep_alive);
   } else {
     // Keep draining.
     next_state_ = STATE_DRAIN_BODY_FOR_AUTH_RESTART;
   }
 
   return OK;
 }
 
 void HttpNetworkTransaction::LogTCPConnectedMetrics() const {
+  DCHECK(connect_start_time_ != base::Time());
+  base::TimeDelta connect_duration =
+      base::Time::Now() - connect_start_time_;
+
+  UMA_HISTOGRAM_CLIPPED_TIMES(FieldTrial::MakeName(
+      "Net.TCP_Connection_Latency", "DnsImpact").data(), connect_duration,
+      base::TimeDelta::FromMilliseconds(1), base::TimeDelta::FromMinutes(10),
+      100);
+
   base::TimeDelta host_resolution_and_tcp_connection_latency =
       base::Time::Now() - host_resolution_start_time_;
 
   UMA_HISTOGRAM_CLIPPED_TIMES(
       FieldTrial::MakeName(
           "Net.Dns_Resolution_And_TCP_Connection_Latency", "DnsImpact").data(),
       host_resolution_and_tcp_connection_latency,
       base::TimeDelta::FromMilliseconds(1), base::TimeDelta::FromMinutes(10),
       100);
 
@@ skipping 252 matching lines @@
 }
 
 int HttpNetworkTransaction::HandleSSLHandshakeError(int error) {
   switch (error) {
     case ERR_SSL_PROTOCOL_ERROR:
     case ERR_SSL_VERSION_OR_CIPHER_MISMATCH:
       if (ssl_config_.tls1_enabled) {
         // This could be a TLS-intolerant server or an SSL 3.0 server that
         // chose a TLS-only cipher suite.  Turn off TLS 1.0 and retry.
         ssl_config_.tls1_enabled = false;
-        connection_.socket()->Disconnect();
+        connection_.set_socket(NULL);
         connection_.Reset();
         next_state_ = STATE_INIT_CONNECTION;
         error = OK;
       }
       break;
   }
   return error;
 }
 
 // This method determines whether it is safe to resend the request after an
@@ skipping 42 matching lines @@
   // out of the cached keep-alive connections eventually.
   if (establishing_tunnel_ ||
       !reused_socket_ ||  // We didn't reuse a keep-alive connection.
       header_buf_len_) {  // We have received some response headers.
     return false;
   }
   return true;
 }
 
 void HttpNetworkTransaction::ResetConnectionAndRequestForResend() {
-  connection_.socket()->Disconnect();
+  connection_.set_socket(NULL);
   connection_.Reset();
   // There are two reasons we need to clear request_headers_.  1) It contains
   // the real request headers, but we may need to resend the CONNECT request
   // first to recreate the SSL tunnel.  2) An empty request_headers_ causes
   // BuildRequestHeaders to be called, which rewinds request_body_stream_ to
   // the beginning of request_->upload_data.
   request_headers_->headers_.clear();
   request_headers_bytes_sent_ = 0;
   next_state_ = STATE_INIT_CONNECTION;  // Resend the request.
 }
@@ skipping 24 matching lines @@
       return error;
   }
 
   if (request_->load_flags & LOAD_BYPASS_PROXY) {
     return error;
   }
 
   int rv = session_->proxy_service()->ReconsiderProxyAfterError(
       request_->url, &proxy_info_, &io_callback_, &pac_request_);
   if (rv == OK || rv == ERR_IO_PENDING) {
-    connection_.socket()->Disconnect();
+    connection_.set_socket(NULL);
     connection_.Reset();
     DCHECK(!request_headers_bytes_sent_);
     next_state_ = STATE_RESOLVE_PROXY_COMPLETE;
   } else {
     rv = error;
   }
 
   return rv;
 }
 
@@ skipping 259 matching lines @@
   if (target == HttpAuth::AUTH_PROXY) {
     auth_info->host = ASCIIToWide(proxy_info_.proxy_server().host_and_port());
   } else {
     DCHECK(target == HttpAuth::AUTH_SERVER);
     auth_info->host = ASCIIToWide(request_->url.host());
   }
   response_.auth_challenge = auth_info;
 }
 
 }  // namespace net