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);
+  int rv = socket_->Open(ConvertAddressFamily(family));
+  if (rv != OK)
+    socket_.reset();
+  return rv;
+}
 
-  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);
+  int rv = socket_->AdoptConnectedSocket(socket_fd, storage);
+  if (rv != OK)
+    socket_.reset();
+  return rv;
 }
 
 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());
+  int rv = socket_->Read(
+      buf, buf_len,
+      base::Bind(&TCPSocketLibevent::ReadCompleted,
+                 base::Unretained(this), base::Unretained(buf), callback));
+  if (rv >= 0)
     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;
+  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_;
 }
 
+bool TCPSocketLibevent::IsValid() const {
+  return socket_ != NULL && socket_->socket_fd() != kInvalidSocket;
+}
+
 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) {
-  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;
+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) {
+    net_log_.EndEvent(NetLog::TYPE_TCP_ACCEPT,
+                      CreateNetLogIPEndPointCallback(address));
+  } else {
+    net_log_.EndEventWithNetErrorCode(NetLog::TYPE_TCP_ACCEPT, rv);
   }
 
-  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;
+  return rv;
+}
+
+int TCPSocketLibevent::BuildTcpSocketLibevent(
+    scoped_ptr<TCPSocketLibevent>* tcp_socket,
+    IPEndPoint* address) {
+  DCHECK(accept_socket_);
+
+  SockaddrStorage storage;
+  if (accept_socket_->GetPeerAddress(&storage) != OK ||
+      !address->FromSockAddr(storage.addr, storage.addr_len)) {
+    accept_socket_.reset();
+    return ERR_ADDRESS_INVALID;
   }
-  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;
-  net_log_.EndEvent(NetLog::TYPE_TCP_ACCEPT,
-                    CreateNetLogIPEndPointCallback(&ip_end_point));
+
+  tcp_socket->reset(new TCPSocketLibevent(net_log_.net_log(),
+                                          net_log_.source()));
+  (*tcp_socket)->socket_.reset(accept_socket_.release());
   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) {
+  if (rv != OK) {
     net_log_.EndEvent(NetLog::TYPE_TCP_CONNECT_ATTEMPT,
-                      NetLog::IntegerCallback("os_error", os_error));
+                      NetLog::IntegerCallback("os_error", errno));
   } 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() {
+void TCPSocketLibevent::ReadCompleted(IOBuffer* buf,
+                                      const CompletionCallback& callback,
+                                      int rv) {
+  DCHECK_NE(ERR_IO_PENDING, rv);
+  // Records fast open status regardless of error in asynchronous case.
+  // TODO(rdsmith,jri): Change histogram name to indicate it could be called on
+  // error.
   RecordFastOpenStatus();
-  if (read_callback_.is_null())
-    return;
+  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());
+  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.
+#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