Make sure that WaitableEvent::TimedWait works fine with large timeouts.

base/synchronization/waitable_event_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 <algorithm>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/synchronization/condition_variable.h"
@@ skipping 133 matching lines @@
   }
 
  private:
   bool fired_;
   WaitableEvent* signaling_event_;  // The WaitableEvent which woke us
   base::Lock lock_;
   base::ConditionVariable cv_;
 };
 
 void WaitableEvent::Wait() {
-  bool result = TimedWait(TimeDelta::FromSeconds(-1));
+  bool result = TimedWait(TimeDelta::Max());
   DCHECK(result) << "TimedWait() should never fail with infinite timeout";
 }
 
 bool WaitableEvent::TimedWait(const TimeDelta& max_time) {
+  DCHECK(max_time >= TimeDelta());

[Lei Zhang, 2015/03/25 01:36:27]

Can we use DCHECK_GE() in both impls?

Also mention this in the header.

[rvargas (doing something else), 2015/03/26 19:37:27]

Done.

   base::ThreadRestrictions::AssertWaitAllowed();
   const TimeTicks end_time(TimeTicks::Now() + max_time);
-  const bool finite_time = max_time.ToInternalValue() >= 0;
 
   kernel_->lock_.Acquire();
   if (kernel_->signaled_) {
     if (!kernel_->manual_reset_) {
       // In this case we were signaled when we had no waiters. Now that
       // someone has waited upon us, we can automatically reset.
       kernel_->signaled_ = false;
     }
 
     kernel_->lock_.Release();
     return true;
   }
 
   SyncWaiter sw;
   sw.lock()->Acquire();
 
   Enqueue(&sw);
   kernel_->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 (;;) {
     const TimeTicks current_time(TimeTicks::Now());
 
-    if (sw.fired() || (finite_time && current_time >= end_time)) {
+    if (sw.fired() || current_time >= end_time) {
       const bool return_value = sw.fired();
 
       // We can't acquire @lock_ before releasing the SyncWaiter lock (because
       // of locking order), however, in between 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();
       sw.lock()->Release();
 
       // This is a bug that has been enshrined in the interface of
       // WaitableEvent now: |Dequeue| is called even when |sw.fired()| is true,
       // even though it'll always return false in that case. However, taking
       // the lock ensures that |Signal| has completed before we return and
       // means that a WaitableEvent can synchronise its own destruction.
       kernel_->lock_.Acquire();
       kernel_->Dequeue(&sw, &sw);
       kernel_->lock_.Release();
 
       return return_value;
     }
 
-    if (finite_time) {
-      const TimeDelta max_wait(end_time - current_time);
-      sw.cv()->TimedWait(max_wait);
-    } else {
-      sw.cv()->Wait();
-    }
+    sw.cv()->TimedWait(end_time - current_time);
   }
 }
 
 // -----------------------------------------------------------------------------
 // Synchronous waiting on multiple objects.
 
 static bool  // StrictWeakOrdering
 cmp_fst_addr(const std::pair<WaitableEvent*, unsigned> &a,
              const std::pair<WaitableEvent*, unsigned> &b) {
   return a.first < b.first;
@@ skipping 180 matching lines @@
       return true;
     }
   }
 
   return false;
 }
 
 // -----------------------------------------------------------------------------
 
 }  // namespace base