Refactor the glib message-pump, and use it as the base for a gtk message pump and an X message pump.

base/message_pump_glib.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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 <gtk/gtk.h>
 #include <glib.h>
 
 #include "base/eintr_wrapper.h"
 #include "base/logging.h"
 #include "base/threading/platform_thread.h"
 
 namespace {
 
 // We send a byte across a pipe to wakeup the event loop.
 const char kWorkScheduled = '\0';
@@ skipping 57 matching lines @@
 // 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::MessagePumpForUI* pump;
+  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;
 }
@@ skipping 18 matching lines @@
   WorkSourceCheck,
   WorkSourceDispatch,
   NULL
 };
 
 }  // namespace
 
 
 namespace base {
 
-struct MessagePumpForUI::RunState {
+struct MessagePumpGlib::RunState {
   Delegate* delegate;
-  Dispatcher* dispatcher;
+  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;
 };
 
-MessagePumpForUI::MessagePumpForUI()
+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];
   CHECK_EQ(pipe(fds), 0);
   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_);
-  gdk_event_handler_set(&EventDispatcher, this, NULL);
 }
 
-MessagePumpForUI::~MessagePumpForUI() {
-  gdk_event_handler_set(reinterpret_cast<GdkEventFunc>(gtk_main_do_event),
-                        this, NULL);
+MessagePumpGlib::~MessagePumpGlib() {
   g_source_destroy(work_source_);
   g_source_unref(work_source_);
   close(wakeup_pipe_read_);
   close(wakeup_pipe_write_);
 }
 
-void MessagePumpForUI::RunWithDispatcher(Delegate* delegate,
-                                         Dispatcher* dispatcher) {
+void MessagePumpGlib::RunWithDispatcher(Delegate* delegate,
+                                        MessagePumpDispatcher* dispatcher) {
 #ifndef NDEBUG
-  // Make sure we only run this on one thread.  GTK only has one message pump
+  // 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 MessagePumpForUI on two different threads; "
+      "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;
 
@@ skipping 31 matching lines @@
       continue;
 
     more_work_is_plausible = state_->delegate->DoIdleWork();
     if (state_->should_quit)
       break;
   }
 
   state_ = previous_state;
 }
 
-bool MessagePumpForUI::RunOnce(GMainContext* context, bool block) {
-  // g_main_context_iteration returns true if events have been dispatched.
-  return g_main_context_iteration(context, block);
-}
-
 // Return the timeout we want passed to poll.
-int MessagePumpForUI::HandlePrepare() {
+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 MessagePumpForUI::HandleCheck() {
+bool MessagePumpGlib::HandleCheck() {
   if (!state_)  // state_ may be null during tests.
     return false;
 
   // We should only ever have a single message on the wakeup pipe, since we
   // are only signaled when the queue went from empty to non-empty.  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;
     if (HANDLE_EINTR(read(wakeup_pipe_read_, &msg, 1)) != 1 || msg != '!') {
       NOTREACHED() << "Error reading from the wakeup pipe.";
     }
     // 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 MessagePumpForUI::HandleDispatch() {
+void MessagePumpGlib::HandleDispatch() {
   state_->has_work = false;
   if (state_->delegate->DoWork()) {
     // NOTE: on Windows at this point we would call ScheduleWork (see
-    // MessagePumpForUI::HandleWorkMessage in message_pump_win.cc). But here,
+    // 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 MessagePumpForUI::AddObserver(Observer* observer) {
+void MessagePumpGlib::AddObserver(MessagePumpObserver* observer) {
   observers_.AddObserver(observer);
 }
 
-void MessagePumpForUI::RemoveObserver(Observer* observer) {
+void MessagePumpGlib::RemoveObserver(MessagePumpObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
-void MessagePumpForUI::DispatchEvents(GdkEvent* event) {
-  WillProcessEvent(event);
-  if (state_ && state_->dispatcher) { // state_ may be null during tests.
-    if (!state_->dispatcher->Dispatch(event))
-      state_->should_quit = true;
-  } else {
-    gtk_main_do_event(event);
-  }
-  DidProcessEvent(event);
-}
-
-void MessagePumpForUI::Run(Delegate* delegate) {
+void MessagePumpGlib::Run(Delegate* delegate) {
   RunWithDispatcher(delegate, NULL);
 }
 
-void MessagePumpForUI::Quit() {
+void MessagePumpGlib::Quit() {
   if (state_) {
     state_->should_quit = true;
   } else {
     NOTREACHED() << "Quit called outside Run!";
   }
 }
 
-void MessagePumpForUI::ScheduleWork() {
+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 MessagePumpForUI::ScheduleDelayedWork(const TimeTicks& delayed_work_time) {
+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();
 }
 
-MessagePumpForUI::Dispatcher* MessagePumpForUI::GetDispatcher() {
+MessagePumpDispatcher* MessagePumpGlib::GetDispatcher() {
   return state_ ? state_->dispatcher : NULL;
 }
 
-void MessagePumpForUI::WillProcessEvent(GdkEvent* event) {
-  FOR_EACH_OBSERVER(Observer, observers_, WillProcessEvent(event));
-}
-
-void MessagePumpForUI::DidProcessEvent(GdkEvent* event) {
-  FOR_EACH_OBSERVER(Observer, observers_, DidProcessEvent(event));
-}
-
-// static
-void MessagePumpForUI::EventDispatcher(GdkEvent* event, gpointer data) {
-  MessagePumpForUI* message_pump = reinterpret_cast<MessagePumpForUI*>(data);
-  message_pump->DispatchEvents(event);
-}
-
 }  // namespace base