1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "mojo/public/cpp/environment/lib/default_async_waiter.h"
6
7 #include <assert.h>
8
9 #include "mojo/public/c/environment/async_waiter.h"
10 #include "mojo/public/cpp/utility/run_loop.h"
11 #include "mojo/public/cpp/utility/run_loop_handler.h"
12
13 namespace mojo {
14
15 namespace {
16
17 // RunLoopHandler implementation used for a request to AsyncWait(). There are
18 // two ways RunLoopHandlerImpl is deleted:
19 // . when the handle is ready (or errored).
20 // . when CancelWait() is invoked.
21 class RunLoopHandlerImpl : public RunLoopHandler {
22 public:
RunLoopHandlerImpl(const Handle & handle,MojoAsyncWaitCallback callback,void * closure)23 RunLoopHandlerImpl(const Handle& handle,
24 MojoAsyncWaitCallback callback,
25 void* closure)
26 : handle_(handle),
27 callback_(callback),
28 closure_(closure) {
29 }
30
~RunLoopHandlerImpl()31 virtual ~RunLoopHandlerImpl() {
32 RunLoop::current()->RemoveHandler(handle_);
33 }
34
35 // RunLoopHandler:
OnHandleReady(const Handle & handle)36 virtual void OnHandleReady(const Handle& handle) MOJO_OVERRIDE {
37 NotifyCallback(MOJO_RESULT_OK);
38 }
39
OnHandleError(const Handle & handle,MojoResult result)40 virtual void OnHandleError(const Handle& handle,
41 MojoResult result) MOJO_OVERRIDE {
42 NotifyCallback(result);
43 }
44
45 private:
NotifyCallback(MojoResult result)46 void NotifyCallback(MojoResult result) {
47 // Delete this to unregister the handle. That way if the callback
48 // reregisters everything is ok.
49 MojoAsyncWaitCallback callback = callback_;
50 void* closure = closure_;
51 delete this;
52
53 callback(closure, result);
54 }
55
56 const Handle handle_;
57 MojoAsyncWaitCallback callback_;
58 void* closure_;
59
60 MOJO_DISALLOW_COPY_AND_ASSIGN(RunLoopHandlerImpl);
61 };
62
AsyncWait(MojoHandle handle,MojoHandleSignals signals,MojoDeadline deadline,MojoAsyncWaitCallback callback,void * closure)63 MojoAsyncWaitID AsyncWait(MojoHandle handle,
64 MojoHandleSignals signals,
65 MojoDeadline deadline,
66 MojoAsyncWaitCallback callback,
67 void* closure) {
68 RunLoop* run_loop = RunLoop::current();
69 assert(run_loop);
70
71 // |run_loop_handler| is destroyed either when the handle is ready or if
72 // CancelWait is invoked.
73 RunLoopHandlerImpl* run_loop_handler =
74 new RunLoopHandlerImpl(Handle(handle), callback, closure);
75 run_loop->AddHandler(run_loop_handler, Handle(handle), signals, deadline);
76 return reinterpret_cast<MojoAsyncWaitID>(run_loop_handler);
77 }
78
CancelWait(MojoAsyncWaitID wait_id)79 void CancelWait(MojoAsyncWaitID wait_id) {
80 delete reinterpret_cast<RunLoopHandlerImpl*>(wait_id);
81 }
82
83 } // namespace
84
85 namespace internal {
86
87 const MojoAsyncWaiter kDefaultAsyncWaiter = {
88 AsyncWait,
89 CancelWait
90 };
91
92 } // namespace internal
93
94 } // namespace mojo
95