Mac/Linux test fixes: hopefully this will fix some flakey tests

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 62 matching lines @@
     // We can always return true because an AsyncWaiter is never in two
     // different wait-lists at the same time.
     return true;
   }
 
   // See StopWatching for discussion
   bool Compare(void* tag) {
     return tag == flag_.get();
   }
 
+ private:
   MessageLoop *const message_loop_;
   Task *const cb_task_;
   scoped_refptr<Flag> flag_;
 };
 
 // -----------------------------------------------------------------------------
 // For async waits we need to make a callback in a MessageLoop thread. We do
 // this by posting this task, which calls the delegate and keeps track of when
 // the event is canceled.
 // -----------------------------------------------------------------------------
 class AsyncCallbackTask : public Task {
  public:
   AsyncCallbackTask(Flag* flag, WaitableEventWatcher::Delegate* delegate,
                     WaitableEvent* event)
       : flag_(flag),
         delegate_(delegate),
         event_(event) {
   }
 
   void Run() {
     // Runs in MessageLoop thread.
-    if (!flag_->value())
+    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_);
-
-    // This is to let the WaitableEventWatcher know that the event has occured
-    // because it needs to be able to return NULL from GetWatchedEvent
-    flag_->Set();
+    }
 
     // We are deleted by the MessageLoop
   }
 
  private:
   scoped_refptr<Flag> flag_;
   WaitableEventWatcher::Delegate *const delegate_;
   WaitableEvent *const event_;
 };
 
@@ skipping 11 matching lines @@
 // -----------------------------------------------------------------------------
 // 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) {
   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 AsyncCallbackTask::Run()
+  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_task_ = new AsyncCallbackTask(cancel_flag_, delegate, event);
 
   AutoLock locked(event->lock_);
 
   if (event->signaled_) {
     if (!event->manual_reset_)
       event->signaled_ = false;
@@ skipping 16 matching lines @@
 
 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
     // 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();
@@ skipping 57 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