Disallow UI/IO thread blocking on any other thread.

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"
 #include "base/synchronization/lock.h"
-#include "base/logging.h"
+#include "base/threading/thread_restrictions.h"
 
 // -----------------------------------------------------------------------------
 // A WaitableEvent on POSIX is implemented as a wait-list. Currently we don't
 // support cross-process events (where one process can signal an event which
 // others are waiting on). Because of this, we can avoid having one thread per
 // listener in several cases.
 //
 // The WaitableEvent maintains a list of waiters, protected by a lock. Each
 // waiter is either an async wait, in which case we have a Task and the
 // MessageLoop to run it on, or a blocking wait, in which case we have the
@@ skipping 128 matching lines @@
   base::Lock lock_;
   base::ConditionVariable cv_;
 };
 
 void WaitableEvent::Wait() {
   bool result = TimedWait(TimeDelta::FromSeconds(-1));
   DCHECK(result) << "TimedWait() should never fail with infinite timeout";
 }
 
 bool WaitableEvent::TimedWait(const TimeDelta& max_time) {
+  base::ThreadRestrictions::AssertWaitAllowed();
   const Time end_time(Time::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;
     }
@@ skipping 46 matching lines @@
 
 static bool  // StrictWeakOrdering
 cmp_fst_addr(const std::pair<WaitableEvent*, unsigned> &a,
              const std::pair<WaitableEvent*, unsigned> &b) {
   return a.first < b.first;
 }
 
 // static
 size_t WaitableEvent::WaitMany(WaitableEvent** raw_waitables,
                                size_t count) {
+  base::ThreadRestrictions::AssertWaitAllowed();
   DCHECK(count) << "Cannot wait on no events";
 
   // We need to acquire the locks in a globally consistent order. Thus we sort
   // the array of waitables by address. We actually sort a pairs so that we can
   // map back to the original index values later.
   std::vector<std::pair<WaitableEvent*, size_t> > waitables;
   waitables.reserve(count);
   for (size_t i = 0; i < count; ++i)
     waitables.push_back(std::make_pair(raw_waitables[i], i));
 
@@ skipping 159 matching lines @@
       return true;
     }
   }
 
   return false;
 }
 
 // -----------------------------------------------------------------------------
 
 }  // namespace base