Plumbing for TCP FastOpen for SSL sockets.

net/socket/tcp_socket.cc

Index: net/socket/tcp_socket.cc
diff --git a/net/socket/tcp_socket.cc b/net/socket/tcp_socket.cc
index 864159750a8d2c700af63ff7692633dac7e50453..8090265935e7547af839bb387681d4b2b7ecba93 100644
--- a/net/socket/tcp_socket.cc
+++ b/net/socket/tcp_socket.cc
@@ -8,72 +8,67 @@
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
+#include "base/task_runner_util.h"
 #include "base/threading/worker_pool.h"
 
 namespace net {
 
 namespace {
 
+// True if OS supports TCP FastOpen.
+bool g_tcp_fastopen_supported = false;
+// True if OS supports TCP FastOpen and is turned on for all connections.
 bool g_tcp_fastopen_enabled = false;
 
 #if defined(OS_LINUX) || defined(OS_ANDROID)
 
-typedef base::RefCountedData<bool> SharedBoolean;
+  // typedef base::RefCountedData<bool> SharedBoolean;
 
-// Checks to see if the system supports TCP FastOpen. Notably, it requires
-// kernel support. Additionally, this checks system configuration to ensure that
-// it's enabled.
-void SystemSupportsTCPFastOpen(scoped_refptr<SharedBoolean> supported) {
-  supported->data = false;
+// Checks if the kernel supports TCP FastOpen.
+bool SystemSupportsTCPFastOpen() {
   static const base::FilePath::CharType kTCPFastOpenProcFilePath[] =
       "/proc/sys/net/ipv4/tcp_fastopen";
-  std::string system_enabled_tcp_fastopen;
+  std::string system_supports_tcp_fastopen;
   if (!base::ReadFileToString(base::FilePath(kTCPFastOpenProcFilePath),
-                              &system_enabled_tcp_fastopen)) {
-    return;
+                              &system_supports_tcp_fastopen)) {
+    return false;
   }
-
-  // As per http://lxr.linux.no/linux+v3.7.7/include/net/tcp.h#L225
-  // TFO_CLIENT_ENABLE is the LSB
-  if (system_enabled_tcp_fastopen.empty() ||
-      (system_enabled_tcp_fastopen[0] & 0x1) == 0) {
-    return;
+  // The read from /proc should return '1' if TCP FastOpen is enabled in the OS.
+  if (system_supports_tcp_fastopen.empty() ||
+      (system_supports_tcp_fastopen[0] != '1')) {
+    return false;
   }
-
-  supported->data = true;
-}
-
-void EnableCallback(scoped_refptr<SharedBoolean> supported) {
-  g_tcp_fastopen_enabled = supported->data;
+  return true;
 }
 
-// This is asynchronous because it needs to do file IO, and it isn't allowed to
-// do that on the IO thread.
-void EnableFastOpenIfSupported() {
-  scoped_refptr<SharedBoolean> supported = new SharedBoolean;
-  base::WorkerPool::PostTaskAndReply(
-      FROM_HERE,
-      base::Bind(SystemSupportsTCPFastOpen, supported),
-      base::Bind(EnableCallback, supported),
-      false);
+void CallbackForTCPFastOpenCheck(bool user_enabled,
+                                 bool system_supported) {
+  g_tcp_fastopen_supported = system_supported;
+  if (user_enabled) {
+    g_tcp_fastopen_enabled = system_supported;
+  }
 }
 
 #else
 
-void EnableFastOpenIfSupported() {
-  g_tcp_fastopen_enabled = false;
-}
+void CheckSupportAndMaybeEnableTCPFastOpen(bool user_enabled) {}
 
 #endif
 
 }  // namespace
 
-void SetTCPFastOpenEnabled(bool value) {
-  if (value) {
-    EnableFastOpenIfSupported();
-  } else {
-    g_tcp_fastopen_enabled = false;
-  }
+// This is asynchronous because it needs to do file IO, and it isn't allowed to
+// do that on the IO thread.
+void CheckSupportAndMaybeEnableTCPFastOpen(bool user_enabled) {
+  base::PostTaskAndReplyWithResult(
+      base::WorkerPool::GetTaskRunner(/*task_is_slow=*/false),
+      FROM_HERE,
+      base::Bind(SystemSupportsTCPFastOpen),
+      base::Bind(CallbackForTCPFastOpenCheck, user_enabled));
+}
+
+bool IsTCPFastOpenSupported() {
+  return g_tcp_fastopen_supported;
 }
 
 bool IsTCPFastOpenEnabled() {