Plumbing for TCP FastOpen field trial and enables it for SSL sockets.

net/socket/client_socket_pool_manager.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/client_socket_pool_manager.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 153 matching lines @@
             ignore_limits,
             resolution_callback,
             TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT));
 
     if (proxy_info.is_http() || proxy_info.is_https()) {
       std::string user_agent;
       request_extra_headers.GetHeader(HttpRequestHeaders::kUserAgent,
                                       &user_agent);
       scoped_refptr<SSLSocketParams> ssl_params;
       if (proxy_info.is_https()) {
-        // TODO (jri): Enable a finch trial to use
-        // COMBINE_CONNECT_AND_WRITE_DESIRED for SSL sockets.
-        proxy_tcp_params =
-            new TransportSocketParams(
-                *proxy_host_port,
-                disable_resolver_cache,
-                ignore_limits,
-                resolution_callback,
-                TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT);
+        // Combine connect and write for SSL sockets in TCP FastOpen
+        // field trial.
+        TransportSocketParams::CombineConnectAndWritePolicy
+            combine_connect_and_write =
+                session->params().enable_tcp_fast_open_for_ssl ?
+                    TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DESIRED :
+                    TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT;
+        proxy_tcp_params = new TransportSocketParams(*proxy_host_port,
+                                                     disable_resolver_cache,
+                                                     ignore_limits,
+                                                     resolution_callback,
+                                                     combine_connect_and_write);
         // Set ssl_params, and unset proxy_tcp_params
         ssl_params = new SSLSocketParams(proxy_tcp_params,
                                          NULL,
                                          NULL,
                                          *proxy_host_port.get(),
                                          ssl_config_for_proxy,
                                          PRIVACY_MODE_DISABLED,
                                          load_flags,
                                          force_spdy_over_ssl,
                                          want_spdy_over_npn);
@@ skipping 28 matching lines @@
 
   // Change group name if privacy mode is enabled.
   if (privacy_mode == PRIVACY_MODE_ENABLED)
     connection_group = "pm/" + connection_group;
 
   // Deal with SSL - which layers on top of any given proxy.
   if (using_ssl) {
     scoped_refptr<TransportSocketParams> ssl_tcp_params;
     if (proxy_info.is_direct()) {
       // Setup TCP params if non-proxied SSL connection.
-      // TODO (jri): Enable a finch trial to use
-      // COMBINE_CONNECT_AND_WRITE_DESIRED for SSL sockets.
-      ssl_tcp_params =
-          new TransportSocketParams(
-              origin_host_port,
-              disable_resolver_cache,
-              ignore_limits,
-              resolution_callback,
-              TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT);
+      // Combine connect and write for SSL sockets in TCP FastOpen field trial.
+      TransportSocketParams::CombineConnectAndWritePolicy
+          combine_connect_and_write =
+              session->params().enable_tcp_fast_open_for_ssl ?
+                  TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DESIRED :
+                  TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT;

[mmenke, 2014/09/10 18:29:08]

Optional:  You could move combine_connect_and_write to the top of this function,
and have:

TransportSocketParams::CombineConnectAndWritePolicy combine_connect_and_write =
TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT;
if (using_ssl || proxy_info.is_https())
  combine_connect_and_write =
TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DESIRED;

And use it for transport socket params everywhere.  That'd catch the SSL over
non-proxy SSL case, though I suppose connecting to a non-SSL proxy could
theoretically be non-idempotent...Anyways, fine as-is.

[Jana, 2014/09/11 20:04:59]

Since it's not a strong preference for you, I'll leave it as is. The decision is
local to the TransportSocketParams below, and it makes the code easier to read
and reason about, IMO.

+      ssl_tcp_params = new TransportSocketParams(origin_host_port,
+                                                 disable_resolver_cache,
+                                                 ignore_limits,
+                                                 resolution_callback,
+                                                 combine_connect_and_write);
     }
     scoped_refptr<SSLSocketParams> ssl_params =
         new SSLSocketParams(ssl_tcp_params,
                             socks_params,
                             http_proxy_params,
                             origin_host_port,
                             ssl_config_for_origin,
                             privacy_mode,
                             load_flags,
                             force_spdy_over_ssl,
@@ skipping 251 matching lines @@
     int num_preconnect_streams) {
   return InitSocketPoolHelper(
       request_url, request_extra_headers, request_load_flags, request_priority,
       session, proxy_info, force_spdy_over_ssl, want_spdy_over_npn,
       ssl_config_for_origin, ssl_config_for_proxy, false, privacy_mode, net_log,
       num_preconnect_streams, NULL, HttpNetworkSession::NORMAL_SOCKET_POOL,
       OnHostResolutionCallback(), CompletionCallback());
 }
 
 }  // namespace net