28   // Be careful here.  TimeDelta has a precision of microseconds, but we want a  in GetTimeIntervalMilliseconds()
34   // If this value is negative, then we need to run delayed work soon.  in GetTimeIntervalMilliseconds()
50 // making Check a second chance to tell GLib we are ready for Dispatch.
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
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
84 // - We also run DoWork, DoDelayedWork, and possibly DoIdleWork in the main
94   // We always return FALSE, so that our timeout is honored.  If we were  in WorkSourcePrepare()
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
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.
196   // Use a low priority so that we let other events in the queue go first.  in MessagePumpGlib()
213 // Return the timeout we want passed to poll.
215   // We know we have work, but we haven't called HandleDispatch yet. Don't let  in HandlePrepare()
216   // the pump block so that we can do some processing.  in HandlePrepare()
221   // We don't think we have work to do, but make sure not to block  in HandlePrepare()
222   // longer than the next time we need to run delayed work.  in HandlePrepare()
230   // We usually have a single message on the wakeup pipe, since we are only  in HandleCheck()
232   // two messages if a task posted a task, hence we read at most two bytes.  in HandleCheck()
243     // Since we ate the message, we need to record that we have more work,  in HandleCheck()
253     // The timer has expired. That condition will stay true until we process  in HandleCheck()
254     // that delayed work, so we don't need to record this differently.  in HandleCheck()
264     // NOTE: on Windows at this point we would call ScheduleWork (see  in HandleDispatch()
266     // instead of posting a message on the wakeup pipe, we can avoid the  in HandleDispatch()
267     // syscalls and just signal that we have more work.  in HandleDispatch()
291   // We really only do a single task for each iteration of the loop.  If we  in Run()
293   // will mean that we don't block on the message pump until there was nothing  in Run()
294   // more to do.  We also set this to true to make sure not to block on the  in Run()
298   // We run our own loop instead of using g_main_loop_quit in one of the  in Run()
299   // callbacks.  This is so we only quit our own loops, and we don't quit  in Run()
300   // nested loops run by others.  TODO(deanm): Is this what we want?  in Run()
302     // Don't block if we think we have more work to do.  in Run()
338   // This can be called on any thread, so we don't want to touch any state  in ScheduleWork()
339   // variables as we would then need locks all over.  This ensures that if  in ScheduleWork()
340   // we are sleeping in a poll that we will wake up.  in ScheduleWork()
348   // We need to wake up the loop in case the poll timeout needs to be  in ScheduleDelayedWork()