Refactor tcp socket and unix domain socket.

net/socket/tcp_socket_libevent.cc

 // Copyright 2013 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/tcp_socket.h"
 
 #include <errno.h>
-#include <fcntl.h>
-#include <netdb.h>
-#include <netinet/in.h>
 #include <netinet/tcp.h>
 #include <sys/socket.h>
 
-#include "base/callback_helpers.h"
+#include "base/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/stats_counters.h"
 #include "base/posix/eintr_wrapper.h"
-#include "build/build_config.h"
 #include "net/base/address_list.h"
 #include "net/base/connection_type_histograms.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/base/network_change_notifier.h"
+#include "net/socket/socket_libevent.h"
 #include "net/socket/socket_net_log_params.h"
 
 // If we don't have a definition for TCPI_OPT_SYN_DATA, create one.
 #ifndef TCPI_OPT_SYN_DATA
 #define TCPI_OPT_SYN_DATA 32
 #endif
 
 namespace net {
 
 namespace {
@@ skipping 28 matching lines @@
   }
   // Set seconds between TCP keep alives.
   if (setsockopt(fd, SOL_TCP, TCP_KEEPINTVL, &delay, sizeof(delay))) {
     PLOG(ERROR) << "Failed to set TCP_KEEPINTVL on fd: " << fd;
     return false;
   }
 #endif
   return true;
 }
 
-int MapAcceptError(int os_error) {
-  switch (os_error) {
-    // If the client aborts the connection before the server calls accept,
-    // POSIX specifies accept should fail with ECONNABORTED. The server can
-    // ignore the error and just call accept again, so we map the error to
-    // ERR_IO_PENDING. See UNIX Network Programming, Vol. 1, 3rd Ed., Sec.
-    // 5.11, "Connection Abort before accept Returns".
-    case ECONNABORTED:
-      return ERR_IO_PENDING;
-    default:
-      return MapSystemError(os_error);
-  }
-}
-
-int MapConnectError(int os_error) {
-  switch (os_error) {
-    case EACCES:
-      return ERR_NETWORK_ACCESS_DENIED;
-    case ETIMEDOUT:
-      return ERR_CONNECTION_TIMED_OUT;
-    default: {
-      int net_error = MapSystemError(os_error);
-      if (net_error == ERR_FAILED)
-        return ERR_CONNECTION_FAILED;  // More specific than ERR_FAILED.
-
-      // Give a more specific error when the user is offline.
-      if (net_error == ERR_ADDRESS_UNREACHABLE &&
-          NetworkChangeNotifier::IsOffline()) {
-        return ERR_INTERNET_DISCONNECTED;
-      }
-      return net_error;
-    }
-  }
-}
-
 }  // namespace
 
 //-----------------------------------------------------------------------------
 
-TCPSocketLibevent::Watcher::Watcher(
-    const base::Closure& read_ready_callback,
-    const base::Closure& write_ready_callback)
-    : read_ready_callback_(read_ready_callback),
-      write_ready_callback_(write_ready_callback) {
-}
-
-TCPSocketLibevent::Watcher::~Watcher() {
-}
-
-void TCPSocketLibevent::Watcher::OnFileCanReadWithoutBlocking(int /* fd */) {
-  if (!read_ready_callback_.is_null())
-    read_ready_callback_.Run();
-  else
-    NOTREACHED();
-}
-
-void TCPSocketLibevent::Watcher::OnFileCanWriteWithoutBlocking(int /* fd */) {
-  if (!write_ready_callback_.is_null())
-    write_ready_callback_.Run();
-  else
-    NOTREACHED();
-}
-
 TCPSocketLibevent::TCPSocketLibevent(NetLog* net_log,
                                      const NetLog::Source& source)
-    : socket_(kInvalidSocket),
-      accept_watcher_(base::Bind(&TCPSocketLibevent::DidCompleteAccept,
-                                 base::Unretained(this)),
-                      base::Closure()),
-      accept_socket_(NULL),
-      accept_address_(NULL),
-      read_watcher_(base::Bind(&TCPSocketLibevent::DidCompleteRead,
-                               base::Unretained(this)),
-                    base::Closure()),
-      write_watcher_(base::Closure(),
-                     base::Bind(&TCPSocketLibevent::DidCompleteConnectOrWrite,
-                                base::Unretained(this))),
-      read_buf_len_(0),
-      write_buf_len_(0),
-      use_tcp_fastopen_(IsTCPFastOpenEnabled()),
+    : use_tcp_fastopen_(IsTCPFastOpenEnabled()),
       tcp_fastopen_connected_(false),
       fast_open_status_(FAST_OPEN_STATUS_UNKNOWN),
-      waiting_connect_(false),
-      connect_os_error_(0),
       logging_multiple_connect_attempts_(false),
       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)) {
   net_log_.BeginEvent(NetLog::TYPE_SOCKET_ALIVE,
                       source.ToEventParametersCallback());
 }
 
 TCPSocketLibevent::~TCPSocketLibevent() {
   net_log_.EndEvent(NetLog::TYPE_SOCKET_ALIVE);
   if (tcp_fastopen_connected_) {
     UMA_HISTOGRAM_ENUMERATION("Net.TcpFastOpenSocketConnection",
                               fast_open_status_, FAST_OPEN_MAX_VALUE);
   }
-  Close();
 }
 
 int TCPSocketLibevent::Open(AddressFamily family) {
-  DCHECK(CalledOnValidThread());
-  DCHECK_EQ(socket_, kInvalidSocket);
+  DCHECK(!socket_);
+  socket_.reset(new SocketLibevent);
+  return socket_->Open(ConvertAddressFamily(family));
+}
 
