OLD | NEW |
| (Empty) |
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. | |
4 | |
5 #include "base/message_pump_glib.h" | |
6 | |
7 #include <fcntl.h> | |
8 #include <math.h> | |
9 | |
10 #include <glib.h> | |
11 | |
12 #include "base/logging.h" | |
13 #include "base/posix/eintr_wrapper.h" | |
14 #include "base/threading/platform_thread.h" | |
15 | |
16 namespace { | |
17 | |
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; | |
23 | |
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())); | |
29 | |
30 // If this value is negative, then we need to run delayed work soon. | |
31 return delay < 0 ? 0 : delay; | |
32 } | |
33 | |
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 // } | |
57 // | |
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. | |
65 // | |
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. | |
69 // | |
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. | |
75 // | |
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. | |
82 | |
83 struct WorkSource : public GSource { | |
84 base::MessagePumpGlib* pump; | |
85 }; | |
86 | |
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; | |
94 } | |
95 | |
96 gboolean WorkSourceCheck(GSource* source) { | |
97 // Only return TRUE if Dispatch should be called. | |
98 return static_cast<WorkSource*>(source)->pump->HandleCheck(); | |
99 } | |
100 | |
101 gboolean WorkSourceDispatch(GSource* source, | |
102 GSourceFunc unused_func, | |
103 gpointer unused_data) { | |
104 | |
105 static_cast<WorkSource*>(source)->pump->HandleDispatch(); | |
106 // Always return TRUE so our source stays registered. | |
107 return TRUE; | |
108 } | |
109 | |
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 | |
116 }; | |
117 | |
118 } // namespace | |
119 | |
120 | |
121 namespace base { | |
122 | |
123 struct MessagePumpGlib::RunState { | |
124 Delegate* delegate; | |
125 MessagePumpDispatcher* dispatcher; | |
126 | |
127 // Used to flag that the current Run() invocation should return ASAP. | |
128 bool should_quit; | |
129 | |
130 // Used to count how many Run() invocations are on the stack. | |
131 int run_depth; | |
132 | |
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; | |
137 }; | |
138 | |
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. | |
148 | |
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; | |
153 | |
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_); | |
162 } | |
163 | |
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 | |
174 | |
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; | |
181 | |
182 RunState* previous_state = state_; | |
183 state_ = &state; | |
184 | |
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; | |
191 | |
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; | |
198 | |
199 more_work_is_plausible = g_main_context_iteration(context_, block); | |
200 if (state_->should_quit) | |
201 break; | |
202 | |
203 more_work_is_plausible |= state_->delegate->DoWork(); | |
204 if (state_->should_quit) | |
205 break; | |
206 | |
207 more_work_is_plausible |= | |
208 state_->delegate->DoDelayedWork(&delayed_work_time_); | |
209 if (state_->should_quit) | |
210 break; | |
211 | |
212 if (more_work_is_plausible) | |
213 continue; | |
214 | |
215 more_work_is_plausible = state_->delegate->DoIdleWork(); | |
216 if (state_->should_quit) | |
217 break; | |
218 } | |
219 | |
220 state_ = previous_state; | |
221 } | |
222 | |
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; | |
230 | |
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_); | |
234 } | |
235 | |
236 bool MessagePumpGlib::HandleCheck() { | |
237 if (!state_) // state_ may be null during tests. | |
238 return false; | |
239 | |
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."; | |
250 } | |
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; | |
257 } | |
258 | |
259 if (state_->has_work) | |
260 return true; | |
261 | |
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; | |
266 } | |
267 | |
268 return false; | |
269 } | |
270 | |
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; | |
279 } | |
280 | |
281 if (state_->should_quit) | |
282 return; | |
283 | |
284 state_->delegate->DoDelayedWork(&delayed_work_time_); | |
285 } | |
286 | |
287 void MessagePumpGlib::AddObserver(MessagePumpObserver* observer) { | |
288 observers_.AddObserver(observer); | |
289 } | |
290 | |
291 void MessagePumpGlib::RemoveObserver(MessagePumpObserver* observer) { | |
292 observers_.RemoveObserver(observer); | |
293 } | |
294 | |
295 void MessagePumpGlib::Run(Delegate* delegate) { | |
296 RunWithDispatcher(delegate, NULL); | |
297 } | |
298 | |
299 void MessagePumpGlib::Quit() { | |
300 if (state_) { | |
301 state_->should_quit = true; | |
302 } else { | |
303 NOTREACHED() << "Quit called outside Run!"; | |
304 } | |
305 } | |
306 | |
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!"; | |
314 } | |
315 } | |
316 | |
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(); | |
322 } | |
323 | |
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_); | |
329 } | |
330 | |
331 MessagePumpDispatcher* MessagePumpGlib::GetDispatcher() { | |
332 return state_ ? state_->dispatcher : NULL; | |
333 } | |
334 | |
335 } // namespace base | |
OLD | NEW |