message_pump_libevent refactor:

net/base/listen_socket.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 "build/build_config.h"
 
 #if defined(OS_WIN)
 // winsock2.h must be included first in order to ensure it is included before
 // windows.h.
 #include <winsock2.h>
 #elif defined(OS_POSIX)
 #include <errno.h>
 #include <sys/socket.h>
 #include <arpa/inet.h>
-#include "base/message_loop.h"
 #include "net/base/net_errors.h"
 #include "third_party/libevent/event.h"
 #endif
 
 #include "net/base/net_util.h"
 #include "net/base/listen_socket.h"
 
 #if defined(OS_WIN)
 #define socklen_t int
 #elif defined(OS_POSIX)
 const int INVALID_SOCKET = -1; // Used same name as in Windows to avoid #ifdef
 const int SOCKET_ERROR = -1;
 #endif
 
 const int kReadBufSize = 200;
 
 ListenSocket::ListenSocket(SOCKET s, ListenSocketDelegate *del)
-#if defined(OS_WIN)
     : socket_(s),
-#elif defined(OS_POSIX)
-    : event_(new event), 
-      socket_(s),
-#endif
       socket_delegate_(del) {
 #if defined(OS_WIN)
   socket_event_ = WSACreateEvent();
   // TODO(ibrar): error handling in case of socket_event_ == WSA_INVALID_EVENT
   WatchSocket(NOT_WAITING);
 #endif
 }
 
 ListenSocket::~ListenSocket() {
 #if defined(OS_WIN)
@@ skipping 121 matching lines @@
     return;
   wait_state_ = WAITING_CLOSE;
 #endif
   socket_delegate_->DidClose(this);
 }
 
 void ListenSocket::UnwatchSocket() {
 #if defined(OS_WIN)
   watcher_.StopWatching();
 #elif defined(OS_POSIX)
-  MessageLoopForIO::current()->UnwatchSocket(event_.get());
-  wait_state_ = NOT_WAITING;
+  watcher_.StopWatchingFileDescriptor();
 #endif
 }
 
 void ListenSocket::WatchSocket(WaitState state) {
 #if defined(OS_WIN)
   WSAEventSelect(socket_, socket_event_, FD_ACCEPT | FD_CLOSE | FD_READ);
   watcher_.StartWatching(socket_event_, this);
 #elif defined(OS_POSIX)
-  MessageLoopForIO::current()->WatchSocket(
-      socket_, EV_READ|EV_PERSIST, event_.get(),this);
+  // Implicitly calls StartWatchingFileDescriptor().
+  MessageLoopForIO::current()->WatchFileDescriptor(
+      socket_, true, MessageLoopForIO::WATCH_READ, &watcher_, this);
   wait_state_ = state;
 #endif
 }
 
 void ListenSocket::SendInternal(const char* bytes, int len) {
   int sent = send(socket_, bytes, len, 0);
   if (sent == SOCKET_ERROR) {
 #if defined(OS_WIN)
   int err = WSAGetLastError();
   if (err == WSAEWOULDBLOCK) {
@@ skipping 41 matching lines @@
     Accept();
   }
   if (ev.lNetworkEvents & FD_READ) {
     Read();
   }
   if (ev.lNetworkEvents & FD_CLOSE) {
     Close();
   }
 }
 #elif defined(OS_POSIX)
-void ListenSocket::OnSocketReady(short flags) {
+void ListenSocket::OnFileCanReadWithoutBlocking(int fd) {
   if (wait_state_ == WAITING_ACCEPT) {
     Accept();
   }
   if (wait_state_ == WAITING_READ) {
     Read();
   }
   if (wait_state_ == WAITING_CLOSE) {
     // Close() is called by Read() in the Linux case.
     // TODO(erikkay): this seems to get hit multiple times after the close
   }
 }
+
+void ListenSocket::OnFileCanWriteWithoutBlocking(int fd) {
+  // MessagePumpLibevent callback, we don't listen for write events
+  // so we shouldn't ever reach here.
+  NOTREACHED();
+}
+
 #endif