Refactor: Simplify WaitableEventWatcher.

base/synchronization/waitable_event_watcher_posix.cc

 // Copyright (c) 2012 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 "base/synchronization/waitable_event_watcher.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/message_loop.h"
 #include "base/synchronization/lock.h"
@@ skipping 79 matching lines @@
   base::Closure callback_;
   scoped_refptr<Flag> flag_;
 };
 
 // -----------------------------------------------------------------------------
 // For async waits we need to make a callback in a MessageLoop thread. We do
 // this by posting a callback, which calls the delegate and keeps track of when
 // the event is canceled.
 // -----------------------------------------------------------------------------
 void AsyncCallbackHelper(Flag* flag,
-                         WaitableEventWatcher::Delegate* delegate,
+                         const WaitableEventWatcher::EventCallback& 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);
   }
 }
 
 WaitableEventWatcher::WaitableEventWatcher()
     : message_loop_(NULL),
       cancel_flag_(NULL),
       waiter_(NULL),
-      event_(NULL),
-      delegate_(NULL) {
+      event_(NULL) {
 }
 
 WaitableEventWatcher::~WaitableEventWatcher() {
   StopWatching();
 }
 
 // -----------------------------------------------------------------------------
 // The Handle is how the user cancels a wait. After deleting the Handle we
 // insure that the delegate cannot be called.
 // -----------------------------------------------------------------------------
-bool WaitableEventWatcher::StartWatching
-    (WaitableEvent* event, WaitableEventWatcher::Delegate* delegate) {
+bool WaitableEventWatcher::StartWatching(
+    WaitableEvent* event,
+    const EventCallback& callback) {
   MessageLoop *const current_ml = MessageLoop::current();
   DCHECK(current_ml) << "Cannot create WaitableEventWatcher without a "
                         "current MessageLoop";
 
   // A user may call StartWatching from within the callback function. In this
   // case, we won't know that we have finished watching, expect that the Flag
   // will have been set in AsyncCallbackHelper().
   if (cancel_flag_.get() && cancel_flag_->value()) {
     if (message_loop_) {
       message_loop_->RemoveDestructionObserver(this);
       message_loop_ = NULL;
     }
 
     cancel_flag_ = NULL;
   }
 
   DCHECK(!cancel_flag_.get()) << "StartWatching called while still watching";
 
   cancel_flag_ = new Flag;
-  callback_ = base::Bind(&AsyncCallbackHelper, cancel_flag_, delegate, event);
+  callback_ = callback;
+  internal_callback_ =
+      base::Bind(&AsyncCallbackHelper, cancel_flag_, callback_, event);
   WaitableEvent::WaitableEventKernel* kernel = event->kernel_.get();
 
   AutoLock locked(kernel->lock_);
 
-  delegate_ = delegate;
   event_ = event;
 
   if (kernel->signaled_) {
     if (!kernel->manual_reset_)
       kernel->signaled_ = false;
 
     // 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;
   }
 
   message_loop_ = current_ml;
   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_.Reset();
 
   if (message_loop_) {
     message_loop_->RemoveDestructionObserver(this);
     message_loop_ = NULL;
   }
 
   if (!cancel_flag_.get())  // if not currently watching...
     return;
 
   if (cancel_flag_->value()) {
@@ skipping 32 matching lines @@
   // a tag which is good for the lifetime of this handle: the Flag. Since we
   // have a reference to the Flag, its memory cannot be reused while this object
   // still exists. So if we find a waiter with the correct pointer value, and
   // which shares a Flag pointer, we have a real match.
   if (kernel_->Dequeue(waiter_, cancel_flag_.get())) {
     // Case 2: the waiter hasn't been signaled yet; it was still on the wait
     // list. We've removed it, thus we can delete it and the task (which cannot
     // have been enqueued with the MessageLoop because the waiter was never
     // signaled)
     delete waiter_;
-    callback_.Reset();
+    internal_callback_.Reset();
     cancel_flag_ = NULL;
     return;
   }
 
   // Case 3: the waiter isn't on the wait-list, thus it was signaled. It may
   // not have run yet, so we set the flag to tell it not to bother enqueuing the
   // task on the MessageLoop, but to delete it instead. The Waiter deletes
   // itself once run.
   cancel_flag_->Set();
   cancel_flag_ = NULL;
@@ skipping 20 matching lines @@
 // -----------------------------------------------------------------------------
 // This is called when the MessageLoop which the callback will be run it is
 // deleted. We need to cancel the callback as if we had been deleted, but we
 // will still be deleted at some point in the future.
 // -----------------------------------------------------------------------------
 void WaitableEventWatcher::WillDestroyCurrentMessageLoop() {
   StopWatching();
 }
 
 }  // namespace base