POSIX: allow WaitableEvents to be deleted while watching them.

base/waitable_event_watcher_posix.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 "base/waitable_event_watcher.h"
 
 #include "base/condition_variable.h"
 #include "base/lock.h"
 #include "base/message_loop.h"
 #include "base/waitable_event.h"
@@ skipping 137 matching lines @@
       message_loop_ = NULL;
     }
 
     cancel_flag_ = NULL;
   }
 
   DCHECK(!cancel_flag_.get()) << "StartWatching called while still watching";
 
   cancel_flag_ = new Flag;
   callback_task_ = new AsyncCallbackTask(cancel_flag_, delegate, event);
+  WaitableEvent::WaitableEventKernel* kernel = event->kernel_.get();
 
-  AutoLock locked(event->lock_);
+  AutoLock locked(kernel->lock_);
 
-  if (event->signaled_) {
-    if (!event->manual_reset_)
-      event->signaled_ = false;
+  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_task_);
     return true;
   }
 
   message_loop_ = current_ml;
   current_ml->AddDestructionObserver(this);
 
   event_ = event;
+  kernel_ = kernel;
   waiter_ = new AsyncWaiter(current_ml, callback_task_, cancel_flag_);
   event->Enqueue(waiter_);
 
   return true;
 }
 
 void WaitableEventWatcher::StopWatching() {
   if (message_loop_) {
     message_loop_->RemoveDestructionObserver(this);
     message_loop_ = NULL;
   }
 
   if (!cancel_flag_.get())  // if not currently watching...
     return;
 
   if (cancel_flag_->value()) {
     // In this case, the event has fired, but we haven't figured that out yet.
     // The WaitableEvent may have been deleted too.
     cancel_flag_ = NULL;
     return;
   }
 
-  if (!event_) {
-    // We have no WaitableEvent. This means that we never enqueued a Waiter on
-    // an event because the event was already signaled when StartWatching was
+  if (!kernel_.get()) {
+    // We have no kernel. This means that we never enqueued a Waiter on an
+    // event because the event was already signaled when StartWatching was
     // called.
     //
     // In this case, a task was enqueued on the MessageLoop and will run.
     // We set the flag in case the task hasn't yet run. The flag will stop the
     // delegate getting called. If the task has run then we have the last
     // reference to the flag and it will be deleted immedately after.
     cancel_flag_->Set();
     cancel_flag_ = NULL;
     return;
   }
 
-  AutoLock locked(event_->lock_);
-  // We have a lock on the WaitableEvent. No one else can signal the event while
-  // we have it.
+  AutoLock locked(kernel_->lock_);
+  // We have a lock on the kernel. No one else can signal the event while we
+  // have it.
 
   // We have a possible ABA issue here. If Dequeue was to compare only the
   // pointer values then it's possible that the AsyncWaiter could have been
   // fired, freed and the memory reused for a different Waiter which was
   // enqueued in the same wait-list. We would think that that waiter was our
   // AsyncWaiter and remove it.
   //
   // To stop this, Dequeue also takes a tag argument which is passed to the
   // virtual Compare function before the two are considered a match. So we need
   // 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 (event_->Dequeue(waiter_, cancel_flag_.get())) {
+  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_;
     delete callback_task_;
     cancel_flag_ = NULL;
     return;
   }
 
@@ skipping 26 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