Blink roll 168661:148720
[chromium-blink-merge.git] / base / message_pump_glib.cc
blob7436558373e15fb604c725c5d9320e9f759ef132
1 // Copyright (c) 2012 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.
5 #include "base/message_pump_glib.h"
7 #include <fcntl.h>
8 #include <math.h>
10 #include <glib.h>
12 #include "base/logging.h"
13 #include "base/posix/eintr_wrapper.h"
14 #include "base/threading/platform_thread.h"
16 namespace {
18 // Return a timeout suitable for the glib loop, -1 to block forever,
19 // 0 to return right away, or a timeout in milliseconds from now.
20 int GetTimeIntervalMilliseconds(const base::TimeTicks& from) {
21 if (from.is_null())
22 return -1;
24 // Be careful here. TimeDelta has a precision of microseconds, but we want a
25 // value in milliseconds. If there are 5.5ms left, should the delay be 5 or
26 // 6? It should be 6 to avoid executing delayed work too early.
27 int delay = static_cast<int>(
28 ceil((from - base::TimeTicks::Now()).InMillisecondsF()));
30 // If this value is negative, then we need to run delayed work soon.
31 return delay < 0 ? 0 : delay;
34 // A brief refresher on GLib:
35 // GLib sources have four callbacks: Prepare, Check, Dispatch and Finalize.
36 // On each iteration of the GLib pump, it calls each source's Prepare function.
37 // This function should return TRUE if it wants GLib to call its Dispatch, and
38 // FALSE otherwise. It can also set a timeout in this case for the next time
39 // Prepare should be called again (it may be called sooner).
40 // After the Prepare calls, GLib does a poll to check for events from the
41 // system. File descriptors can be attached to the sources. The poll may block
42 // if none of the Prepare calls returned TRUE. It will block indefinitely, or
43 // by the minimum time returned by a source in Prepare.
44 // After the poll, GLib calls Check for each source that returned FALSE
45 // from Prepare. The return value of Check has the same meaning as for Prepare,
46 // making Check a second chance to tell GLib we are ready for Dispatch.
47 // Finally, GLib calls Dispatch for each source that is ready. If Dispatch
48 // returns FALSE, GLib will destroy the source. Dispatch calls may be recursive
49 // (i.e., you can call Run from them), but Prepare and Check cannot.
50 // Finalize is called when the source is destroyed.
51 // NOTE: It is common for subsytems to want to process pending events while
52 // doing intensive work, for example the flash plugin. They usually use the
53 // following pattern (recommended by the GTK docs):
54 // while (gtk_events_pending()) {
55 // gtk_main_iteration();
56 // }
58 // gtk_events_pending just calls g_main_context_pending, which does the
59 // following:
60 // - Call prepare on all the sources.
61 // - Do the poll with a timeout of 0 (not blocking).
62 // - Call check on all the sources.
63 // - *Does not* call dispatch on the sources.
64 // - Return true if any of prepare() or check() returned true.
66 // gtk_main_iteration just calls g_main_context_iteration, which does the whole
67 // thing, respecting the timeout for the poll (and block, although it is
68 // expected not to if gtk_events_pending returned true), and call dispatch.
70 // Thus it is important to only return true from prepare or check if we
71 // actually have events or work to do. We also need to make sure we keep
72 // internal state consistent so that if prepare/check return true when called
73 // from gtk_events_pending, they will still return true when called right
74 // after, from gtk_main_iteration.
76 // For the GLib pump we try to follow the Windows UI pump model:
77 // - Whenever we receive a wakeup event or the timer for delayed work expires,
78 // we run DoWork and/or DoDelayedWork. That part will also run in the other
79 // event pumps.
80 // - We also run DoWork, DoDelayedWork, and possibly DoIdleWork in the main
81 // loop, around event handling.
83 struct WorkSource : public GSource {
84 base::MessagePumpGlib* pump;
87 gboolean WorkSourcePrepare(GSource* source,
88 gint* timeout_ms) {
89 *timeout_ms = static_cast<WorkSource*>(source)->pump->HandlePrepare();
90 // We always return FALSE, so that our timeout is honored. If we were
91 // to return TRUE, the timeout would be considered to be 0 and the poll
92 // would never block. Once the poll is finished, Check will be called.
93 return FALSE;
96 gboolean WorkSourceCheck(GSource* source) {
97 // Only return TRUE if Dispatch should be called.
98 return static_cast<WorkSource*>(source)->pump->HandleCheck();
101 gboolean WorkSourceDispatch(GSource* source,
102 GSourceFunc unused_func,
103 gpointer unused_data) {
105 static_cast<WorkSource*>(source)->pump->HandleDispatch();
106 // Always return TRUE so our source stays registered.
107 return TRUE;
110 // I wish these could be const, but g_source_new wants non-const.
111 GSourceFuncs WorkSourceFuncs = {
112 WorkSourcePrepare,
113 WorkSourceCheck,
114 WorkSourceDispatch,
115 NULL
118 } // namespace
121 namespace base {
123 struct MessagePumpGlib::RunState {
124 Delegate* delegate;
125 MessagePumpDispatcher* dispatcher;
127 // Used to flag that the current Run() invocation should return ASAP.
128 bool should_quit;
130 // Used to count how many Run() invocations are on the stack.
131 int run_depth;
133 // This keeps the state of whether the pump got signaled that there was new
134 // work to be done. Since we eat the message on the wake up pipe as soon as
135 // we get it, we keep that state here to stay consistent.
136 bool has_work;
139 MessagePumpGlib::MessagePumpGlib()
140 : state_(NULL),
141 context_(g_main_context_default()),
142 wakeup_gpollfd_(new GPollFD) {
143 // Create our wakeup pipe, which is used to flag when work was scheduled.
144 int fds[2];
145 int ret = pipe(fds);
146 DCHECK_EQ(ret, 0);
147 (void)ret; // Prevent warning in release mode.
149 wakeup_pipe_read_ = fds[0];
150 wakeup_pipe_write_ = fds[1];
151 wakeup_gpollfd_->fd = wakeup_pipe_read_;
152 wakeup_gpollfd_->events = G_IO_IN;
154 work_source_ = g_source_new(&WorkSourceFuncs, sizeof(WorkSource));
155 static_cast<WorkSource*>(work_source_)->pump = this;
156 g_source_add_poll(work_source_, wakeup_gpollfd_.get());
157 // Use a low priority so that we let other events in the queue go first.
158 g_source_set_priority(work_source_, G_PRIORITY_DEFAULT_IDLE);
159 // This is needed to allow Run calls inside Dispatch.
160 g_source_set_can_recurse(work_source_, TRUE);
161 g_source_attach(work_source_, context_);
164 void MessagePumpGlib::RunWithDispatcher(Delegate* delegate,
165 MessagePumpDispatcher* dispatcher) {
166 #ifndef NDEBUG
167 // Make sure we only run this on one thread. X/GTK only has one message pump
168 // so we can only have one UI loop per process.
169 static base::PlatformThreadId thread_id = base::PlatformThread::CurrentId();
170 DCHECK(thread_id == base::PlatformThread::CurrentId()) <<
171 "Running MessagePumpGlib on two different threads; "
172 "this is unsupported by GLib!";
173 #endif
175 RunState state;
176 state.delegate = delegate;
177 state.dispatcher = dispatcher;
178 state.should_quit = false;
179 state.run_depth = state_ ? state_->run_depth + 1 : 1;
180 state.has_work = false;
182 RunState* previous_state = state_;
183 state_ = &state;
185 // We really only do a single task for each iteration of the loop. If we
186 // have done something, assume there is likely something more to do. This
187 // will mean that we don't block on the message pump until there was nothing
188 // more to do. We also set this to true to make sure not to block on the
189 // first iteration of the loop, so RunUntilIdle() works correctly.
190 bool more_work_is_plausible = true;
192 // We run our own loop instead of using g_main_loop_quit in one of the
193 // callbacks. This is so we only quit our own loops, and we don't quit
194 // nested loops run by others. TODO(deanm): Is this what we want?
195 for (;;) {
196 // Don't block if we think we have more work to do.
197 bool block = !more_work_is_plausible;
199 more_work_is_plausible = g_main_context_iteration(context_, block);
200 if (state_->should_quit)
201 break;
203 more_work_is_plausible |= state_->delegate->DoWork();
204 if (state_->should_quit)
205 break;
207 more_work_is_plausible |=
208 state_->delegate->DoDelayedWork(&delayed_work_time_);
209 if (state_->should_quit)
210 break;
212 if (more_work_is_plausible)
213 continue;
215 more_work_is_plausible = state_->delegate->DoIdleWork();
216 if (state_->should_quit)
217 break;
220 state_ = previous_state;
223 // Return the timeout we want passed to poll.
224 int MessagePumpGlib::HandlePrepare() {
225 // We know we have work, but we haven't called HandleDispatch yet. Don't let
226 // the pump block so that we can do some processing.
227 if (state_ && // state_ may be null during tests.
228 state_->has_work)
229 return 0;
231 // We don't think we have work to do, but make sure not to block
232 // longer than the next time we need to run delayed work.
233 return GetTimeIntervalMilliseconds(delayed_work_time_);
236 bool MessagePumpGlib::HandleCheck() {
237 if (!state_) // state_ may be null during tests.
238 return false;
240 // We usually have a single message on the wakeup pipe, since we are only
241 // signaled when the queue went from empty to non-empty, but there can be
242 // two messages if a task posted a task, hence we read at most two bytes.
243 // The glib poll will tell us whether there was data, so this read
244 // shouldn't block.
245 if (wakeup_gpollfd_->revents & G_IO_IN) {
246 char msg[2];
247 const int num_bytes = HANDLE_EINTR(read(wakeup_pipe_read_, msg, 2));
248 if (num_bytes < 1) {
249 NOTREACHED() << "Error reading from the wakeup pipe.";
251 DCHECK((num_bytes == 1 && msg[0] == '!') ||
252 (num_bytes == 2 && msg[0] == '!' && msg[1] == '!'));
253 // Since we ate the message, we need to record that we have more work,
254 // because HandleCheck() may be called without HandleDispatch being called
255 // afterwards.
256 state_->has_work = true;
259 if (state_->has_work)
260 return true;
262 if (GetTimeIntervalMilliseconds(delayed_work_time_) == 0) {
263 // The timer has expired. That condition will stay true until we process
264 // that delayed work, so we don't need to record this differently.
265 return true;
268 return false;
271 void MessagePumpGlib::HandleDispatch() {
272 state_->has_work = false;
273 if (state_->delegate->DoWork()) {
274 // NOTE: on Windows at this point we would call ScheduleWork (see
275 // MessagePumpGlib::HandleWorkMessage in message_pump_win.cc). But here,
276 // instead of posting a message on the wakeup pipe, we can avoid the
277 // syscalls and just signal that we have more work.
278 state_->has_work = true;
281 if (state_->should_quit)
282 return;
284 state_->delegate->DoDelayedWork(&delayed_work_time_);
287 void MessagePumpGlib::AddObserver(MessagePumpObserver* observer) {
288 observers_.AddObserver(observer);
291 void MessagePumpGlib::RemoveObserver(MessagePumpObserver* observer) {
292 observers_.RemoveObserver(observer);
295 void MessagePumpGlib::Run(Delegate* delegate) {
296 RunWithDispatcher(delegate, NULL);
299 void MessagePumpGlib::Quit() {
300 if (state_) {
301 state_->should_quit = true;
302 } else {
303 NOTREACHED() << "Quit called outside Run!";
307 void MessagePumpGlib::ScheduleWork() {
308 // This can be called on any thread, so we don't want to touch any state
309 // variables as we would then need locks all over. This ensures that if
310 // we are sleeping in a poll that we will wake up.
311 char msg = '!';
312 if (HANDLE_EINTR(write(wakeup_pipe_write_, &msg, 1)) != 1) {
313 NOTREACHED() << "Could not write to the UI message loop wakeup pipe!";
317 void MessagePumpGlib::ScheduleDelayedWork(const TimeTicks& delayed_work_time) {
318 // We need to wake up the loop in case the poll timeout needs to be
319 // adjusted. This will cause us to try to do work, but that's ok.
320 delayed_work_time_ = delayed_work_time;
321 ScheduleWork();
324 MessagePumpGlib::~MessagePumpGlib() {
325 g_source_destroy(work_source_);
326 g_source_unref(work_source_);
327 close(wakeup_pipe_read_);
328 close(wakeup_pipe_write_);
331 MessagePumpDispatcher* MessagePumpGlib::GetDispatcher() {
332 return state_ ? state_->dispatcher : NULL;
335 } // namespace base