Reverting 6911.

Review URL: http://codereview.chromium.org/14068

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@6916 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 119 insertions, 156 deletions

diff --git a/base/message_loop.cc b/base/message_loop.cc
index 12ad3fa..898fbfa 100644
--- a/base/message_loop.cc
+++ b/base/message_loop.cc
@@ -593,17 +593,22 @@ bool MessageLoopForIO::WaitForIOCompletion(DWORD timeout, IOHandler* filter) {
 
 #elif defined(OS_POSIX)
 
-bool MessageLoopForIO::WatchFileDescriptor(int fd,
-                                           bool persistent,
-                                           Mode mode,
-                                           FileDescriptorWatcher *controller,
-                                           Watcher *delegate) {
-  return pump_libevent()->WatchFileDescriptor(
-      fd,
-      persistent,
-      static_cast<base::MessagePumpLibevent::Mode>(mode),
-      controller,
-      delegate);
+void MessageLoopForIO::WatchSocket(int socket, short interest_mask,
+                                   struct event* e, Watcher* watcher) {
+  pump_libevent()->WatchSocket(socket, interest_mask, e, watcher);
 }
 
+void MessageLoopForIO::WatchFileHandle(int fd, short interest_mask,
+                                       struct event* e, FileWatcher* watcher) {
+  pump_libevent()->WatchFileHandle(fd, interest_mask, e, watcher);
+}
+
+
+void MessageLoopForIO::UnwatchSocket(struct event* e) {
+  pump_libevent()->UnwatchSocket(e);
+}
+
+void MessageLoopForIO::UnwatchFileHandle(struct event* e) {
+  pump_libevent()->UnwatchFileHandle(e);
+}
 #endif
diff --git a/base/message_loop.h b/base/message_loop.h
index 6cd0ef4..69db8c1 100644
--- a/base/message_loop.h
+++ b/base/message_loop.h
@@ -473,21 +473,14 @@ class MessageLoopForIO : public MessageLoop {
 
 #elif defined(OS_POSIX)
   typedef base::MessagePumpLibevent::Watcher Watcher;
-  typedef base::MessagePumpLibevent::FileDescriptorWatcher
-      FileDescriptorWatcher;
-
-  enum Mode {
-    WATCH_READ = base::MessagePumpLibevent::WATCH_READ,
-    WATCH_WRITE = base::MessagePumpLibevent::WATCH_WRITE,
-    WATCH_READ_WRITE = base::MessagePumpLibevent::WATCH_READ_WRITE
-  };
-
-  // Please see MessagePumpLibevent for definition.
-  bool WatchFileDescriptor(int fd,
-                           bool persistent,
-                           Mode mode,
-                           FileDescriptorWatcher *controller,
-                           Watcher *delegate);
+  typedef base::MessagePumpLibevent::FileWatcher FileWatcher;
+
+  // Please see MessagePumpLibevent for definitions of these methods.
+  void WatchSocket(int socket, short interest_mask,
+                   struct event* e, Watcher* watcher);
+  void WatchFileHandle(int fd, short interest_mask, event* e, FileWatcher*);
+  void UnwatchSocket(struct event* e);
+  void UnwatchFileHandle(event* e);
 #endif  // defined(OS_POSIX)
 };
 
diff --git a/base/message_pump_libevent.cc b/base/message_pump_libevent.cc
index 9c13110..a281980 100644
--- a/base/message_pump_libevent.cc
+++ b/base/message_pump_libevent.cc
@@ -15,48 +15,17 @@ namespace base {
 
 // Return 0 on success
 // Too small a function to bother putting in a library?
-static int SetNonBlocking(int fd) {
-  int flags = fcntl(fd, F_GETFL, 0);
-  if (flags == -1)
-    flags = 0;
-  return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
-}
-
-MessagePumpLibevent::FileDescriptorWatcher::FileDescriptorWatcher()
-    : is_persistent_(false),
-      event_(NULL) {
-}
-
-MessagePumpLibevent::FileDescriptorWatcher::~FileDescriptorWatcher() {
-  if (event_.get()) {
-    StopWatchingFileDescriptor();
-  }
-}
-
-void MessagePumpLibevent::FileDescriptorWatcher::Init(event *e,
-                                                      bool is_persistent) {
-  DCHECK(e);
-
-  // Cleanup any old event we might have been watching.
-  if (event_.get()) {
-    StopWatchingFileDescriptor();
-  }
-
-  is_persistent = is_persistent_;
-  event_.reset(e);
-}
-
-bool MessagePumpLibevent::FileDescriptorWatcher::StopWatchingFileDescriptor() {
-  if (event_.get() == NULL) {
-    return true;
-  }
-
-  // event_del() is a no-op of the event isn't active.
-  return (event_del(event_.get()) == 0);
+static int SetNonBlocking(int fd)
+{
+    int flags = fcntl(fd, F_GETFL, 0);
+    if (-1 == flags)
+      flags = 0;
+    return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
 }
 
 // Called if a byte is received on the wakeup pipe.
 void MessagePumpLibevent::OnWakeup(int socket, short flags, void* context) {
+
   base::MessagePumpLibevent* that =
               static_cast<base::MessagePumpLibevent*>(context);
   DCHECK(that->wakeup_pipe_out_ == socket);
@@ -92,7 +61,7 @@ bool MessagePumpLibevent::Init() {
 
   wakeup_event_ = new event;
   event_set(wakeup_event_, wakeup_pipe_out_, EV_READ | EV_PERSIST,
-            OnWakeup, this);
+	    OnWakeup, this);
   event_base_set(event_base_, wakeup_event_);
 
   if (event_add(wakeup_event_, 0))
@@ -108,56 +77,67 @@ MessagePumpLibevent::~MessagePumpLibevent() {
   event_base_free(event_base_);
 }
 
-bool MessagePumpLibevent::WatchFileDescriptor(int fd,
-                                              bool persistent,
-                                              Mode mode,
-                                              FileDescriptorWatcher *controller,
-                                              Watcher *delegate) {
-  DCHECK(fd > 0);
-  DCHECK(controller);
-  DCHECK(delegate);
-  DCHECK(mode == WATCH_READ || mode == WATCH_WRITE || mode == WATCH_READ_WRITE);
+void MessagePumpLibevent::WatchSocket(int socket, short interest_mask,
+                                      event* e, Watcher* watcher) {
 
-  int event_mask = persistent ? EV_PERSIST : 0;
-  if (mode == WATCH_READ || mode == WATCH_READ_WRITE) {
-    event_mask |= EV_READ;
-  }
-  if (mode == WATCH_WRITE || mode == WATCH_READ_WRITE) {
-    event_mask |= EV_WRITE;
-  }
-
-  // Ownership is transferred to the controller.
-  scoped_ptr<event> evt(new event);
-  // Set current interest mask and message pump for this event.
-  event_set(evt.get(), fd, event_mask | EV_READ, OnLibeventNotification,
-            delegate);
+  // Set current interest mask and message pump for this event
+  event_set(e, socket, interest_mask, OnReadinessNotification, watcher);
 
   // Tell libevent which message pump this socket will belong to when we add it.
-  if (event_base_set(event_base_, evt.get()) != 0) {
-    return false;
-  }
+  event_base_set(event_base_, e);
 
   // Add this socket to the list of monitored sockets.
-  if (event_add(evt.get(), NULL) != 0) {
-    return false;
+  if (event_add(e, NULL))
+    NOTREACHED();
+}
+
+void MessagePumpLibevent::WatchFileHandle(int fd, short interest_mask,
+                                          event* e, FileWatcher* watcher) {
+  // Set current interest mask and message pump for this event
+  if ((interest_mask & EV_READ) != 0) {
+    event_set(e, fd, interest_mask, OnFileReadReadinessNotification, watcher);
+  } else {
+    event_set(e, fd, interest_mask, OnFileWriteReadinessNotification, watcher);
   }
 
-  // Transfer ownership of e to controller.
-  controller->Init(evt.release(), persistent);
-  return true;
+  // Tell libevent which message pump this fd will belong to when we add it.
+  event_base_set(event_base_, e);
+
+  // Add this fd to the list of monitored sockets.
+  if (event_add(e, NULL))
+    NOTREACHED();
 }
 
+void MessagePumpLibevent::UnwatchSocket(event* e) {
+  // Remove this socket from the list of monitored sockets.
+  if (event_del(e))
+    NOTREACHED();
+}
+
+void MessagePumpLibevent::UnwatchFileHandle(event* e) {
+  // Remove this fd from the list of monitored fds.
+  if (event_del(e))
+    NOTREACHED();
+}
 
-void MessagePumpLibevent::OnLibeventNotification(int fd, short flags,
-                                                 void* context) {
+void MessagePumpLibevent::OnReadinessNotification(int socket, short flags,
+                                                  void* context) {
+  // The given socket is ready for I/O.
+  // Tell the owner what kind of I/O the socket is ready for.
   Watcher* watcher = static_cast<Watcher*>(context);
+  watcher->OnSocketReady(flags);
+}
 
-  if (flags & EV_WRITE) {
-    watcher->OnFileCanWriteWithoutBlocking(fd);
-  }
-  if (flags & EV_READ) {
-    watcher->OnFileCanReadWithoutBlocking(fd);
-  }
+void MessagePumpLibevent::OnFileReadReadinessNotification(int fd, short flags,
+                                                          void* context) {
+  FileWatcher* watcher = static_cast<FileWatcher*>(context);
+  watcher->OnFileReadReady(fd);
+}
+
+void MessagePumpLibevent::OnFileWriteReadinessNotification(int fd, short flags,
+                                                           void* context) {
+  FileWatcher* watcher = static_cast<FileWatcher*>(context);
+  watcher->OnFileWriteReady(fd);
 }
 
 // Reentrant!
diff --git a/base/message_pump_libevent.h b/base/message_pump_libevent.h
index 36475c1..b54bc36 100644
--- a/base/message_pump_libevent.h
+++ b/base/message_pump_libevent.h
@@ -6,7 +6,6 @@
 #define BASE_MESSAGE_PUMP_LIBEVENT_H_
 
 #include "base/message_pump.h"
-#include "base/scoped_ptr.h"
 #include "base/time.h"
 
 // Declare structs we need from libevent.h rather than including it
@@ -19,65 +18,46 @@ namespace base {
 // TODO(dkegel): add support for background file IO somehow
 class MessagePumpLibevent : public MessagePump {
  public:
-
-  // Object returned by WatchFileDescriptor to manage further watching.
-  class FileDescriptorWatcher {
-    public:
-     FileDescriptorWatcher();
-     ~FileDescriptorWatcher();  // Implicitly calls StopWatching.
-
-     // NOTE: These methods aren't called StartWatching()/StopWatching() to
-     // avoid confusion with the win32 ObjectWatcher class.
-
-     // Stop watching the FD, always safe to call.  No-op if there's nothing
-     // to do.
-     bool StopWatchingFileDescriptor();
-
-    private:
-     // Called by MessagePumpLibevent, ownership of |e| is transferred to this
-     // object.
-     // If this FileWatcher is already watching an event, the previous event is
-     // terminated and cleaned up here.
-     void Init(event* e, bool is_persistent);
-     friend class MessagePumpLibevent;
-
-    private:
-     bool is_persistent_;  // false if this event is one-shot.
-     scoped_ptr<event> event_;
-     DISALLOW_COPY_AND_ASSIGN(FileDescriptorWatcher);
-  };
-
-  // Used with WatchFileDescptor to asynchronously monitor the I/O readiness of
-  // a File Descriptor.
+  // Used with WatchSocket to asynchronously monitor the I/O readiness of a
+  // socket.
   class Watcher {
    public:
     virtual ~Watcher() {}
-    // Called from MessageLoop::Run when an FD can be read from/written to
-    // without blocking
-    virtual void OnFileCanReadWithoutBlocking(int fd) = 0;
-    virtual void OnFileCanWriteWithoutBlocking(int fd) = 0;
+    // Called from MessageLoop::Run when a ready socket is detected.
+    virtual void OnSocketReady(short eventmask) = 0;
+  };
+
+  // Used with WatchFileHandle to monitor I/O readiness for a File Handle.
+  class FileWatcher {
+   public:
+    virtual ~FileWatcher() {}
+    // Called from MessageLoop::Run when a non-blocking read/write can be made.
+    virtual void OnFileReadReady(int fd) = 0;
+    virtual void OnFileWriteReady(int fd) = 0;
   };
 
   MessagePumpLibevent();
   virtual ~MessagePumpLibevent();
 
-  enum Mode {
-    WATCH_READ,
-    WATCH_WRITE,
-    WATCH_READ_WRITE
-  };
-
-  // Have the current thread's message loop watch for a a situation in which
-  // reading/writing to the FD can be performed without Blocking.
-  // Callers must provide a preallocated FileDescriptorWatcher object which
-  // can later be used to manage the Lifetime of this event.
+  // Have the current thread's message loop watch for a ready socket.
+  // Caller must provide a struct event for this socket for libevent's use.
+  // The event and interest_mask fields are defined in libevent.
   // Returns true on success.
+  // TODO(dkegel): hide libevent better; abstraction still too leaky
+  // TODO(dkegel): better error handing
   // TODO(dkegel): switch to edge-triggered readiness notification
-  bool WatchFileDescriptor(int fd,
-                           bool persistent,
-                           Mode mode,
-                           FileDescriptorWatcher *controller,
-                           Watcher *delegate);
+  void WatchSocket(int socket, short interest_mask, event* e, Watcher*);
+
+  // TODO(playmobil): Merge this with WatchSocket().
+  void WatchFileHandle(int fd, short interest_mask, event* e, FileWatcher*);
+
+  // Stop watching a socket.
+  // Event was previously initialized by WatchSocket.
+  void UnwatchSocket(event* e);
+
+  // Stop watching a File Handle.
+  // Event was previously initialized by WatchFileHandle.
+  void UnwatchFileHandle(event* e);
 
   // MessagePump methods:
   virtual void Run(Delegate* delegate);
@@ -103,9 +83,14 @@ class MessagePumpLibevent : public MessagePump {
   // readiness callbacks when a socket is ready for I/O.
   event_base* event_base_;
 
-  // Called by libevent to tell us a registered FD can be read/written to.
-  static void OnLibeventNotification(int fd, short flags,
-                                     void* context);
+  // Called by libevent to tell us a registered socket is ready
+  static void OnReadinessNotification(int socket, short flags, void* context);
+
+  // Called by libevent to tell us a registered fd is ready.
+  static void OnFileReadReadinessNotification(int fd, short flags,
+                                              void* context);
+  static void OnFileWriteReadinessNotification(int fd, short flags,
+                                               void* context);
 
   // Unix pipe used to implement ScheduleWork()
   // ... callback; called by libevent inside Run() when pipe is ready to read