Plumbing for TCP FastOpen for SSL sockets.

net/socket/transport_client_socket_pool.h

Index: net/socket/transport_client_socket_pool.h
diff --git a/net/socket/transport_client_socket_pool.h b/net/socket/transport_client_socket_pool.h
index 003008a372ddfa1a20f4b566a583ed545b3e5f5d..8722dc52e34e89ced996c4648b299b30d137791c 100644
--- a/net/socket/transport_client_socket_pool.h
+++ b/net/socket/transport_client_socket_pool.h
@@ -21,6 +21,15 @@
 
 namespace net {
 
+// Auto-connect currently translates to using TCP Fast Open.
+// NOTE: For TCP Fast Open, enable if the write is known to be idempotent,
+// and if a write on the socket is guaranteed to happen before any reads.

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

Think the NOTE isn't really clear.  How about:

This translates into using TCP Fast Open.  Fast open should not be used in the
case the first write to the socket may be non-idempotent, as it could result in
sending the data twice on failure.  NOTE:  Currently, ENABLED is used if the
request is idempotent, and USE_DEFAULT is used for mother other cases (Including
non-idempotent requests).

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

I've slightly modified it from your suggestion, PTAL.

+enum AutoConnectWithWritePolicy {
+  AUTO_CONNECT_USE_DEFAULT,
+  AUTO_CONNECT_ENABLED,
+  AUTO_CONNECT_DISABLED

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

So I talked to Randy - he remains a bit concerned, since these are set on
"TransportSocketParams" rather than something like "TCPSocketParams".  Though
that's effectively what they are, the naming abstracts that out...kinda.  He
said he'd defer to me, though.

My thinking is that AUTO_CONNECT is confusing.  Calling this
FIRST_WRITE_IS_IDEMPOTENT would make sense...except that then having a "DEFAULT"
value makes little sense.

Maybe call them:

COMBINE_CONNECT_AND_WRITE_ALLOWED,
COMBINE_CONNECT_AND_WRITE_IF_SUPPORTED,
COMBINE_CONNECT_AND_WRITE_PROHIBITED,

I think that's much more accurate, though still doesn't really clear that
idempotence matters (Not that calling them TCP_FAST_OPEN_* really makes that
clear, either).

[Adam Rice, 2014/09/10 05:39:27]

At the moment "TransportSocket" always means TCP/IP in net/. Has this ever not
been the case?

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

I'm fine with using this... I still think of it as auto-connect, since that is
basically what TFO does from a client API point of view. I am using DEFAULT and
DESIRED instead of ALLOWED and IF_SUPPORTED, since it's really not clear how
ALLOWED and IF_SUPPORTED are different (IF_SUPPORTED seems like a subset of
ALLOWED). I've also moved it to be inside TransportSocketParams. PTAL. 

I understand the concern, and I understand the desire for clarity ... perhaps we
*should* change this to TCPSocketParams? That would make things a lot simpler.
That would be a different CL though.

+};
+
 class ClientSocketFactory;
 
 typedef base::Callback<int(const AddressList&, const BoundNetLog& net_log)>
@@ -38,12 +47,24 @@ class NET_EXPORT_PRIVATE TransportSocketParams
       bool ignore_limits,
       const OnHostResolutionCallback& host_resolution_callback);

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

Can you get rid of this?  Looks like you've updated most callsites in net/?  If
not, that's fine, but should eventually aim to get rid of it.

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

Ah -- oversight. Done. I had already combined the constructors in the .cc file,
forgot to remove it here.

 
+  // Same as above with one additional boolean to enable use of TCP FastOpen.
+  TransportSocketParams(
+      const HostPortPair& host_port_pair,
+      bool disable_resolver_cache,
+      bool ignore_limits,
+      const OnHostResolutionCallback& host_resolution_callback,
+      AutoConnectWithWritePolicy auto_connect_with_write_if_supported);
+
   const HostResolver::RequestInfo& destination() const { return destination_; }
   bool ignore_limits() const { return ignore_limits_; }
   const OnHostResolutionCallback& host_resolution_callback() const {
     return host_resolution_callback_;
   }
 
+  AutoConnectWithWritePolicy auto_connect_with_write() const {
+    return auto_connect_with_write_;
+  }
+
  private:
   friend class base::RefCounted<TransportSocketParams>;
   ~TransportSocketParams();
@@ -51,6 +72,7 @@ class NET_EXPORT_PRIVATE TransportSocketParams
   HostResolver::RequestInfo destination_;
   bool ignore_limits_;
   const OnHostResolutionCallback host_resolution_callback_;
+  AutoConnectWithWritePolicy auto_connect_with_write_;
 
   DISALLOW_COPY_AND_ASSIGN(TransportSocketParams);
 };
@@ -90,6 +112,7 @@ class NET_EXPORT_PRIVATE TransportConnectJobHelper {
   State next_state() const { return next_state_; }
   void set_next_state(State next_state) { next_state_ = next_state; }
   CompletionCallback on_io_complete() const { return on_io_complete_; }
+  const TransportSocketParams* params() { return params_.get(); }
 
   int DoResolveHost(RequestPriority priority, const BoundNetLog& net_log);
   int DoResolveHostComplete(int result, const BoundNetLog& net_log);