Plumbing for TCP FastOpen for SSL sockets.

net/socket/transport_client_socket_pool.h

 // 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.
 
 #ifndef NET_SOCKET_TRANSPORT_CLIENT_SOCKET_POOL_H_
 #define NET_SOCKET_TRANSPORT_CLIENT_SOCKET_POOL_H_
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "net/base/host_port_pair.h"
 #include "net/dns/host_resolver.h"
 #include "net/dns/single_request_host_resolver.h"
 #include "net/socket/client_socket_pool.h"
 #include "net/socket/client_socket_pool_base.h"
 #include "net/socket/client_socket_pool_histograms.h"
 
 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)>
 OnHostResolutionCallback;
 
 class NET_EXPORT_PRIVATE TransportSocketParams
     : public base::RefCounted<TransportSocketParams> {
  public:
   // |host_resolution_callback| will be invoked after the the hostname is
   // resolved.  If |host_resolution_callback| does not return OK, then the
   // connection will be aborted with that value.
   TransportSocketParams(
       const HostPortPair& host_port_pair,
       bool disable_resolver_cache,
       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();
 
   HostResolver::RequestInfo destination_;
   bool ignore_limits_;
   const OnHostResolutionCallback host_resolution_callback_;
+  AutoConnectWithWritePolicy auto_connect_with_write_;
 
   DISALLOW_COPY_AND_ASSIGN(TransportSocketParams);
 };
 
 // Common data and logic shared between TransportConnectJob and
 // WebSocketTransportConnectJob.
 class NET_EXPORT_PRIVATE TransportConnectJobHelper {
  public:
   enum State {
     STATE_RESOLVE_HOST,
@@ skipping 19 matching lines @@
   ~TransportConnectJobHelper();
 
   ClientSocketFactory* client_socket_factory() {
     return client_socket_factory_;
   }
 
   const AddressList& addresses() const { return addresses_; }
   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);
 
   template <class T>
   int DoConnectInternal(T* job);
 
   template <class T>
   void SetOnIOComplete(T* job);
 
@@ skipping 230 matching lines @@
         break;
     }
   } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);
 
   return rv;
 }
 
 }  // namespace net
 
 #endif  // NET_SOCKET_TRANSPORT_CLIENT_SOCKET_POOL_H_