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_loop/message_pump_glib.h" 6 7 #include <fcntl.h> 8 #include <math.h> 9 10 #include <glib.h> 11 12 #include "base/lazy_instance.h" 13 #include "base/logging.h" 14 #include "base/posix/eintr_wrapper.h" 15 #include "base/synchronization/lock.h" 16 #include "base/threading/platform_thread.h" 17 18 namespace base { 19 20 namespace { 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 int GetTimeIntervalMilliseconds(const TimeTicks& from) { 25 if (from.is_null()) 26 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 ceil((from - TimeTicks::Now()).InMillisecondsF())); 33 34 // If this value is negative, then we need to run delayed work soon. 35 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 subsystems 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 MessagePumpGlib* pump; 89 }; 90 91 gboolean WorkSourcePrepare(GSource* source, 92 gint* timeout_ms) { 93 *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 return FALSE; 98 } 99 100 gboolean WorkSourceCheck(GSource* source) { 101 // Only return TRUE if Dispatch should be called. 102 return static_cast<WorkSource*>(source)->pump->HandleCheck(); 103 } 104 105 gboolean WorkSourceDispatch(GSource* source, 106 GSourceFunc unused_func, 107 gpointer unused_data) { 108 109 static_cast<WorkSource*>(source)->pump->HandleDispatch(); 110 // Always return TRUE so our source stays registered. 111 return TRUE; 112 } 113 114 // I wish these could be const, but g_source_new wants non-const. 115 GSourceFuncs WorkSourceFuncs = {WorkSourcePrepare, WorkSourceCheck, 116 WorkSourceDispatch, nullptr}; 117 118 // The following is used to make sure we only run the MessagePumpGlib on one 119 // thread. X only has one message pump so we can only have one UI loop per 120 // process. 121 #ifndef NDEBUG 122 123 // Tracks the pump the most recent pump that has been run. 124 struct ThreadInfo { 125 // The pump. 126 MessagePumpGlib* pump; 127 128 // ID of the thread the pump was run on. 129 PlatformThreadId thread_id; 130 }; 131 132 // Used for accesing |thread_info|. 133 static LazyInstance<Lock>::Leaky thread_info_lock = LAZY_INSTANCE_INITIALIZER; 134 135 // If non-NULL it means a MessagePumpGlib exists and has been Run. This is 136 // destroyed when the MessagePump is destroyed. 137 ThreadInfo* thread_info = NULL; 138 139 void CheckThread(MessagePumpGlib* pump) { 140 AutoLock auto_lock(thread_info_lock.Get()); 141 if (!thread_info) { 142 thread_info = new ThreadInfo; 143 thread_info->pump = pump; 144 thread_info->thread_id = PlatformThread::CurrentId(); 145 } 146 DCHECK(thread_info->thread_id == PlatformThread::CurrentId()) << 147 "Running MessagePumpGlib on two different threads; " 148 "this is unsupported by GLib!"; 149 } 150 151 void PumpDestroyed(MessagePumpGlib* pump) { 152 AutoLock auto_lock(thread_info_lock.Get()); 153 if (thread_info && thread_info->pump == pump) { 154 delete thread_info; 155 thread_info = NULL; 156 } 157 } 158 159 #endif 160 161 } // namespace 162 163 struct MessagePumpGlib::RunState { 164 Delegate* delegate; 165 166 // Used to flag that the current Run() invocation should return ASAP. 167 bool should_quit; 168 169 // Used to count how many Run() invocations are on the stack. 170 int run_depth; 171 172 // This keeps the state of whether the pump got signaled that there was new 173 // work to be done. Since we eat the message on the wake up pipe as soon as 174 // we get it, we keep that state here to stay consistent. 175 bool has_work; 176 }; 177 178 MessagePumpGlib::MessagePumpGlib() 179 : state_(nullptr), 180 context_(g_main_context_default()), 181 wakeup_gpollfd_(new GPollFD) { 182 // Create our wakeup pipe, which is used to flag when work was scheduled. 183 int fds[2]; 184 int ret = pipe(fds); 185 DCHECK_EQ(ret, 0); 186 (void)ret; // Prevent warning in release mode. 187 188 wakeup_pipe_read_ = fds[0]; 189 wakeup_pipe_write_ = fds[1]; 190 wakeup_gpollfd_->fd = wakeup_pipe_read_; 191 wakeup_gpollfd_->events = G_IO_IN; 192 193 work_source_ = g_source_new(&WorkSourceFuncs, sizeof(WorkSource)); 194 static_cast<WorkSource*>(work_source_)->pump = this; 195 g_source_add_poll(work_source_, wakeup_gpollfd_.get()); 196 // Use a low priority so that we let other events in the queue go first. 197 g_source_set_priority(work_source_, G_PRIORITY_DEFAULT_IDLE); 198 // This is needed to allow Run calls inside Dispatch. 199 g_source_set_can_recurse(work_source_, TRUE); 200 g_source_attach(work_source_, context_); 201 } 202 203 MessagePumpGlib::~MessagePumpGlib() { 204 #ifndef NDEBUG 205 PumpDestroyed(this); 206 #endif 207 g_source_destroy(work_source_); 208 g_source_unref(work_source_); 209 close(wakeup_pipe_read_); 210 close(wakeup_pipe_write_); 211 } 212 213 // Return the timeout we want passed to poll. 214 int MessagePumpGlib::HandlePrepare() { 215 // We know we have work, but we haven't called HandleDispatch yet. Don't let 216 // the pump block so that we can do some processing. 217 if (state_ && // state_ may be null during tests. 218 state_->has_work) 219 return 0; 220 221 // We don't think we have work to do, but make sure not to block 222 // longer than the next time we need to run delayed work. 223 return GetTimeIntervalMilliseconds(delayed_work_time_); 224 } 225 226 bool MessagePumpGlib::HandleCheck() { 227 if (!state_) // state_ may be null during tests. 228 return false; 229 230 // We usually have a single message on the wakeup pipe, since we are only 231 // signaled when the queue went from empty to non-empty, but there can be 232 // two messages if a task posted a task, hence we read at most two bytes. 233 // The glib poll will tell us whether there was data, so this read 234 // shouldn't block. 235 if (wakeup_gpollfd_->revents & G_IO_IN) { 236 char msg[2]; 237 const int num_bytes = HANDLE_EINTR(read(wakeup_pipe_read_, msg, 2)); 238 if (num_bytes < 1) { 239 NOTREACHED() << "Error reading from the wakeup pipe."; 240 } 241 DCHECK((num_bytes == 1 && msg[0] == '!') || 242 (num_bytes == 2 && msg[0] == '!' && msg[1] == '!')); 243 // Since we ate the message, we need to record that we have more work, 244 // because HandleCheck() may be called without HandleDispatch being called 245 // afterwards. 246 state_->has_work = true; 247 } 248 249 if (state_->has_work) 250 return true; 251 252 if (GetTimeIntervalMilliseconds(delayed_work_time_) == 0) { 253 // The timer has expired. That condition will stay true until we process 254 // that delayed work, so we don't need to record this differently. 255 return true; 256 } 257 258 return false; 259 } 260 261 void MessagePumpGlib::HandleDispatch() { 262 state_->has_work = false; 263 if (state_->delegate->DoWork()) { 264 // NOTE: on Windows at this point we would call ScheduleWork (see 265 // MessagePumpGlib::HandleWorkMessage in message_pump_win.cc). But here, 266 // instead of posting a message on the wakeup pipe, we can avoid the 267 // syscalls and just signal that we have more work. 268 state_->has_work = true; 269 } 270 271 if (state_->should_quit) 272 return; 273 274 state_->delegate->DoDelayedWork(&delayed_work_time_); 275 } 276 277 void MessagePumpGlib::Run(Delegate* delegate) { 278 #ifndef NDEBUG 279 CheckThread(this); 280 #endif 281 282 RunState state; 283 state.delegate = delegate; 284 state.should_quit = false; 285 state.run_depth = state_ ? state_->run_depth + 1 : 1; 286 state.has_work = false; 287 288 RunState* previous_state = state_; 289 state_ = &state; 290 291 // We really only do a single task for each iteration of the loop. If we 292 // have done something, assume there is likely something more to do. This 293 // will mean that we don't block on the message pump until there was nothing 294 // more to do. We also set this to true to make sure not to block on the 295 // first iteration of the loop, so RunUntilIdle() works correctly. 296 bool more_work_is_plausible = true; 297 298 // We run our own loop instead of using g_main_loop_quit in one of the 299 // callbacks. This is so we only quit our own loops, and we don't quit 300 // nested loops run by others. TODO(deanm): Is this what we want? 301 for (;;) { 302 // Don't block if we think we have more work to do. 303 bool block = !more_work_is_plausible; 304 305 more_work_is_plausible = g_main_context_iteration(context_, block); 306 if (state_->should_quit) 307 break; 308 309 more_work_is_plausible |= state_->delegate->DoWork(); 310 if (state_->should_quit) 311 break; 312 313 more_work_is_plausible |= 314 state_->delegate->DoDelayedWork(&delayed_work_time_); 315 if (state_->should_quit) 316 break; 317 318 if (more_work_is_plausible) 319 continue; 320 321 more_work_is_plausible = state_->delegate->DoIdleWork(); 322 if (state_->should_quit) 323 break; 324 } 325 326 state_ = previous_state; 327 } 328 329 void MessagePumpGlib::Quit() { 330 if (state_) { 331 state_->should_quit = true; 332 } else { 333 NOTREACHED() << "Quit called outside Run!"; 334 } 335 } 336 337 void MessagePumpGlib::ScheduleWork() { 338 // This can be called on any thread, so we don't want to touch any state 339 // variables as we would then need locks all over. This ensures that if 340 // we are sleeping in a poll that we will wake up. 341 char msg = '!'; 342 if (HANDLE_EINTR(write(wakeup_pipe_write_, &msg, 1)) != 1) { 343 NOTREACHED() << "Could not write to the UI message loop wakeup pipe!"; 344 } 345 } 346 347 void MessagePumpGlib::ScheduleDelayedWork(const TimeTicks& delayed_work_time) { 348 // We need to wake up the loop in case the poll timeout needs to be 349 // adjusted. This will cause us to try to do work, but that's OK. 350 delayed_work_time_ = delayed_work_time; 351 ScheduleWork(); 352 } 353 354 bool MessagePumpGlib::ShouldQuit() const { 355 CHECK(state_); 356 return state_->should_quit; 357 } 358 359 } // namespace base 360