Plumbing for TCP FastOpen for SSL sockets.

net/socket/transport_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/socket/transport_client_socket_pool.h"
 
 #include <algorithm>
 
 #include "base/compiler_specific.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "base/synchronization/lock.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/client_socket_pool_base.h"
 #include "net/socket/socket_net_log_params.h"
 #include "net/socket/tcp_client_socket.h"
 
 using base::TimeDelta;
+extern bool g_tcp_fastopen_user_enabled;
+extern bool g_tcp_fastopen_supported;
 
 namespace net {
 
 // TODO(willchan): Base this off RTT instead of statically setting it. Note we
 // choose a timeout that is different from the backup connect job timer so they
 // don't synchronize.
 const int TransportConnectJobHelper::kIPv6FallbackTimerInMs = 300;
 
 namespace {
 
@@ skipping 15 matching lines @@
     g_last_connect_time_lock = LAZY_INSTANCE_INITIALIZER;
 
 // |g_last_connect_time| has the last time a connect() call is made.
 static base::LazyInstance<base::TimeTicks>::Leaky
     g_last_connect_time = LAZY_INSTANCE_INITIALIZER;
 
 TransportSocketParams::TransportSocketParams(
     const HostPortPair& host_port_pair,
     bool disable_resolver_cache,
     bool ignore_limits,
-    const OnHostResolutionCallback& host_resolution_callback)
+    const OnHostResolutionCallback& host_resolution_callback,
+    CombineConnectAndWritePolicy combine_connect_and_write_if_supported)
     : destination_(host_port_pair),
       ignore_limits_(ignore_limits),
-      host_resolution_callback_(host_resolution_callback) {
+      host_resolution_callback_(host_resolution_callback),
+      combine_connect_and_write_(combine_connect_and_write_if_supported) {
   if (disable_resolver_cache)
     destination_.set_allow_cached_response(false);
+  // combine_connect_and_write currently translates to TCP FastOpen.
+  // Enable TCP FastOpen if user wants it and system supports it.
+  if (!g_tcp_fastopen_supported) {
+    combine_connect_and_write_ = COMBINE_CONNECT_AND_WRITE_PROHIBITED;
+  } else {
+    if (g_tcp_fastopen_user_enabled &&
+        combine_connect_and_write_ == COMBINE_CONNECT_AND_WRITE_DEFAULT) {
+      combine_connect_and_write_ = COMBINE_CONNECT_AND_WRITE_DESIRED;
+    }
+  }
 }
 
 TransportSocketParams::~TransportSocketParams() {}
 
 // TransportConnectJobs will time out after this many seconds.  Note this is
 // the total time, including both host resolution and TCP connect() times.
 //
 // TODO(eroman): The use of this constant needs to be re-evaluated. The time
 // needed for TCPClientSocketXXX::Connect() can be arbitrarily long, since
 // the address list may contain many alternatives, and most of those may
@@ skipping 175 matching lines @@
       interval_between_connects_ = CONNECT_INTERVAL_LE_20MS;
     else
       interval_between_connects_ = CONNECT_INTERVAL_GT_20MS;
   }
 
   helper_.set_next_state(
       TransportConnectJobHelper::STATE_TRANSPORT_CONNECT_COMPLETE);
   transport_socket_ =
       helper_.client_socket_factory()->CreateTransportClientSocket(
           helper_.addresses(), net_log().net_log(), net_log().source());
+
+  // If the list contains IPv6 and IPv4 addresses, the first address will
+  // be IPv6, and the IPv4 addresses will be tried as fallback addresses,
+  // per "Happy Eyeballs" (RFC 6555).
+  bool try_ipv6_connect_with_ipv4_fallback =
+      helper_.addresses().front().GetFamily() == ADDRESS_FAMILY_IPV6 &&
+      !AddressListOnlyContainsIPv6(helper_.addresses());
+
+  // Enable TCP FastOpen if indicated by transport socket params.
+  // Note: We currently do not turn on TCP FastOpen for destinations where
+  // we try a TCP connect over IPv6 with fallback to IPv4.
+  if (!try_ipv6_connect_with_ipv4_fallback &&
+      helper_.params()->combine_connect_and_write() ==
+          TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DESIRED) {
+    transport_socket_->EnableTCPFastOpen();
+  }
+
   int rv = transport_socket_->Connect(helper_.on_io_complete());
-  if (rv == ERR_IO_PENDING &&
-      helper_.addresses().front().GetFamily() == ADDRESS_FAMILY_IPV6 &&
-      !AddressListOnlyContainsIPv6(helper_.addresses())) {
+  if (rv == ERR_IO_PENDING && try_ipv6_connect_with_ipv4_fallback) {
     fallback_timer_.Start(
         FROM_HERE,
         base::TimeDelta::FromMilliseconds(
             TransportConnectJobHelper::kIPv6FallbackTimerInMs),
         this,
         &TransportConnectJob::DoIPv6FallbackTransportConnect);
   }
   return rv;
 }
 
@@ skipping 257 matching lines @@
     HigherLayeredPool* higher_pool) {
   base_.AddHigherLayeredPool(higher_pool);
 }
 
 void TransportClientSocketPool::RemoveHigherLayeredPool(
     HigherLayeredPool* higher_pool) {
   base_.RemoveHigherLayeredPool(higher_pool);
 }
 
 }  // namespace net