Move message_pump to base/message_loop.

base/message_pump_glib.cc

Index: base/message_pump_glib.cc
diff --git a/base/message_pump_glib.cc b/base/message_pump_glib.cc
deleted file mode 100644
index 7436558373e15fb604c725c5d9320e9f759ef132..0000000000000000000000000000000000000000
--- a/base/message_pump_glib.cc
+++ /dev/null
@@ -1,335 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/message_pump_glib.h"
-
-#include <fcntl.h>
-#include <math.h>
-
-#include <glib.h>
-
-#include "base/logging.h"
-#include "base/posix/eintr_wrapper.h"
-#include "base/threading/platform_thread.h"
-
-namespace {
-
-// Return a timeout suitable for the glib loop, -1 to block forever,
-// 0 to return right away, or a timeout in milliseconds from now.
-int GetTimeIntervalMilliseconds(const base::TimeTicks& from) {
-  if (from.is_null())
-    return -1;
-
-  // Be careful here.  TimeDelta has a precision of microseconds, but we want a
-  // value in milliseconds.  If there are 5.5ms left, should the delay be 5 or
-  // 6?  It should be 6 to avoid executing delayed work too early.
-  int delay = static_cast<int>(
-      ceil((from - base::TimeTicks::Now()).InMillisecondsF()));
-
-  // If this value is negative, then we need to run delayed work soon.
-  return delay < 0 ? 0 : delay;
-}
-
-// A brief refresher on GLib:
-//     GLib sources have four callbacks: Prepare, Check, Dispatch and Finalize.
-// On each iteration of the GLib pump, it calls each source's Prepare function.
-// This function should return TRUE if it wants GLib to call its Dispatch, and
-// FALSE otherwise.  It can also set a timeout in this case for the next time
-// Prepare should be called again (it may be called sooner).
-//     After the Prepare calls, GLib does a poll to check for events from the
-// system.  File descriptors can be attached to the sources.  The poll may block
-// if none of the Prepare calls returned TRUE.  It will block indefinitely, or
-// by the minimum time returned by a source in Prepare.
-//     After the poll, GLib calls Check for each source that returned FALSE
-// from Prepare.  The return value of Check has the same meaning as for Prepare,
-// making Check a second chance to tell GLib we are ready for Dispatch.
-//     Finally, GLib calls Dispatch for each source that is ready.  If Dispatch
-// returns FALSE, GLib will destroy the source.  Dispatch calls may be recursive
-// (i.e., you can call Run from them), but Prepare and Check cannot.
-//     Finalize is called when the source is destroyed.
-// NOTE: It is common for subsytems to want to process pending events while
-// doing intensive work, for example the flash plugin. They usually use the
-// following pattern (recommended by the GTK docs):
-// while (gtk_events_pending()) {
-//   gtk_main_iteration();
-// }
-//
-// gtk_events_pending just calls g_main_context_pending, which does the
-// following:
-// - Call prepare on all the sources.
-// - Do the poll with a timeout of 0 (not blocking).
-// - Call check on all the sources.
-// - *Does not* call dispatch on the sources.
-// - Return true if any of prepare() or check() returned true.
-//
-// gtk_main_iteration just calls g_main_context_iteration, which does the whole
-// thing, respecting the timeout for the poll (and block, although it is
-// expected not to if gtk_events_pending returned true), and call dispatch.
-//
-// Thus it is important to only return true from prepare or check if we
-// actually have events or work to do. We also need to make sure we keep
-// internal state consistent so that if prepare/check return true when called
-// from gtk_events_pending, they will still return true when called right
-// after, from gtk_main_iteration.
-//
-// For the GLib pump we try to follow the Windows UI pump model:
-// - Whenever we receive a wakeup event or the timer for delayed work expires,
-// we run DoWork and/or DoDelayedWork. That part will also run in the other
-// event pumps.
-// - We also run DoWork, DoDelayedWork, and possibly DoIdleWork in the main
-// loop, around event handling.
-
-struct WorkSource : public GSource {
-  base::MessagePumpGlib* pump;
-};
-
-gboolean WorkSourcePrepare(GSource* source,
-                           gint* timeout_ms) {
-  *timeout_ms = static_cast<WorkSource*>(source)->pump->HandlePrepare();
-  // We always return FALSE, so that our timeout is honored.  If we were
-  // to return TRUE, the timeout would be considered to be 0 and the poll
-  // would never block.  Once the poll is finished, Check will be called.
-  return FALSE;
-}
-
-gboolean WorkSourceCheck(GSource* source) {
-  // Only return TRUE if Dispatch should be called.
-  return static_cast<WorkSource*>(source)->pump->HandleCheck();
-}
-
-gboolean WorkSourceDispatch(GSource* source,
-                            GSourceFunc unused_func,
-                            gpointer unused_data) {
-
-  static_cast<WorkSource*>(source)->pump->HandleDispatch();
-  // Always return TRUE so our source stays registered.
-  return TRUE;
-}
-
-// I wish these could be const, but g_source_new wants non-const.
-GSourceFuncs WorkSourceFuncs = {
-  WorkSourcePrepare,
-  WorkSourceCheck,
-  WorkSourceDispatch,
-  NULL
-};
-
-}  // namespace
-
-
-namespace base {
-
-struct MessagePumpGlib::RunState {
-  Delegate* delegate;
-  MessagePumpDispatcher* dispatcher;
-
-  // Used to flag that the current Run() invocation should return ASAP.
-  bool should_quit;
-
-  // Used to count how many Run() invocations are on the stack.
-  int run_depth;
-
-  // This keeps the state of whether the pump got signaled that there was new
-  // work to be done. Since we eat the message on the wake up pipe as soon as
-  // we get it, we keep that state here to stay consistent.
-  bool has_work;
-};
-
-MessagePumpGlib::MessagePumpGlib()
-    : state_(NULL),
-      context_(g_main_context_default()),
-      wakeup_gpollfd_(new GPollFD) {
-  // Create our wakeup pipe, which is used to flag when work was scheduled.
-  int fds[2];
-  int ret = pipe(fds);
-  DCHECK_EQ(ret, 0);
-  (void)ret;  // Prevent warning in release mode.
-
-  wakeup_pipe_read_  = fds[0];
-  wakeup_pipe_write_ = fds[1];
-  wakeup_gpollfd_->fd = wakeup_pipe_read_;
-  wakeup_gpollfd_->events = G_IO_IN;
-
-  work_source_ = g_source_new(&WorkSourceFuncs, sizeof(WorkSource));
-  static_cast<WorkSource*>(work_source_)->pump = this;
-  g_source_add_poll(work_source_, wakeup_gpollfd_.get());
-  // Use a low priority so that we let other events in the queue go first.
-  g_source_set_priority(work_source_, G_PRIORITY_DEFAULT_IDLE);
-  // This is needed to allow Run calls inside Dispatch.
-  g_source_set_can_recurse(work_source_, TRUE);
-  g_source_attach(work_source_, context_);
-}
-
-void MessagePumpGlib::RunWithDispatcher(Delegate* delegate,
-                                        MessagePumpDispatcher* dispatcher) {
-#ifndef NDEBUG
-  // Make sure we only run this on one thread. X/GTK only has one message pump
-  // so we can only have one UI loop per process.
-  static base::PlatformThreadId thread_id = base::PlatformThread::CurrentId();
-  DCHECK(thread_id == base::PlatformThread::CurrentId()) <<
-      "Running MessagePumpGlib on two different threads; "
-      "this is unsupported by GLib!";
-#endif
-
-  RunState state;
-  state.delegate = delegate;
-  state.dispatcher = dispatcher;
-  state.should_quit = false;
-  state.run_depth = state_ ? state_->run_depth + 1 : 1;
-  state.has_work = false;
-
-  RunState* previous_state = state_;
-  state_ = &state;
-
-  // We really only do a single task for each iteration of the loop.  If we
-  // have done something, assume there is likely something more to do.  This
-  // will mean that we don't block on the message pump until there was nothing
-  // more to do.  We also set this to true to make sure not to block on the
-  // first iteration of the loop, so RunUntilIdle() works correctly.
-  bool more_work_is_plausible = true;
-
-  // We run our own loop instead of using g_main_loop_quit in one of the
-  // callbacks.  This is so we only quit our own loops, and we don't quit
-  // nested loops run by others.  TODO(deanm): Is this what we want?
-  for (;;) {
-    // Don't block if we think we have more work to do.
-    bool block = !more_work_is_plausible;
-
-    more_work_is_plausible = g_main_context_iteration(context_, block);
-    if (state_->should_quit)
-      break;
-
-    more_work_is_plausible |= state_->delegate->DoWork();
-    if (state_->should_quit)
-      break;
-
-    more_work_is_plausible |=
-        state_->delegate->DoDelayedWork(&delayed_work_time_);
-    if (state_->should_quit)
-      break;
-
-    if (more_work_is_plausible)
-      continue;
-
-    more_work_is_plausible = state_->delegate->DoIdleWork();
-    if (state_->should_quit)
-      break;
-  }
-
-  state_ = previous_state;
-}
-
-// Return the timeout we want passed to poll.
-int MessagePumpGlib::HandlePrepare() {
-  // We know we have work, but we haven't called HandleDispatch yet. Don't let
-  // the pump block so that we can do some processing.
-  if (state_ &&  // state_ may be null during tests.
-      state_->has_work)
-    return 0;
-
-  // We don't think we have work to do, but make sure not to block
-  // longer than the next time we need to run delayed work.
-  return GetTimeIntervalMilliseconds(delayed_work_time_);
-}
-
-bool MessagePumpGlib::HandleCheck() {
-  if (!state_)  // state_ may be null during tests.
-    return false;
-
-  // We usually have a single message on the wakeup pipe, since we are only
-  // signaled when the queue went from empty to non-empty, but there can be
-  // two messages if a task posted a task, hence we read at most two bytes.
-  // The glib poll will tell us whether there was data, so this read
-  // shouldn't block.
-  if (wakeup_gpollfd_->revents & G_IO_IN) {
-    char msg[2];
-    const int num_bytes = HANDLE_EINTR(read(wakeup_pipe_read_, msg, 2));
-    if (num_bytes < 1) {
-      NOTREACHED() << "Error reading from the wakeup pipe.";
-    }
-    DCHECK((num_bytes == 1 && msg[0] == '!') ||
-           (num_bytes == 2 && msg[0] == '!' && msg[1] == '!'));
-    // Since we ate the message, we need to record that we have more work,
-    // because HandleCheck() may be called without HandleDispatch being called
-    // afterwards.
-    state_->has_work = true;
-  }
-
-  if (state_->has_work)
-    return true;
-
-  if (GetTimeIntervalMilliseconds(delayed_work_time_) == 0) {
-    // The timer has expired. That condition will stay true until we process
-    // that delayed work, so we don't need to record this differently.
-    return true;
-  }
-
-  return false;
-}
-
-void MessagePumpGlib::HandleDispatch() {
-  state_->has_work = false;
-  if (state_->delegate->DoWork()) {
-    // NOTE: on Windows at this point we would call ScheduleWork (see
-    // MessagePumpGlib::HandleWorkMessage in message_pump_win.cc). But here,
-    // instead of posting a message on the wakeup pipe, we can avoid the
-    // syscalls and just signal that we have more work.
-    state_->has_work = true;
-  }
-
-  if (state_->should_quit)
-    return;
-
-  state_->delegate->DoDelayedWork(&delayed_work_time_);
-}
-
-void MessagePumpGlib::AddObserver(MessagePumpObserver* observer) {
-  observers_.AddObserver(observer);
-}
-
-void MessagePumpGlib::RemoveObserver(MessagePumpObserver* observer) {
-  observers_.RemoveObserver(observer);
-}
-
-void MessagePumpGlib::Run(Delegate* delegate) {
-  RunWithDispatcher(delegate, NULL);
-}
-
-void MessagePumpGlib::Quit() {
-  if (state_) {
-    state_->should_quit = true;
-  } else {
-    NOTREACHED() << "Quit called outside Run!";
-  }
-}
-
-void MessagePumpGlib::ScheduleWork() {
-  // This can be called on any thread, so we don't want to touch any state
-  // variables as we would then need locks all over.  This ensures that if
-  // we are sleeping in a poll that we will wake up.
-  char msg = '!';
-  if (HANDLE_EINTR(write(wakeup_pipe_write_, &msg, 1)) != 1) {
-    NOTREACHED() << "Could not write to the UI message loop wakeup pipe!";
-  }
-}
-
-void MessagePumpGlib::ScheduleDelayedWork(const TimeTicks& delayed_work_time) {
-  // We need to wake up the loop in case the poll timeout needs to be
-  // adjusted.  This will cause us to try to do work, but that's ok.
-  delayed_work_time_ = delayed_work_time;
-  ScheduleWork();
-}
-
-MessagePumpGlib::~MessagePumpGlib() {
-  g_source_destroy(work_source_);
-  g_source_unref(work_source_);
-  close(wakeup_pipe_read_);
-  close(wakeup_pipe_write_);
-}
-
-MessagePumpDispatcher* MessagePumpGlib::GetDispatcher() {
-  return state_ ? state_->dispatcher : NULL;
-}
-
-}  // namespace base