-  socket_ = CreatePlatformSocket(ConvertAddressFamily(family), SOCK_STREAM,
-                                 IPPROTO_TCP);
-  if (socket_ < 0) {
-    PLOG(ERROR) << "CreatePlatformSocket() returned an error";
-    return MapSystemError(errno);
+int TCPSocketLibevent::AdoptConnectedSocket(int socket_fd,
+                                            const IPEndPoint& peer_address) {
+  DCHECK(!socket_);
+
+  SockaddrStorage storage;
+  if (!peer_address.ToSockAddr(storage.addr, &storage.addr_len) &&
+      // For backward compatibility, allows the empty address.
+      !(peer_address == IPEndPoint())) {
+    return ERR_ADDRESS_INVALID;
   }
 
-  if (SetNonBlocking(socket_)) {
-    int result = MapSystemError(errno);
-    Close();
-    return result;
-  }
-
-  return OK;
-}
-
-int TCPSocketLibevent::AdoptConnectedSocket(int socket,
-                                            const IPEndPoint& peer_address) {
-  DCHECK(CalledOnValidThread());
-  DCHECK_EQ(socket_, kInvalidSocket);
-
-  socket_ = socket;
-
-  if (SetNonBlocking(socket_)) {
-    int result = MapSystemError(errno);
-    Close();
-    return result;
-  }
-
-  peer_address_.reset(new IPEndPoint(peer_address));
-
-  return OK;
+  socket_.reset(new SocketLibevent);
+  return socket_->AdoptConnectedSocket(socket_fd, storage);
 }
 
 int TCPSocketLibevent::Bind(const IPEndPoint& address) {
-  DCHECK(CalledOnValidThread());
-  DCHECK_NE(socket_, kInvalidSocket);
+  DCHECK(socket_);
 
   SockaddrStorage storage;
   if (!address.ToSockAddr(storage.addr, &storage.addr_len))
     return ERR_ADDRESS_INVALID;
 
-  int result = bind(socket_, storage.addr, storage.addr_len);
-  if (result < 0) {
-    PLOG(ERROR) << "bind() returned an error";
-    return MapSystemError(errno);
-  }
-
-  return OK;
+  return socket_->Bind(storage);
 }
 
 int TCPSocketLibevent::Listen(int backlog) {
-  DCHECK(CalledOnValidThread());
-  DCHECK_GT(backlog, 0);
-  DCHECK_NE(socket_, kInvalidSocket);
-
-  int result = listen(socket_, backlog);
-  if (result < 0) {
-    PLOG(ERROR) << "listen() returned an error";
-    return MapSystemError(errno);
-  }
-
-  return OK;
+  DCHECK(socket_);
+  return socket_->Listen(backlog);
 }
 
-int TCPSocketLibevent::Accept(scoped_ptr<TCPSocketLibevent>* socket,
+int TCPSocketLibevent::Accept(scoped_ptr<TCPSocketLibevent>* tcp_socket,
                               IPEndPoint* address,
                               const CompletionCallback& callback) {
-  DCHECK(CalledOnValidThread());
-  DCHECK(socket);
-  DCHECK(address);
+  DCHECK(tcp_socket);
   DCHECK(!callback.is_null());
-  DCHECK(accept_callback_.is_null());
+  DCHECK(socket_);
+  DCHECK(!accept_socket_);
 
   net_log_.BeginEvent(NetLog::TYPE_TCP_ACCEPT);
 
-  int result = AcceptInternal(socket, address);
-
-  if (result == ERR_IO_PENDING) {
-    if (!base::MessageLoopForIO::current()->WatchFileDescriptor(
-            socket_, true, base::MessageLoopForIO::WATCH_READ,
-            &accept_socket_watcher_, &accept_watcher_)) {
-      PLOG(ERROR) << "WatchFileDescriptor failed on read";
-      return MapSystemError(errno);
-    }
-
-    accept_socket_ = socket;
-    accept_address_ = address;
-    accept_callback_ = callback;
-  }
-
-  return result;
+  int rv = socket_->Accept(
+      &accept_socket_,
+      base::Bind(&TCPSocketLibevent::AcceptCompleted,
+                 base::Unretained(this), tcp_socket, address, callback));
+  if (rv != ERR_IO_PENDING)
+    rv = HandleAcceptCompleted(tcp_socket, address, rv);
+  return rv;
 }
 
 int TCPSocketLibevent::Connect(const IPEndPoint& address,
                                const CompletionCallback& callback) {
-  DCHECK(CalledOnValidThread());
-  DCHECK_NE(socket_, kInvalidSocket);
-  DCHECK(!waiting_connect_);
-
-  // |peer_address_| will be non-NULL if Connect() has been called. Unless
-  // Close() is called to reset the internal state, a second call to Connect()
-  // is not allowed.
-  // Please note that we don't allow a second Connect() even if the previous
-  // Connect() has failed. Connecting the same |socket_| again after a
-  // connection attempt failed results in unspecified behavior according to
-  // POSIX.
-  DCHECK(!peer_address_);
+  DCHECK(socket_);
 
   if (!logging_multiple_connect_attempts_)
     LogConnectBegin(AddressList(address));
 
-  peer_address_.reset(new IPEndPoint(address));
+  net_log_.BeginEvent(NetLog::TYPE_TCP_CONNECT_ATTEMPT,
+                      CreateNetLogIPEndPointCallback(&address));
 
-  int rv = DoConnect();
-  if (rv == ERR_IO_PENDING) {
-    // Synchronous operation not supported.
-    DCHECK(!callback.is_null());
-    write_callback_ = callback;
-    waiting_connect_ = true;
-  } else {
-    DoConnectComplete(rv);
+  SockaddrStorage storage;
+  if (!address.ToSockAddr(storage.addr, &storage.addr_len))
+    return ERR_ADDRESS_INVALID;
+
+  if (use_tcp_fastopen_) {
+    // With TCP FastOpen, we pretend that the socket is connected.
+    DCHECK(!tcp_fastopen_connected_);
+    socket_->SetPeerAddress(storage);
+    return OK;
   }
 
+  int rv = socket_->Connect(storage,
+                            base::Bind(&TCPSocketLibevent::ConnectCompleted,
+                                       base::Unretained(this), callback));
+  if (rv != ERR_IO_PENDING)
+    rv = HandleConnectCompleted(rv);
   return rv;
 }
 
 bool TCPSocketLibevent::IsConnected() const {
-  DCHECK(CalledOnValidThread());
-
-  if (socket_ == kInvalidSocket || waiting_connect_)
+  if (!socket_)
     return false;
 
-  if (use_tcp_fastopen_ && !tcp_fastopen_connected_ && peer_address_) {
+  if (use_tcp_fastopen_ && !tcp_fastopen_connected_ &&
+      socket_->HasPeerAddress()) {
     // With TCP FastOpen, we pretend that the socket is connected.
     // This allows GetPeerAddress() to return peer_address_.
     return true;
   }
 
-  // Check if connection is alive.
-  char c;
-  int rv = HANDLE_EINTR(recv(socket_, &c, 1, MSG_PEEK));
-  if (rv == 0)
-    return false;
-  if (rv == -1 && errno != EAGAIN && errno != EWOULDBLOCK)
-    return false;
-
-  return true;
+  return socket_->IsConnected();
 }
 
 bool TCPSocketLibevent::IsConnectedAndIdle() const {
-  DCHECK(CalledOnValidThread());
-
-  if (socket_ == kInvalidSocket || waiting_connect_)
-    return false;
-
   // TODO(wtc): should we also handle the TCP FastOpen case here,
   // as we do in IsConnected()?
-
-  // Check if connection is alive and we haven't received any data
-  // unexpectedly.
-  char c;
-  int rv = HANDLE_EINTR(recv(socket_, &c, 1, MSG_PEEK));
-  if (rv >= 0)
-    return false;
-  if (errno != EAGAIN && errno != EWOULDBLOCK)
-    return false;
-
-  return true;
+  return socket_ && socket_->IsConnectedAndIdle();
 }
 
 int TCPSocketLibevent::Read(IOBuffer* buf,
                             int buf_len,
                             const CompletionCallback& callback) {
-  DCHECK(CalledOnValidThread());
-  DCHECK_NE(kInvalidSocket, socket_);
-  DCHECK(!waiting_connect_);
-  DCHECK(read_callback_.is_null());
-  // Synchronous operation not supported
+  DCHECK(socket_);
   DCHECK(!callback.is_null());
-  DCHECK_GT(buf_len, 0);
 
-  int nread = HANDLE_EINTR(read(socket_, buf->data(), buf_len));
-  if (nread >= 0) {
-    base::StatsCounter read_bytes("tcp.read_bytes");
-    read_bytes.Add(nread);
-    net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_RECEIVED, nread,
-                                  buf->data());
-    RecordFastOpenStatus();
-    return nread;
-  }
-  if (errno != EAGAIN && errno != EWOULDBLOCK) {
-    int net_error = MapSystemError(errno);
-    net_log_.AddEvent(NetLog::TYPE_SOCKET_READ_ERROR,
-                      CreateNetLogSocketErrorCallback(net_error, errno));
-    return net_error;
-  }
-
-  if (!base::MessageLoopForIO::current()->WatchFileDescriptor(
-          socket_, true, base::MessageLoopForIO::WATCH_READ,
-          &read_socket_watcher_, &read_watcher_)) {
-    DVLOG(1) << "WatchFileDescriptor failed on read, errno " << errno;
-    return MapSystemError(errno);
-  }
-
-  read_buf_ = buf;
-  read_buf_len_ = buf_len;
-  read_callback_ = callback;
-  return ERR_IO_PENDING;
+  int rv = socket_->Read(
+      buf, buf_len,
+      base::Bind(&TCPSocketLibevent::ReadCompleted,
+                 base::Unretained(this), base::Unretained(buf), callback));
+  if (rv != ERR_IO_PENDING)
+    rv = HandleReadCompleted(buf, rv);
+  return rv;
 }
 
 int TCPSocketLibevent::Write(IOBuffer* buf,
                              int buf_len,
                              const CompletionCallback& callback) {
-  DCHECK(CalledOnValidThread());
-  DCHECK_NE(kInvalidSocket, socket_);
-  DCHECK(!waiting_connect_);
-  DCHECK(write_callback_.is_null());
-  // Synchronous operation not supported
+  DCHECK(socket_);
   DCHECK(!callback.is_null());
-  DCHECK_GT(buf_len, 0);
 
-  int nwrite = InternalWrite(buf, buf_len);
-  if (nwrite >= 0) {
-    base::StatsCounter write_bytes("tcp.write_bytes");
-    write_bytes.Add(nwrite);
-    net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_SENT, nwrite,
-                                  buf->data());
-    return nwrite;
-  }
-  if (errno != EAGAIN && errno != EWOULDBLOCK) {
-    int net_error = MapSystemError(errno);
-    net_log_.AddEvent(NetLog::TYPE_SOCKET_WRITE_ERROR,
-                      CreateNetLogSocketErrorCallback(net_error, errno));
-    return net_error;
+  CompletionCallback write_callback =
+      base::Bind(&TCPSocketLibevent::WriteCompleted,
+                 base::Unretained(this), base::Unretained(buf), callback);
+  int rv;
+  if (use_tcp_fastopen_ && !tcp_fastopen_connected_) {
+    rv = TcpFastOpenWrite(buf, buf_len, write_callback);
+  } else {
+    rv = socket_->Write(buf, buf_len, write_callback);
   }
 
-  if (!base::MessageLoopForIO::current()->WatchFileDescriptor(
-          socket_, true, base::MessageLoopForIO::WATCH_WRITE,
-          &write_socket_watcher_, &write_watcher_)) {
-    DVLOG(1) << "WatchFileDescriptor failed on write, errno " << errno;
-    return MapSystemError(errno);
-  }
-
-  write_buf_ = buf;
-  write_buf_len_ = buf_len;
-  write_callback_ = callback;
-  return ERR_IO_PENDING;
+  if (rv != ERR_IO_PENDING)
+    rv = HandleWriteCompleted(buf, rv);
+  return rv;
 }
 
 int TCPSocketLibevent::GetLocalAddress(IPEndPoint* address) const {
-  DCHECK(CalledOnValidThread());
   DCHECK(address);
 
+  if (!socket_)
+    return ERR_SOCKET_NOT_CONNECTED;
+
   SockaddrStorage storage;
-  if (getsockname(socket_, storage.addr, &storage.addr_len) < 0)
-    return MapSystemError(errno);
+  int rv = socket_->GetLocalAddress(&storage);
+  if (rv != OK)
+    return rv;
+
   if (!address->FromSockAddr(storage.addr, storage.addr_len))
     return ERR_ADDRESS_INVALID;
 
   return OK;
 }
 
 int TCPSocketLibevent::GetPeerAddress(IPEndPoint* address) const {
-  DCHECK(CalledOnValidThread());
   DCHECK(address);
+
   if (!IsConnected())
     return ERR_SOCKET_NOT_CONNECTED;
-  *address = *peer_address_;
+
+  SockaddrStorage storage;
+  int rv = socket_->GetPeerAddress(&storage);
+  if (rv != OK)
+    return rv;
+
+  if (!address->FromSockAddr(storage.addr, storage.addr_len))
+    return ERR_ADDRESS_INVALID;
+
   return OK;
 }
 
 int TCPSocketLibevent::SetDefaultOptionsForServer() {
-  DCHECK(CalledOnValidThread());
+  DCHECK(socket_);
   return SetAddressReuse(true);
 }
 
 void TCPSocketLibevent::SetDefaultOptionsForClient() {
-  DCHECK(CalledOnValidThread());
+  DCHECK(socket_);
 
   // This mirrors the behaviour on Windows. See the comment in
   // tcp_socket_win.cc after searching for "NODELAY".
-  SetTCPNoDelay(socket_, true);  // If SetTCPNoDelay fails, we don't care.
+  // If SetTCPNoDelay fails, we don't care.
+  SetTCPNoDelay(socket_->socket_fd(), true);
 
   // TCP keep alive wakes up the radio, which is expensive on mobile. Do not
   // enable it there. It's useful to prevent TCP middleboxes from timing out
   // connection mappings. Packets for timed out connection mappings at
   // middleboxes will either lead to:
   // a) Middleboxes sending TCP RSTs. It's up to higher layers to check for this
   // and retry. The HTTP network transaction code does this.
   // b) Middleboxes just drop the unrecognized TCP packet. This leads to the TCP
   // stack retransmitting packets per TCP stack retransmission timeouts, which
   // are very high (on the order of seconds). Given the number of
   // retransmissions required before killing the connection, this can lead to
   // tens of seconds or even minutes of delay, depending on OS.
 #if !defined(OS_ANDROID) && !defined(OS_IOS)
   const int kTCPKeepAliveSeconds = 45;
 
-  SetTCPKeepAlive(socket_, true, kTCPKeepAliveSeconds);
+  SetTCPKeepAlive(socket_->socket_fd(), true, kTCPKeepAliveSeconds);
 #endif
 }
 
 int TCPSocketLibevent::SetAddressReuse(bool allow) {
-  DCHECK(CalledOnValidThread());
+  DCHECK(socket_);
 
   // SO_REUSEADDR is useful for server sockets to bind to a recently unbound
   // port. When a socket is closed, the end point changes its state to TIME_WAIT
   // and wait for 2 MSL (maximum segment lifetime) to ensure the remote peer
   // acknowledges its closure. For server sockets, it is usually safe to
   // bind to a TIME_WAIT end point immediately, which is a widely adopted
   // behavior.
   //
   // Note that on *nix, SO_REUSEADDR does not enable the TCP socket to bind to
   // an end point that is already bound by another socket. To do that one must
   // set SO_REUSEPORT instead. This option is not provided on Linux prior
   // to 3.9.
   //
   // SO_REUSEPORT is provided in MacOS X and iOS.
   int boolean_value = allow ? 1 : 0;
-  int rv = setsockopt(socket_, SOL_SOCKET, SO_REUSEADDR, &boolean_value,
-                      sizeof(boolean_value));
+  int rv = setsockopt(socket_->socket_fd(), SOL_SOCKET, SO_REUSEADDR,
+                      &boolean_value, sizeof(boolean_value));
   if (rv < 0)
     return MapSystemError(errno);
   return OK;
 }
 
 int TCPSocketLibevent::SetReceiveBufferSize(int32 size) {
-  DCHECK(CalledOnValidThread());
-  int rv = setsockopt(socket_, SOL_SOCKET, SO_RCVBUF,
+  DCHECK(socket_);
+  int rv = setsockopt(socket_->socket_fd(), SOL_SOCKET, SO_RCVBUF,
                       reinterpret_cast<const char*>(&size), sizeof(size));
   return (rv == 0) ? OK : MapSystemError(errno);
 }
 
 int TCPSocketLibevent::SetSendBufferSize(int32 size) {
-  DCHECK(CalledOnValidThread());
-  int rv = setsockopt(socket_, SOL_SOCKET, SO_SNDBUF,
+  DCHECK(socket_);
+  int rv = setsockopt(socket_->socket_fd(), SOL_SOCKET, SO_SNDBUF,
                       reinterpret_cast<const char*>(&size), sizeof(size));
   return (rv == 0) ? OK : MapSystemError(errno);
 }
 
 bool TCPSocketLibevent::SetKeepAlive(bool enable, int delay) {
-  DCHECK(CalledOnValidThread());
-  return SetTCPKeepAlive(socket_, enable, delay);
+  DCHECK(socket_);
+  return SetTCPKeepAlive(socket_->socket_fd(), enable, delay);
 }
 
 bool TCPSocketLibevent::SetNoDelay(bool no_delay) {
-  DCHECK(CalledOnValidThread());
-  return SetTCPNoDelay(socket_, no_delay);
+  DCHECK(socket_);
+  return SetTCPNoDelay(socket_->socket_fd(), no_delay);
 }
 
 void TCPSocketLibevent::Close() {
-  DCHECK(CalledOnValidThread());
-
-  bool ok = accept_socket_watcher_.StopWatchingFileDescriptor();
-  DCHECK(ok);
-  ok = read_socket_watcher_.StopWatchingFileDescriptor();
-  DCHECK(ok);
-  ok = write_socket_watcher_.StopWatchingFileDescriptor();
-  DCHECK(ok);
-
-  if (socket_ != kInvalidSocket) {
-    if (IGNORE_EINTR(close(socket_)) < 0)
-      PLOG(ERROR) << "close";
-    socket_ = kInvalidSocket;
-  }
-
-  if (!accept_callback_.is_null()) {
-    accept_socket_ = NULL;
-    accept_address_ = NULL;
-    accept_callback_.Reset();
-  }
-
-  if (!read_callback_.is_null()) {
-    read_buf_ = NULL;
-    read_buf_len_ = 0;
-    read_callback_.Reset();
-  }
-
-  if (!write_callback_.is_null()) {
-    write_buf_ = NULL;
-    write_buf_len_ = 0;
-    write_callback_.Reset();
-  }
-
+  socket_.reset();
   tcp_fastopen_connected_ = false;
   fast_open_status_ = FAST_OPEN_STATUS_UNKNOWN;
-  waiting_connect_ = false;
-  peer_address_.reset();
-  connect_os_error_ = 0;
 }
 
 bool TCPSocketLibevent::UsingTCPFastOpen() const {
   return use_tcp_fastopen_;
 }
 
 void TCPSocketLibevent::StartLoggingMultipleConnectAttempts(
     const AddressList& addresses) {
   if (!logging_multiple_connect_attempts_) {
     logging_multiple_connect_attempts_ = true;
     LogConnectBegin(addresses);
   } else {
     NOTREACHED();
   }
 }
 
 void TCPSocketLibevent::EndLoggingMultipleConnectAttempts(int net_error) {
   if (logging_multiple_connect_attempts_) {
     LogConnectEnd(net_error);
     logging_multiple_connect_attempts_ = false;
   } else {
     NOTREACHED();
   }
 }
 
-int TCPSocketLibevent::AcceptInternal(scoped_ptr<TCPSocketLibevent>* socket,
-                                      IPEndPoint* address) {
+void TCPSocketLibevent::AcceptCompleted(
+    scoped_ptr<TCPSocketLibevent>* tcp_socket,
+    IPEndPoint* address,
+    const CompletionCallback& callback,
+    int rv) {
+  DCHECK_NE(ERR_IO_PENDING, rv);
+  callback.Run(HandleAcceptCompleted(tcp_socket, address, rv));
+}
+
+int TCPSocketLibevent::HandleAcceptCompleted(
+    scoped_ptr<TCPSocketLibevent>* tcp_socket,
+    IPEndPoint* address,
+    int rv) {
+  if (rv == OK)
+    rv = BuildTcpSocketLibevent(tcp_socket, address);
+
+  if (rv != OK && rv != ERR_IO_PENDING)
+    net_log_.EndEventWithNetErrorCode(NetLog::TYPE_TCP_ACCEPT, rv);
+
+  return rv;
+}
+
+int TCPSocketLibevent::BuildTcpSocketLibevent(
+    scoped_ptr<TCPSocketLibevent>* tcp_socket,
+    IPEndPoint* address) {
+  DCHECK(accept_socket_);
+
   SockaddrStorage storage;
-  int new_socket = HANDLE_EINTR(accept(socket_,
-                                       storage.addr,
-                                       &storage.addr_len));
-  if (new_socket < 0) {
-    int net_error = MapAcceptError(errno);
-    if (net_error != ERR_IO_PENDING)
-      net_log_.EndEventWithNetErrorCode(NetLog::TYPE_TCP_ACCEPT, net_error);
-    return net_error;
+  if (accept_socket_->GetPeerAddress(&storage) != OK ||
+      !address->FromSockAddr(storage.addr, storage.addr_len)) {
+    accept_socket_.reset();
+    return ERR_ADDRESS_INVALID;
   }
 
-  IPEndPoint ip_end_point;
-  if (!ip_end_point.FromSockAddr(storage.addr, storage.addr_len)) {
-    NOTREACHED();
-    if (IGNORE_EINTR(close(new_socket)) < 0)
-      PLOG(ERROR) << "close";
-    int net_error = ERR_ADDRESS_INVALID;
-    net_log_.EndEventWithNetErrorCode(NetLog::TYPE_TCP_ACCEPT, net_error);
-    return net_error;
-  }
-  scoped_ptr<TCPSocketLibevent> tcp_socket(new TCPSocketLibevent(
-      net_log_.net_log(), net_log_.source()));
-  int adopt_result = tcp_socket->AdoptConnectedSocket(new_socket, ip_end_point);
-  if (adopt_result != OK) {
-    net_log_.EndEventWithNetErrorCode(NetLog::TYPE_TCP_ACCEPT, adopt_result);
-    return adopt_result;
-  }
-  *socket = tcp_socket.Pass();
-  *address = ip_end_point;
+  tcp_socket->reset(new TCPSocketLibevent(net_log_.net_log(),
+                                          net_log_.source()));
+  (*tcp_socket)->socket_.reset(accept_socket_.release());
   net_log_.EndEvent(NetLog::TYPE_TCP_ACCEPT,
-                    CreateNetLogIPEndPointCallback(&ip_end_point));
+                    CreateNetLogIPEndPointCallback(address));

[mmenke, 2014/06/30 18:26:51]

Think we should move this up to HandleAcceptCompleted.  It's a little confusing
to log it in one place on accept, and another place on failure.

[byungchul, 2014/06/30 19:38:35]

Done.

   return OK;
 }
 
-int TCPSocketLibevent::DoConnect() {
-  DCHECK_EQ(0, connect_os_error_);
-
-  net_log_.BeginEvent(NetLog::TYPE_TCP_CONNECT_ATTEMPT,
-                      CreateNetLogIPEndPointCallback(peer_address_.get()));
-
-  // Connect the socket.
-  if (!use_tcp_fastopen_) {
-    SockaddrStorage storage;
-    if (!peer_address_->ToSockAddr(storage.addr, &storage.addr_len))
-      return ERR_ADDRESS_INVALID;
-
-    if (!HANDLE_EINTR(connect(socket_, storage.addr, storage.addr_len))) {
-      // Connected without waiting!
-      return OK;
-    }
-  } else {
-    // With TCP FastOpen, we pretend that the socket is connected.
-    DCHECK(!tcp_fastopen_connected_);
-    return OK;
-  }
-
-  // Check if the connect() failed synchronously.
-  connect_os_error_ = errno;
-  if (connect_os_error_ != EINPROGRESS)
-    return MapConnectError(connect_os_error_);
-
-  // Otherwise the connect() is going to complete asynchronously, so watch
-  // for its completion.
-  if (!base::MessageLoopForIO::current()->WatchFileDescriptor(
-          socket_, true, base::MessageLoopForIO::WATCH_WRITE,
-          &write_socket_watcher_, &write_watcher_)) {
-    connect_os_error_ = errno;
-    DVLOG(1) << "WatchFileDescriptor failed: " << connect_os_error_;
-    return MapSystemError(connect_os_error_);
-  }
-
-  return ERR_IO_PENDING;
+void TCPSocketLibevent::ConnectCompleted(const CompletionCallback& callback,
+                                         int rv) const {
+  DCHECK_NE(ERR_IO_PENDING, rv);
+  callback.Run(HandleConnectCompleted(rv));
 }
 
-void TCPSocketLibevent::DoConnectComplete(int result) {
+int TCPSocketLibevent::HandleConnectCompleted(int rv) const {
   // Log the end of this attempt (and any OS error it threw).
-  int os_error = connect_os_error_;
-  connect_os_error_ = 0;
-  if (result != OK) {
+  int os_error = errno;

[mmenke, 2014/06/30 18:26:51]

This imposes a non-obvious constraint on SocketLibevent (And the same is true of
accessing errno in the read/write functions as well).  This should be documented
as part of SocketLibevent's connect function.  Longer term, may want to consider
a more robust way of passing the information, or only logging the network error.

[mmenke, 2014/06/30 18:26:51]

nit:  Can just inline this below.

[byungchul, 2014/06/30 19:38:35]

Done.

[byungchul, 2014/06/30 19:38:35]

Done.

+  if (rv != OK) {
     net_log_.EndEvent(NetLog::TYPE_TCP_CONNECT_ATTEMPT,
                       NetLog::IntegerCallback("os_error", os_error));
   } else {
     net_log_.EndEvent(NetLog::TYPE_TCP_CONNECT_ATTEMPT);
   }
 
+  // Give a more specific error when the user is offline.
+  if (rv == ERR_ADDRESS_UNREACHABLE && NetworkChangeNotifier::IsOffline())
+    rv = ERR_INTERNET_DISCONNECTED;
+
   if (!logging_multiple_connect_attempts_)
-    LogConnectEnd(result);
+    LogConnectEnd(rv);
+
+  return rv;
 }
 
-void TCPSocketLibevent::LogConnectBegin(const AddressList& addresses) {
+void TCPSocketLibevent::LogConnectBegin(const AddressList& addresses) const {
   base::StatsCounter connects("tcp.connect");
   connects.Increment();
 
   net_log_.BeginEvent(NetLog::TYPE_TCP_CONNECT,
                       addresses.CreateNetLogCallback());
 }
 
-void TCPSocketLibevent::LogConnectEnd(int net_error) {
-  if (net_error == OK)
-    UpdateConnectionTypeHistograms(CONNECTION_ANY);
-
+void TCPSocketLibevent::LogConnectEnd(int net_error) const {
   if (net_error != OK) {
     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_TCP_CONNECT, net_error);
     return;
   }
 
+  UpdateConnectionTypeHistograms(CONNECTION_ANY);
+
   SockaddrStorage storage;
-  int rv = getsockname(socket_, storage.addr, &storage.addr_len);
-  if (rv != 0) {
-    PLOG(ERROR) << "getsockname() [rv: " << rv << "] error: ";
+  int rv = socket_->GetLocalAddress(&storage);
+  if (rv != OK) {
+    PLOG(ERROR) << "GetLocalAddress() [rv: " << rv << "] error: ";
     NOTREACHED();
     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_TCP_CONNECT, rv);
     return;
   }
 
   net_log_.EndEvent(NetLog::TYPE_TCP_CONNECT,
                     CreateNetLogSourceAddressCallback(storage.addr,
                                                       storage.addr_len));
 }
 
-void TCPSocketLibevent::DidCompleteRead() {
-  RecordFastOpenStatus();
-  if (read_callback_.is_null())
-    return;
+void TCPSocketLibevent::ReadCompleted(IOBuffer* buf,
+                                      const CompletionCallback& callback,
+                                      int rv) {
+  DCHECK_NE(ERR_IO_PENDING, rv);
+  callback.Run(HandleReadCompleted(buf, rv));
+}
 
-  int bytes_transferred;
-  bytes_transferred = HANDLE_EINTR(read(socket_, read_buf_->data(),
-                                        read_buf_len_));
-
-  int result;
-  if (bytes_transferred >= 0) {
-    result = bytes_transferred;
-    base::StatsCounter read_bytes("tcp.read_bytes");
-    read_bytes.Add(bytes_transferred);
-    net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_RECEIVED, result,
-                                  read_buf_->data());
-  } else {
-    result = MapSystemError(errno);
-    if (result != ERR_IO_PENDING) {
-      net_log_.AddEvent(NetLog::TYPE_SOCKET_READ_ERROR,
-                        CreateNetLogSocketErrorCallback(result, errno));
-    }
+int TCPSocketLibevent::HandleReadCompleted(IOBuffer* buf, int rv) {
+  if (rv < 0) {
+    net_log_.AddEvent(NetLog::TYPE_SOCKET_READ_ERROR,
+                      CreateNetLogSocketErrorCallback(rv, errno));
+    return rv;
   }
 
-  if (result != ERR_IO_PENDING) {
-    read_buf_ = NULL;
-    read_buf_len_ = 0;
-    bool ok = read_socket_watcher_.StopWatchingFileDescriptor();
-    DCHECK(ok);
-    base::ResetAndReturn(&read_callback_).Run(result);
-  }
+  base::StatsCounter read_bytes("tcp.read_bytes");
+  read_bytes.Add(rv);
+  net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_RECEIVED, rv,
+                                buf->data());
+  RecordFastOpenStatus();

[mmenke, 2014/06/30 18:26:51]

We used to call this regardless of failure, success, or getting ERR_IO_PENDING. 
This is a significant change to when we call this, and I believe it's meant to
be called both on success and on failure, not sure about ERR_IO_PENDING.  It
also overwrites errno.

So...changes:
1)  Need to call this on error.
2)  The ERR_IO_PENDING change is enough of a change that we may want to rename
the histogram if affects.  Should probably contact the person who added the
histogram (rdsmith, maybe?) and ask about this.

[byungchul, 2014/06/30 19:38:35]

Not sure if it should be called at error as well. If you see the original code,
there are 2 places to call RecordFastOpenStatus():
1) Read() which calls it only on success
2) DidCompleteRead() which calls BEFORE read.

Added rdsmith for review.

[Randy Smith (Not in Mondays), 2014/07/07 19:46:41]

Arggh.  My read of the code (memory isn't clear) is that this was broken as
written; it's called only on success in the synchronous case, and on both
success and failure in the async cases.  So I think that means you should:
* Change the histogram name; suffix an _A or something.
* Add an extra argument to the function indicating whether this is success or
error, and make sure it's called in both cases (don't call it on IO_PENDING--the
goal here is that the first read on the socket will be after the handshake, so
it can figure out how the handshake happened).
* Keep the behavior in RecordFastOpenStatus() of ignoring the call if we aren't
in {FAST,SLOW}_CONNECT_RETURN; if we aren't, that means we've already figured
out how the initial handshake went.
* Add two more entries in the enum for {FAST,SLOW}_CONNECT_RETURN error,
indicating that the fast open connection failed (or, at least, we never managed
to use the socket after we did the connection in a way that suggests the problem
might have to do with the fast open).

But I'd like Jana to evaluate this plan (Matt, your opinion is also welcome). 
I'll ping him for that eval.

[byungchul, 2014/07/07 21:10:26]

Modified to call RecordFastOpenStatus() as before, and added TODO for you to
revise histogram because I am afraid not to do it correctly.

+  return rv;
 }
 
-void TCPSocketLibevent::DidCompleteWrite() {
-  if (write_callback_.is_null())
-    return;
+void TCPSocketLibevent::WriteCompleted(IOBuffer* buf,
+                                       const CompletionCallback& callback,
+                                       int rv) const {
+  DCHECK_NE(ERR_IO_PENDING, rv);
+  callback.Run(HandleWriteCompleted(buf, rv));
+}
 
-  int bytes_transferred;
-  bytes_transferred = HANDLE_EINTR(write(socket_, write_buf_->data(),
-                                         write_buf_len_));
-
-  int result;
-  if (bytes_transferred >= 0) {
-    result = bytes_transferred;
-    base::StatsCounter write_bytes("tcp.write_bytes");
-    write_bytes.Add(bytes_transferred);
-    net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_SENT, result,
-                                  write_buf_->data());
-  } else {
-    result = MapSystemError(errno);
-    if (result != ERR_IO_PENDING) {
-      net_log_.AddEvent(NetLog::TYPE_SOCKET_WRITE_ERROR,
-                        CreateNetLogSocketErrorCallback(result, errno));
-    }
+int TCPSocketLibevent::HandleWriteCompleted(IOBuffer* buf, int rv) const {
+  if (rv < 0) {
+    net_log_.AddEvent(NetLog::TYPE_SOCKET_WRITE_ERROR,
+                      CreateNetLogSocketErrorCallback(rv, errno));
+    return rv;
   }
 
-  if (result != ERR_IO_PENDING) {
-    write_buf_ = NULL;
-    write_buf_len_ = 0;
-    write_socket_watcher_.StopWatchingFileDescriptor();
-    base::ResetAndReturn(&write_callback_).Run(result);
-  }
+  base::StatsCounter write_bytes("tcp.write_bytes");
+  write_bytes.Add(rv);
+  net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_SENT, rv,
+                                buf->data());
+  return rv;
 }
 
-void TCPSocketLibevent::DidCompleteConnect() {
-  DCHECK(waiting_connect_);
+int TCPSocketLibevent::TcpFastOpenWrite(
+    IOBuffer* buf,
+    int buf_len,
+    const CompletionCallback& callback) {
+  SockaddrStorage storage;
+  int rv = socket_->GetPeerAddress(&storage);
+  if (rv != OK)
+    return rv;
 
-  // Get the error that connect() completed with.
-  int os_error = 0;
-  socklen_t len = sizeof(os_error);
-  if (getsockopt(socket_, SOL_SOCKET, SO_ERROR, &os_error, &len) < 0)
-    os_error = errno;
+  int flags = 0x20000000; // Magic flag to enable TCP_FASTOPEN.

[mmenke, 2014/06/30 18:26:51]

nit:  2 spaces before comment (Know the old code had this issue as well).

[byungchul, 2014/06/30 19:38:35]

Done.

+#if defined(OS_LINUX)
+  // sendto() will fail with EPIPE when the system doesn't support TCP Fast
+  // Open. Theoretically that shouldn't happen since the caller should check
+  // for system support on startup, but users may dynamically disable TCP Fast
+  // Open via sysctl.
+  flags |= MSG_NOSIGNAL;
+#endif // defined(OS_LINUX)
+  rv = HANDLE_EINTR(sendto(socket_->socket_fd(),
+                           buf->data(),
+                           buf_len,
+                           flags,
+                           storage.addr,
+                           storage.addr_len));
+  tcp_fastopen_connected_ = true;
 
-  int result = MapConnectError(os_error);
-  connect_os_error_ = os_error;
-  if (result != ERR_IO_PENDING) {
-    DoConnectComplete(result);
-    waiting_connect_ = false;
-    write_socket_watcher_.StopWatchingFileDescriptor();
-    base::ResetAndReturn(&write_callback_).Run(result);
+  if (rv >= 0) {
+    fast_open_status_ = FAST_OPEN_FAST_CONNECT_RETURN;
+    return rv;
   }
-}
 
-void TCPSocketLibevent::DidCompleteConnectOrWrite() {
-  if (waiting_connect_)
-    DidCompleteConnect();
-  else
-    DidCompleteWrite();
-}
+  DCHECK_NE(EPIPE, errno);
 
-void TCPSocketLibevent::DidCompleteAccept() {
-  DCHECK(CalledOnValidThread());
+  // If errno == EINPROGRESS, that means the kernel didn't have a cookie
+  // and would block. The kernel is internally doing a connect() though.
+  // Remap EINPROGRESS to EAGAIN so we treat this the same as our other
+  // asynchronous cases. Note that the user buffer has not been copied to
+  // kernel space.
+  if (errno == EINPROGRESS) {
+    rv = ERR_IO_PENDING;
+  } else {
+    rv = MapSystemError(errno);
+  }
 
-  int result = AcceptInternal(accept_socket_, accept_address_);
-  if (result != ERR_IO_PENDING) {
-    accept_socket_ = NULL;
-    accept_address_ = NULL;
-    bool ok = accept_socket_watcher_.StopWatchingFileDescriptor();
-    DCHECK(ok);
-    CompletionCallback callback = accept_callback_;
-    accept_callback_.Reset();
-    callback.Run(result);
+  if (rv != ERR_IO_PENDING) {
+    fast_open_status_ = FAST_OPEN_ERROR;
+    return rv;
   }
-}
 
-int TCPSocketLibevent::InternalWrite(IOBuffer* buf, int buf_len) {
-  int nwrite;
-  if (use_tcp_fastopen_ && !tcp_fastopen_connected_) {
-    SockaddrStorage storage;
-    if (!peer_address_->ToSockAddr(storage.addr, &storage.addr_len)) {
-      // Set errno to EADDRNOTAVAIL so that MapSystemError will map it to
-      // ERR_ADDRESS_INVALID later.
-      errno = EADDRNOTAVAIL;
-      return -1;
-    }
-
-    int flags = 0x20000000; // Magic flag to enable TCP_FASTOPEN.
-#if defined(OS_LINUX)
-    // sendto() will fail with EPIPE when the system doesn't support TCP Fast
-    // Open. Theoretically that shouldn't happen since the caller should check
-    // for system support on startup, but users may dynamically disable TCP Fast
-    // Open via sysctl.
-    flags |= MSG_NOSIGNAL;
-#endif // defined(OS_LINUX)
-    nwrite = HANDLE_EINTR(sendto(socket_,
-                                 buf->data(),
-                                 buf_len,
-                                 flags,
-                                 storage.addr,
-                                 storage.addr_len));
-    tcp_fastopen_connected_ = true;
-
-    if (nwrite < 0) {
-      DCHECK_NE(EPIPE, errno);
-
-      // If errno == EINPROGRESS, that means the kernel didn't have a cookie
-      // and would block. The kernel is internally doing a connect() though.
-      // Remap EINPROGRESS to EAGAIN so we treat this the same as our other
-      // asynchronous cases. Note that the user buffer has not been copied to
-      // kernel space.
-      if (errno == EINPROGRESS) {
-        errno = EAGAIN;
-        fast_open_status_ = FAST_OPEN_SLOW_CONNECT_RETURN;
-      } else {
-        fast_open_status_ = FAST_OPEN_ERROR;
-      }
-    } else {
-      fast_open_status_ = FAST_OPEN_FAST_CONNECT_RETURN;
-    }
-  } else {
-    nwrite = HANDLE_EINTR(write(socket_, buf->data(), buf_len));
-  }
-  return nwrite;
+  fast_open_status_ = FAST_OPEN_SLOW_CONNECT_RETURN;
+  return socket_->WaitForWrite(buf, buf_len, callback);
 }
 
 void TCPSocketLibevent::RecordFastOpenStatus() {
   if (use_tcp_fastopen_ &&
       (fast_open_status_ == FAST_OPEN_FAST_CONNECT_RETURN ||
        fast_open_status_ == FAST_OPEN_SLOW_CONNECT_RETURN)) {
     DCHECK_NE(FAST_OPEN_STATUS_UNKNOWN, fast_open_status_);
     bool getsockopt_success(false);
     bool server_acked_data(false);
 #if defined(TCP_INFO)
     // Probe to see the if the socket used TCP Fast Open.
     tcp_info info;
     socklen_t info_len = sizeof(tcp_info);
     getsockopt_success =
-        getsockopt(socket_, IPPROTO_TCP, TCP_INFO, &info, &info_len) == 0 &&
+        getsockopt(socket_->socket_fd(), IPPROTO_TCP, TCP_INFO,
+                   &info, &info_len) == 0 &&
         info_len == sizeof(tcp_info);
     server_acked_data = getsockopt_success &&
         (info.tcpi_options & TCPI_OPT_SYN_DATA);
 #endif
     if (getsockopt_success) {
       if (fast_open_status_ == FAST_OPEN_FAST_CONNECT_RETURN) {
         fast_open_status_ = (server_acked_data ? FAST_OPEN_SYN_DATA_ACK :
                              FAST_OPEN_SYN_DATA_NACK);
       } else {
         fast_open_status_ = (server_acked_data ? FAST_OPEN_NO_SYN_DATA_ACK :
                              FAST_OPEN_NO_SYN_DATA_NACK);
       }
     } else {
       fast_open_status_ = (fast_open_status_ == FAST_OPEN_FAST_CONNECT_RETURN ?
                            FAST_OPEN_SYN_DATA_FAILED :
                            FAST_OPEN_NO_SYN_DATA_FAILED);
     }
   }
 }
 
 }  // namespace net