Refactor: Simplify WaitableEventWatcher.

base/synchronization/waitable_event_watcher_posix.cc

Index: base/synchronization/waitable_event_watcher_posix.cc
diff --git a/base/synchronization/waitable_event_watcher_posix.cc b/base/synchronization/waitable_event_watcher_posix.cc
index 3180b4bff413f9432e5fa1e62755770801cb80d8..99c83b5c40616a55e0f862ee2805789ee12eac55 100644
--- a/base/synchronization/waitable_event_watcher_posix.cc
+++ b/base/synchronization/waitable_event_watcher_posix.cc
@@ -97,14 +97,14 @@ class AsyncWaiter : public WaitableEvent::Waiter {
 // the event is canceled.
 // -----------------------------------------------------------------------------
 void AsyncCallbackHelper(Flag* flag,
-                         WaitableEventWatcher::Delegate* delegate,
+                         Callback<void(WaitableEvent*)>* callback,
                          WaitableEvent* event) {
   // Runs in MessageLoop thread.
   if (!flag->value()) {
     // This is to let the WaitableEventWatcher know that the event has occured
     // because it needs to be able to return NULL from GetWatchedObject
     flag->Set();
-    delegate->OnWaitableEventSignaled(event);
+    callback->Run(event);
   }
 }
 
@@ -112,8 +112,7 @@ WaitableEventWatcher::WaitableEventWatcher()
     : message_loop_(NULL),
       cancel_flag_(NULL),
       waiter_(NULL),
-      event_(NULL),
-      delegate_(NULL) {
+      event_(NULL) {
 }
 
 WaitableEventWatcher::~WaitableEventWatcher() {
@@ -125,7 +124,7 @@ WaitableEventWatcher::~WaitableEventWatcher() {
 // insure that the delegate cannot be called.
 // -----------------------------------------------------------------------------
 bool WaitableEventWatcher::StartWatching
-    (WaitableEvent* event, WaitableEventWatcher::Delegate* delegate) {
+    (WaitableEvent* event, Callback<void(WaitableEvent*)>* callback) {

[dmichael (off chromium), 2013/01/25 21:28:11]

nit: paren should be on the previous line.
extra tiny nit: I also prefer 1 param per line for declarations and definitions
if they don't fit on 1

[teravest, 2013/01/28 17:10:55]

Done.

   MessageLoop *const current_ml = MessageLoop::current();
   DCHECK(current_ml) << "Cannot create WaitableEventWatcher without a "
                         "current MessageLoop";
@@ -145,12 +144,13 @@ bool WaitableEventWatcher::StartWatching
   DCHECK(!cancel_flag_.get()) << "StartWatching called while still watching";
 
   cancel_flag_ = new Flag;
-  callback_ = base::Bind(&AsyncCallbackHelper, cancel_flag_, delegate, event);
+  internal_callback_ =
+      base::Bind(&AsyncCallbackHelper, cancel_flag_, callback, event);
   WaitableEvent::WaitableEventKernel* kernel = event->kernel_.get();
 
   AutoLock locked(kernel->lock_);
 
-  delegate_ = delegate;
+  callback_ = callback;
   event_ = event;
 
   if (kernel->signaled_) {
@@ -159,7 +159,7 @@ bool WaitableEventWatcher::StartWatching
 
     // No hairpinning - we can't call the delegate directly here. We have to
     // enqueue a task on the MessageLoop as normal.
-    current_ml->PostTask(FROM_HERE, callback_);
+    current_ml->PostTask(FROM_HERE, internal_callback_);
     return true;
   }
 
@@ -167,14 +167,14 @@ bool WaitableEventWatcher::StartWatching
   current_ml->AddDestructionObserver(this);
 
   kernel_ = kernel;
-  waiter_ = new AsyncWaiter(current_ml, callback_, cancel_flag_);
+  waiter_ = new AsyncWaiter(current_ml, internal_callback_, cancel_flag_);
   event->Enqueue(waiter_);
 
   return true;
 }
 
 void WaitableEventWatcher::StopWatching() {
-  delegate_ = NULL;
+  callback_ = NULL;
 
   if (message_loop_) {
     message_loop_->RemoveDestructionObserver(this);
@@ -227,7 +227,7 @@ void WaitableEventWatcher::StopWatching() {
     // have been enqueued with the MessageLoop because the waiter was never
     // signaled)
     delete waiter_;
-    callback_.Reset();
+    internal_callback_.Reset();
     cancel_flag_ = NULL;
     return;
   }