| /external/chromium_org/mojo/system/ |
| waiter.h | 19 // IMPORTANT (all-caps gets your attention, right?): |Waiter| methods are called
20 // under other locks, in particular, |Dispatcher::lock_|s, so |Waiter| methods
23 class MOJO_SYSTEM_IMPL_EXPORT Waiter {
25 Waiter();
26 ~Waiter();
28 // A |Waiter| can be used multiple times; |Init()| should be called before
58 // Wake the waiter up with the given result and context (or no-op if it's been
75 DISALLOW_COPY_AND_ASSIGN(Waiter);
|
| waiter_list.h | 19 class Waiter;
22 // |WaiterList| tracks all the |Waiter|s that are waiting on a given
36 void AddWaiter(Waiter* waiter, MojoHandleSignals signals, uint32_t context);
37 void RemoveWaiter(Waiter* waiter);
41 WaiterInfo(Waiter* waiter, MojoHandleSignals signals, uint32_t context)
42 : waiter(waiter), signals(signals), context(context) {
44 Waiter* waiter; member in struct:mojo::system::WaiterList::WaiterInfo
[all...] |
| simple_dispatcher.h | 21 // in core.cc). This class implements the standard waiter-signalling mechanism
38 virtual MojoResult AddWaiterImplNoLock(Waiter* waiter,
41 virtual void RemoveWaiterImplNoLock(Waiter* waiter) OVERRIDE;
|
| waiter.cc | 5 #include "mojo/system/waiter.h"
15 Waiter::Waiter()
25 Waiter::~Waiter() {
28 void Waiter::Init() {
39 MojoResult Waiter::Wait(MojoDeadline deadline, uint32_t* context) {
84 void Waiter::Awake(MojoResult result, uint32_t context) {
|
| message_pipe_endpoint.h | 25 class Waiter;
69 virtual MojoResult AddWaiter(Waiter* waiter,
72 virtual void RemoveWaiter(Waiter* waiter);
|
| waiter_test_utils.h | 16 #include "mojo/system/waiter.h"
22 // This is a very simple thread that has a |Waiter|, on which it waits
24 // |Waiter| on creation, but the caller must start the thread with |Start()|. It
33 // waiter_list.AddWaiter(thread.waiter(), ...);
35 // ... some stuff to wake the waiter ...
36 // waiter_list.RemoveWaiter(thread.waiter());
41 // |Waiter::Init()|, |AddWaiter()|, and |RemoveWaiter()| are done in the main
42 // (test) thread, not the waiter thread (as would actually happen in real code).
53 Waiter* waiter() { return &waiter_; function in class:mojo::system::test::SimpleWaiterThread
[all...] |
| message_pipe_endpoint.cc | 30 MojoResult MessagePipeEndpoint::AddWaiter(Waiter* /*waiter*/,
37 void MessagePipeEndpoint::RemoveWaiter(Waiter* /*waiter*/) {
|
| simple_dispatcher.cc | 28 MojoResult SimpleDispatcher::AddWaiterImplNoLock(Waiter* waiter,
39 waiter_list_.AddWaiter(waiter, signals, context);
43 void SimpleDispatcher::RemoveWaiterImplNoLock(Waiter* waiter) {
45 waiter_list_.RemoveWaiter(waiter);
|
| data_pipe_consumer_dispatcher.h | 47 virtual MojoResult AddWaiterImplNoLock(Waiter* waiter,
50 virtual void RemoveWaiterImplNoLock(Waiter* waiter) OVERRIDE;
|
| data_pipe_producer_dispatcher.h | 49 virtual MojoResult AddWaiterImplNoLock(Waiter* waiter,
52 virtual void RemoveWaiterImplNoLock(Waiter* waiter) OVERRIDE;
|
| local_message_pipe_endpoint.h | 39 virtual MojoResult AddWaiter(Waiter* waiter,
42 virtual void RemoveWaiter(Waiter* waiter) OVERRIDE;
|
| message_pipe.h | 27 class Waiter;
68 Waiter* waiter,
71 void RemoveWaiter(unsigned port, Waiter* waiter);
|
| waiter_list.cc | 9 #include "mojo/system/waiter.h"
25 it->waiter->Awake(MOJO_RESULT_OK, it->context);
27 it->waiter->Awake(MOJO_RESULT_FAILED_PRECONDITION, it->context);
34 it->waiter->Awake(MOJO_RESULT_CANCELLED, it->context);
39 void WaiterList::AddWaiter(Waiter* waiter,
42 waiters_.push_back(WaiterInfo(waiter, signals, context));
45 void WaiterList::RemoveWaiter(Waiter* waiter) {
47 // so we need to scan the entire list and remove all occurrences of |waiter|
[all...] |
| data_pipe.h | 22 class Waiter;
62 MojoResult ProducerAddWaiter(Waiter* waiter,
65 void ProducerRemoveWaiter(Waiter* waiter);
85 MojoResult ConsumerAddWaiter(Waiter* waiter,
88 void ConsumerRemoveWaiter(Waiter* waiter);
|
| data_pipe_producer_dispatcher.cc | 91 Waiter* waiter,
95 return data_pipe_->ProducerAddWaiter(waiter, signals, context);
98 void DataPipeProducerDispatcher::RemoveWaiterImplNoLock(Waiter* waiter) {
100 data_pipe_->ProducerRemoveWaiter(waiter);
|
| message_pipe_dispatcher.h | 91 virtual MojoResult AddWaiterImplNoLock(Waiter* waiter,
94 virtual void RemoveWaiterImplNoLock(Waiter* waiter) OVERRIDE;
|
| dispatcher.h | 37 class Waiter;
119 // Adds a waiter to this dispatcher. The waiter will be woken up when this
125 // - |MOJO_RESULT_OK| if the waiter was added;
130 MojoResult AddWaiter(Waiter* waiter,
133 void RemoveWaiter(Waiter* waiter);
246 virtual MojoResult AddWaiterImplNoLock(Waiter* waiter,
[all...] |
| data_pipe_consumer_dispatcher.cc | 112 Waiter* waiter,
116 return data_pipe_->ConsumerAddWaiter(waiter, signals, context);
119 void DataPipeConsumerDispatcher::RemoveWaiterImplNoLock(Waiter* waiter) {
121 data_pipe_->ConsumerRemoveWaiter(waiter);
|
| local_message_pipe_endpoint.cc | 130 MojoResult LocalMessagePipeEndpoint::AddWaiter(Waiter* waiter,
141 waiter_list_.AddWaiter(waiter, signals, context);
145 void LocalMessagePipeEndpoint::RemoveWaiter(Waiter* waiter) {
147 waiter_list_.RemoveWaiter(waiter);
|
| data_pipe.cc | 180 MojoResult DataPipe::ProducerAddWaiter(Waiter* waiter,
192 producer_waiter_list_->AddWaiter(waiter, signals, context);
196 void DataPipe::ProducerRemoveWaiter(Waiter* waiter) {
199 producer_waiter_list_->RemoveWaiter(waiter);
333 MojoResult DataPipe::ConsumerAddWaiter(Waiter* waiter,
345 consumer_waiter_list_->AddWaiter(waiter, signals, context);
349 void DataPipe::ConsumerRemoveWaiter(Waiter* waiter)
[all...] |
| /external/chromium_org/base/synchronization/ |
| waitable_event.h | 102 class Waiter {
104 // Signal the waiter to wake up.
106 // Consider the case of a Waiter which is in multiple WaitableEvent's
108 // signaled at the same time. Now, each will wake only the first waiter in
111 // to dequeue the waiter from the other wait-list in time), two auto-resets
112 // will have happened, but only one waiter has been signaled!
114 // Because of this, a Waiter may "reject" a wake by returning false. In
126 virtual ~Waiter() {}
148 bool Dequeue(Waiter* waiter, void* tag)
[all...] |
| waitable_event_posix.cc | 21 // waiter is either an async wait, in which case we have a Task and the
31 // firing a waiter and so we can store that pointer to find out which event
82 // This is a synchronous waiter. The thread is waiting on the given condition
85 class SyncWaiter : public WaitableEvent::Waiter {
262 // enqueued our waiter in them all.
302 // The locks of the WaitableEvents have been taken in order and the Waiter has
306 // None of the WaitableEvent locks are held. The Waiter has not been enqueued
313 size_t count, Waiter* waiter) {
325 const size_t r = EnqueueMany(waitables + 1, count - 1, waiter);
[all...] |
| /external/chromium_org/chrome/browser/chromeos/login/lock/ |
| screen_locker_browsertest.cc | 43 class Waiter : public content::NotificationObserver {
45 explicit Waiter(Browser* browser)
56 virtual ~Waiter() {
89 DISALLOW_COPY_AND_ASSIGN(Waiter);
191 Waiter waiter(browser());
193 waiter.Wait(false /* not locked */, true /* full screen */);
199 Waiter waiter(browser());
202 waiter.Wait(true /* locked */, true /* full screen */)
[all...] |
| /external/chromium_org/chrome/browser/extensions/ |
| extension_gcm_app_handler_unittest.cc | 73 class Waiter {
75 Waiter() {}
76 ~Waiter() {}
100 base::Bind(&Waiter::OnIOLoopPump, base::Unretained(this)));
118 base::Bind(&Waiter::OnIOLoopPumpCompleted, base::Unretained(this)));
127 base::Bind(&Waiter::PumpIOLoopCompleted, base::Unretained(this)));
132 DISALLOW_COPY_AND_ASSIGN(Waiter);
137 FakeExtensionGCMAppHandler(Profile* profile, Waiter* waiter)
139 waiter_(waiter),
373 Waiter* waiter() { return &waiter_; } function in class:extensions::ExtensionGCMAppHandlerTest
[all...] |
| /libcore/luni/src/test/java/libcore/java/lang/ |
| OldAndroidMonitorTest.java | 106 Waiter waiter; field in class:OldAndroidMonitorTest.Interrupter
108 Interrupter(String name, Waiter waiter) {
110 this.waiter = waiter;
123 waiter.spin = true;
124 // System.out.println("InterruptTest: starting waiter");
125 waiter.start();
133 /* Waiter is spinning, and its monitor should still be thin
273 Waiter waiter = new Waiter("InterruptTest Waiter"); local
[all...] |
