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,
+    AutoConnectWithWritePolicy auto_connect_with_write_if_supported)
     : destination_(host_port_pair),
       ignore_limits_(ignore_limits),
-      host_resolution_callback_(host_resolution_callback) {
+      host_resolution_callback_(host_resolution_callback),
+      auto_connect_with_write_(auto_connect_with_write_if_supported) {
   if (disable_resolver_cache)
     destination_.set_allow_cached_response(false);
+  // Auto-connect currently translates to only TCP Fast Open.
+  // Enable TCP FastOpen if user wants it and system supports it.
+  if (!g_tcp_fastopen_supported)
+    auto_connect_with_write_ = AUTO_CONNECT_DISABLED;
+  else

[mmenke, 2014/09/09 14:29:28]

Use braces for both cases of an if/else statement when any one of the blocks
takes up more than one line.

[Jana, 2014/09/10 16:03:11]

Done.

+    if (g_tcp_fastopen_user_enabled &&
+        auto_connect_with_write_ == AUTO_CONNECT_USE_DEFAULT)
+      auto_connect_with_write_ = AUTO_CONNECT_ENABLED;

[mmenke, 2014/09/09 14:29:28]

Use braces for an if when the antecedent takes up more than one line.

[Jana, 2014/09/10 16:03:11]

Done.

 }
 
 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());
+
+  // Enable TCP FastOpen if indicated by transport socket params.
+  // Note: We currently do not turn on TCP FastOpen for destinations where
+  // we might try a TCP connect over IPv6 with fallback to IPv4.
+  if (helper_.params()->auto_connect_with_write() == AUTO_CONNECT_ENABLED &&
+      (helper_.addresses().front().GetFamily() != ADDRESS_FAMILY_IPV6 ||
+       AddressListOnlyContainsIPv6(helper_.addresses())))

[mmenke, 2014/09/09 14:29:28]

optional:  Think this is a little clearer if the last line is indented 4 spaces
instead of 1.

[mmenke, 2014/09/09 16:03:33]

Should we have any tests for this?  Not sure how hard they'd be to manage...Just
use mock sockets, and check that fast open was/wasn't set?

[mmenke, 2014/09/09 16:03:33]

optional:  Or may be clearer as a function in an anonymous namespace: 
AddressListContainsIPv6AndIPv4 or something.  Up to you.  It's not a complicated
check, but think removing it reduces complexity when reading the code.

[Jana, 2014/09/10 16:03:11]

Acknowledged.

[Jana, 2014/09/10 16:03:11]

Do you have a pointer for a test that currently tests happy eyeballs? One
difficulty is that currently setting fast open on a socket requires the system
to support it (this is the /proc file read for checking if the system supports
fast open.) 

[mmenke, 2014/09/10 17:32:22]

Yea, we'd need to force the tests to think they had (Or did not have) happy
eyeballs support.

TransportClientSocketPoolTest.IPv6FallbackSocketIPv4FinishesFirst and the nearby
tests check happy eyeballs behavior.

[Jana, 2014/09/11 16:02:36]

Tests added in transport_client_socket_pool_unittest.cc, PTAL.

+    transport_socket_->EnableTCPFastOpen();

[mmenke, 2014/09/09 14:29:28]

use braces.

[Jana, 2014/09/10 16:03:11]

This code has changed, but what's the formatting logic for using braces here?
There is no body that is > 1 line. Is this because the previous expression (the
boolean expression) is > 1 line?

[mmenke, 2014/09/10 17:32:22]

It's because the antecedent of the if statement takes up more than one line -
basically, if anything takes up more than one line, use braces.  They're also
often, though not always, used on else/ifs, even if everything is a single line.

[Jana, 2014/09/11 16:02:36]

Acknowledged.

+
   int rv = transport_socket_->Connect(helper_.on_io_complete());
   if (rv == ERR_IO_PENDING &&
       helper_.addresses().front().GetFamily() == ADDRESS_FAMILY_IPV6 &&
       !AddressListOnlyContainsIPv6(helper_.addresses())) {
     fallback_timer_.Start(
         FROM_HERE,
         base::TimeDelta::FromMilliseconds(
             TransportConnectJobHelper::kIPv6FallbackTimerInMs),
         this,
         &TransportConnectJob::DoIPv6FallbackTransportConnect);
@@ skipping 261 matching lines @@
     HigherLayeredPool* higher_pool) {
   base_.AddHigherLayeredPool(higher_pool);
 }
 
 void TransportClientSocketPool::RemoveHigherLayeredPool(
     HigherLayeredPool* higher_pool) {
   base_.RemoveHigherLayeredPool(higher_pool);
 }
 
 }  // namespace net