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