Reverting 6911.

net/base/tcp_client_socket_libevent.cc

 // Copyright (c) 2006-2008 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/base/tcp_client_socket.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <netdb.h>
 #include <sys/socket.h>
@@ skipping 50 matching lines @@
   }
 }
 
 //-----------------------------------------------------------------------------
 
 TCPClientSocket::TCPClientSocket(const AddressList& addresses)
   : socket_(kInvalidSocket),
     addresses_(addresses),
     current_ai_(addresses_.head()),
     waiting_connect_(false),
+    event_(new event),
     write_callback_(NULL),
     callback_(NULL) {
 }
 
 TCPClientSocket::~TCPClientSocket() {
   Disconnect();
 }
 
 int TCPClientSocket::Connect(CompletionCallback* callback) {
   // If already connected, then just return OK.
@@ skipping 21 matching lines @@
     DLOG(INFO) << "connect failed: " << errno;
     close(socket_);
     socket_ = kInvalidSocket;
     return MapPosixError(errno);
   }
 
   // Initialize event_ and link it to our MessagePump.
   // POLLOUT is set if the connection is established.
   // POLLIN is set if the connection fails,
   // so select for both read and write.
-  MessageLoopForIO::current()->WatchFileDescriptor(
-     socket_, true, MessageLoopForIO::WATCH_READ_WRITE, &socket_watcher_, this);
+  MessageLoopForIO::current()->WatchSocket(
+     socket_, EV_READ|EV_WRITE|EV_PERSIST, event_.get(), this);
 
   waiting_connect_ = true;
   callback_ = callback;
   return ERR_IO_PENDING;
 }
 
 int TCPClientSocket::ReconnectIgnoringLastError(CompletionCallback* callback) {
   // No ignorable errors!
   return ERR_UNEXPECTED;
 }
 
 void TCPClientSocket::Disconnect() {
   if (socket_ == kInvalidSocket)
     return;
 
-  socket_watcher_.StopWatchingFileDescriptor();
+  MessageLoopForIO::current()->UnwatchSocket(event_.get());
   close(socket_);
   socket_ = kInvalidSocket;
   waiting_connect_ = false;
 
   // Reset for next time.
   current_ai_ = addresses_.head();
 }
 
 bool TCPClientSocket::IsConnected() const {
   if (socket_ == kInvalidSocket || waiting_connect_)
@@ skipping 22 matching lines @@
 
   int nread = read(socket_, buf, buf_len);
   if (nread >= 0) {
     return nread;
   }
   if (errno != EAGAIN && errno != EWOULDBLOCK) {
     DLOG(INFO) << "read failed, errno " << errno;
     return MapPosixError(errno);
   }
 
-  MessageLoopForIO::current()->WatchFileDescriptor(
-     socket_, true, MessageLoopForIO::WATCH_READ, &socket_watcher_, this);
+  MessageLoopForIO::current()->WatchSocket(
+     socket_, EV_READ|EV_PERSIST, event_.get(), this);
 
   buf_ = buf;
   buf_len_ = buf_len;
   callback_ = callback;
   return ERR_IO_PENDING;
 }
 
 int TCPClientSocket::Write(const char* buf,
                            int buf_len,
                            CompletionCallback* callback) {
   DCHECK(socket_ != kInvalidSocket);
   DCHECK(!waiting_connect_);
   DCHECK(!write_callback_);
   // Synchronous operation not supported
   DCHECK(callback);
   DCHECK(buf_len > 0);
 
   int nwrite = write(socket_, buf, buf_len);
   if (nwrite >= 0) {
     return nwrite;
   }
   if (errno != EAGAIN && errno != EWOULDBLOCK)
     return MapPosixError(errno);
 
-  MessageLoopForIO::current()->WatchFileDescriptor(
-     socket_, true, MessageLoopForIO::WATCH_WRITE, &socket_watcher_, this);
-
+  MessageLoopForIO::current()->WatchSocket(
+     socket_, EV_WRITE|EV_PERSIST, event_.get(), this);
 
   write_buf_ = buf;
   write_buf_len_ = buf_len;
   write_callback_ = callback;
   return ERR_IO_PENDING;
 }
 
 int TCPClientSocket::CreateSocket(const addrinfo* ai) {
   socket_ = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
   if (socket_ == kInvalidSocket)
@@ skipping 45 matching lines @@
              error_code == ENETUNREACH ||
              error_code == EHOSTUNREACH ||
              error_code == ETIMEDOUT)) {
     // This address failed, try next one in list.
     const addrinfo* next = current_ai_->ai_next;
     Disconnect();
     current_ai_ = next;
     result = Connect(callback_);
   } else {
     result = MapPosixError(error_code);
-    socket_watcher_.StopWatchingFileDescriptor();
+    MessageLoopForIO::current()->UnwatchSocket(event_.get());
     waiting_connect_ = false;
   }
 
   if (result != ERR_IO_PENDING)
     DoCallback(result);
 }
 
 void TCPClientSocket::DidCompleteRead() {
   int bytes_transferred;
   bytes_transferred = read(socket_, buf_, buf_len_);
 
   int result;
   if (bytes_transferred >= 0) {
     result = bytes_transferred;
   } else {
     result = MapPosixError(errno);
   }
 
   if (result != ERR_IO_PENDING) {
     buf_ = NULL;
     buf_len_ = 0;
-    socket_watcher_.StopWatchingFileDescriptor();
+    MessageLoopForIO::current()->UnwatchSocket(event_.get());
     DoCallback(result);
   }
 }
 
 void TCPClientSocket::DidCompleteWrite() {
   int bytes_transferred;
   bytes_transferred = write(socket_, write_buf_, write_buf_len_);
 
   int result;
   if (bytes_transferred >= 0) {
     result = bytes_transferred;
   } else {
     result = MapPosixError(errno);
   }
 
   if (result != ERR_IO_PENDING) {
     write_buf_ = NULL;
     write_buf_len_ = 0;
-    socket_watcher_.StopWatchingFileDescriptor();
+    MessageLoopForIO::current()->UnwatchSocket(event_.get());
     DoWriteCallback(result);
   }
 }
 
-void TCPClientSocket::OnFileCanReadWithoutBlocking(int fd) {
+void TCPClientSocket::OnSocketReady(short flags) {
+  // the only used bits of flags are EV_READ and EV_WRITE
+
   if (waiting_connect_) {
     DidCompleteConnect();
-  } else if (callback_) {
-    DidCompleteRead();
+  } else {
+    if ((flags & EV_WRITE) && write_callback_)
+      DidCompleteWrite();
+    if ((flags & EV_READ) && callback_)
+      DidCompleteRead();
   }
 }
 
-void TCPClientSocket::OnFileCanWriteWithoutBlocking(int fd) {
-  if (waiting_connect_) {
-    DidCompleteConnect();
-  } else if (write_callback_) {
-    DidCompleteWrite();
-  }
-}
-
 int TCPClientSocket::GetPeerName(struct sockaddr *name, socklen_t *namelen) {
   return ::getpeername(socket_, name, namelen);
 }
 
 }  // namespace net