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"
@@ skipping 176 matching lines @@
     RequestPriority priority,
     const scoped_refptr<TransportSocketParams>& params,
     base::TimeDelta timeout_duration,
     ClientSocketFactory* client_socket_factory,
     HostResolver* host_resolver,
     Delegate* delegate,
     NetLog* net_log)
     : ConnectJob(group_name, timeout_duration, priority, delegate,
                  BoundNetLog::Make(net_log, NetLog::SOURCE_CONNECT_JOB)),
       helper_(params, client_socket_factory, host_resolver, &connect_timing_),
-      interval_between_connects_(CONNECT_INTERVAL_GT_20MS) {
+      interval_between_connects_(CONNECT_INTERVAL_GT_20MS),
+      group_name_(group_name) {
   helper_.SetOnIOComplete(this);
 }
 
 TransportConnectJob::~TransportConnectJob() {
   // We don't worry about cancelling the host resolution and TCP connect, since
   // ~SingleRequestHostResolver and ~StreamSocket will take care of it.
 }
 
 LoadState TransportConnectJob::GetLoadState() const {
   switch (helper_.next_state()) {
@@ skipping 46 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 SSL socket. (This is a quite a hackish
+  // approach, but using TFO requires a more substantial change in the
+  // socket create/connect path.)
+  // TODO (jri): Finch trial this.
+  if (group_name_.substr(0, 3) == "ssl") {

[mmenke, 2014/08/12 15:25:16]

This seems a really bad idea.  Looking at my connections now, I have a
connection to http://ssl.gstatic.com/, and a group (For another connection)
named pm/ssl/ssl.gstatic.com.  This classifies them both incorrectly.

I also think this should be finch trialed in this CL, so we have a shutoff,
particularly if we land this before branch.

[mmenke, 2014/08/12 15:36:44]

And just to elaborate a little, I don't think the transport client socket should
know or care if we're going to use SSL.  I suggest making use fastopen a
TransportSocketParam instead, and having the SSL code set it to true.

[Jana, 2014/08/13 07:33:40]

Acknowledged.

[Jana, 2014/08/13 07:33:40]

Changed to use TransportSocketParams, PTAL. (I've not done the Finch setup yet.)

+    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())) {
     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