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