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

base/waitable_event_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.h"
 
 #include "base/condition_variable.h"
 #include "base/lock.h"
 #include "base/message_loop.h"
 
@@ skipping 17 matching lines @@
 // firing a waiter and so we can store that pointer to find out which event
 // triggered.
 // -----------------------------------------------------------------------------
 
 namespace base {
 
 // -----------------------------------------------------------------------------
 // This is just an abstract base class for waking the two types of waiters
 // -----------------------------------------------------------------------------
 WaitableEvent::WaitableEvent(bool manual_reset, bool initially_signaled)
-    : signaled_(false),
+    : signaled_(initially_signaled),
       manual_reset_(manual_reset) {
-  DCHECK(!initially_signaled) << "Not implemented";
 }
 
 WaitableEvent::~WaitableEvent() {
-  DCHECK(waiters_.empty()) << "Deleting WaitableEvent with listeners!";
+  if (!waiters_.empty()) {
+    LOG(ERROR) << "Destroying a WaitableEvent (" << this << ") with "
+               << waiters_.size() << " waiters";
+    NOTREACHED() << "Aborting.";
+  }
 }
 
 void WaitableEvent::Reset() {
   AutoLock locked(lock_);
   signaled_ = false;
 }
 
 void WaitableEvent::Signal() {
   AutoLock locked(lock_);
 
@@ skipping 26 matching lines @@
 // -----------------------------------------------------------------------------
 // This is an synchronous waiter. The thread is waiting on the given condition
 // variable and the fired flag in this object.
 // -----------------------------------------------------------------------------
 class SyncWaiter : public WaitableEvent::Waiter {
  public:
   SyncWaiter(ConditionVariable* cv, Lock* lock)
       : fired_(false),
         cv_(cv),
         lock_(lock),
-        signaling_event_(NULL) { }
+        signaling_event_(NULL) {
+  }
 
   bool Fire(WaitableEvent *signaling_event) {
     lock_->Acquire();
       const bool previous_value = fired_;
       fired_ = true;
       if (!previous_value)
         signaling_event_ = signaling_event;
     lock_->Release();
 
     if (previous_value)
@@ skipping 35 matching lines @@
 
  private:
   bool fired_;
   ConditionVariable *const cv_;
   Lock *const lock_;
   WaitableEvent* signaling_event_;  // The WaitableEvent which woke us
 };
 
 bool WaitableEvent::TimedWait(const TimeDelta& max_time) {
   const Time end_time(Time::Now() + max_time);
+  const bool finite_time = max_time.ToInternalValue() >= 0;
 
   lock_.Acquire();
     if (signaled_) {
       if (!manual_reset_) {
         // In this case we were signaled when we had no waiters. Now that
         // someone has waited upon us, we can automatically reset.
         signaled_ = false;
       }
 
       lock_.Release();
       return true;
     }
 
     Lock lock;
     lock.Acquire();
     ConditionVariable cv(&lock);
     SyncWaiter sw(&cv, &lock);
 
     Enqueue(&sw);
   lock_.Release();
   // We are violating locking order here by holding the SyncWaiter lock but not
   // the WaitableEvent lock. However, this is safe because we don't lock @lock_
   // again before unlocking it.
 
   for (;;) {
-    if (sw.fired()) {
+    const Time current_time(Time::Now());
+
+    if (sw.fired() || (finite_time && current_time >= end_time)) {
+      const bool return_value = sw.fired();
+
+      // We can't acquire @lock_ before releasing @lock (because of locking
+      // order), however, inbetween the two a signal could be fired and @sw
+      // would accept it, however we will still return false, so the signal
+      // would be lost on an auto-reset WaitableEvent. Thus we call Disable
+      // which makes sw::Fire return false.
+      sw.Disable();
       lock.Release();
-      return true;
+
+      lock_.Acquire();
+        Dequeue(&sw, &sw);
+      lock_.Release();
+
+      return return_value;
     }
 
-    if (max_time.ToInternalValue() < 0) {
+    if (finite_time) {
+      const TimeDelta max_wait(end_time - current_time);
+      cv.TimedWait(max_wait);
+    } else {
       cv.Wait();
-    } else {
-      const Time current_time(Time::Now());
-      if (current_time >= end_time) {
-        // We can't acquire @lock_ before releasing @lock (because of locking
-        // order), however, inbetween the two a signal could be fired and @sw
-        // would accept it, however we will still return false, so the signal
-        // would be lost on an auto-reset WaitableEvent. Thus we call Disable
-        // which makes sw::Fire return false.
-        sw.Disable();
-        lock.Release();
-
-        lock_.Acquire();
-          Dequeue(&sw, &sw);
-        lock_.Release();
-        return false;
-      }
-      const TimeDelta max_wait(end_time - current_time);
-
-      cv.TimedWait(max_wait);
     }
   }
 }
 
 bool WaitableEvent::Wait() {
   return TimedWait(TimeDelta::FromSeconds(-1));
 }
 
 // -----------------------------------------------------------------------------
 
@@ skipping 175 matching lines @@
       return true;
     }
   }
 
   return false;
 }
 
 // -----------------------------------------------------------------------------
 
 }  // namespace base