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

base/message_pump_x.cc

 // 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_x.h"
+#include "base/message_pump_x.h"
 
 #include <gdk/gdkx.h>
 #if defined(HAVE_XINPUT2)
 #include <X11/extensions/XInput2.h>
 #else
 #include <X11/Xlib.h>
 #endif
 
-#include "base/message_pump_glib_x_dispatch.h"
-
 namespace {
 
 gboolean PlaceholderDispatch(GSource* source,
                              GSourceFunc cb,
                              gpointer data) {
   return TRUE;
 }
 
 }  // namespace
 
 namespace base {
 
-MessagePumpGlibX::MessagePumpGlibX() : base::MessagePumpForUI(),
+MessagePumpX::MessagePumpX() : MessagePumpGlib(),
 #if defined(HAVE_XINPUT2)
     xiopcode_(-1),
 #endif
     gdksource_(NULL),
     dispatching_event_(false),
     capture_x_events_(0),
     capture_gdk_events_(0) {
   gdk_window_add_filter(NULL, &GdkEventFilter, this);
   gdk_event_handler_set(&EventDispatcherX, this, NULL);
 
 #if defined(HAVE_XINPUT2)
   InitializeXInput2();
 #endif
   InitializeEventsToCapture();
 }
 
-MessagePumpGlibX::~MessagePumpGlibX() {
+MessagePumpX::~MessagePumpX() {
   gdk_window_remove_filter(NULL, &GdkEventFilter, this);
-
-  // It is not necessary to reset the GDK event handler using
-  // gdk_event_handler_set since it's done in the destructor for
-  // MessagePumpForUI.
+  gdk_event_handler_set(reinterpret_cast<GdkEventFunc>(gtk_main_do_event),
+                        this, NULL);
 }
 
-bool MessagePumpGlibX::ShouldCaptureXEvent(XEvent* xev) {
+bool MessagePumpX::ShouldCaptureXEvent(XEvent* xev) {
   return capture_x_events_[xev->type]
 #if defined(HAVE_XINPUT2)
         && (xev->type != GenericEvent || xev->xcookie.extension == xiopcode_)
 #endif
     ;
 }
 
 
-bool MessagePumpGlibX::ProcessXEvent(XEvent* xev) {
+bool MessagePumpX::ProcessXEvent(XEvent* xev) {
   bool should_quit = false;
 
 #if defined(HAVE_XINPUT2)
   bool have_cookie = false;
   if (xev->type == GenericEvent &&
       XGetEventData(xev->xgeneric.display, &xev->xcookie)) {
     have_cookie = true;
   }
 #endif
 
   if (!WillProcessXEvent(xev)) {
-    MessagePumpGlibXDispatcher::DispatchStatus status =
-      static_cast<MessagePumpGlibXDispatcher*>
-      (GetDispatcher())->DispatchX(xev);
+    MessagePumpDispatcher::DispatchStatus status =
+        GetDispatcher()->DispatchX(xev);
 
-    if (status == MessagePumpGlibXDispatcher::EVENT_QUIT) {
+    if (status == MessagePumpDispatcher::EVENT_QUIT) {
       should_quit = true;
       Quit();
-    } else if (status == MessagePumpGlibXDispatcher::EVENT_IGNORED) {
+    } else if (status == MessagePumpDispatcher::EVENT_IGNORED) {
       VLOG(1) << "Event (" << xev->type << ") not handled.";
     }
   }
 
 #if defined(HAVE_XINPUT2)
   if (have_cookie) {
     XFreeEventData(xev->xgeneric.display, &xev->xcookie);
   }
 #endif
 
   return should_quit;
 }
 
-bool MessagePumpGlibX::RunOnce(GMainContext* context, bool block) {
+bool MessagePumpX::RunOnce(GMainContext* context, bool block) {
   GdkDisplay* gdisp = gdk_display_get_default();
   if (!gdisp || !GetDispatcher())
-    return MessagePumpForUI::RunOnce(context, block);
+    return g_main_context_iteration(context, block);
 
   Display* display = GDK_DISPLAY_XDISPLAY(gdisp);
 
   if (XPending(display)) {
     XEvent xev;
     XPeekEvent(display, &xev);
 
     if (ShouldCaptureXEvent(&xev)) {
       XNextEvent(display, &xev);
       if (ProcessXEvent(&xev))
@@ skipping 21 matching lines @@
     dispatching_event_ = false;
 
     gdksource_->source_funcs->dispatch = cb;
   } else {
     retvalue = g_main_context_iteration(context, block);
   }
 
   return retvalue;
 }
 
-GdkFilterReturn MessagePumpGlibX::GdkEventFilter(GdkXEvent* gxevent,
-                                                 GdkEvent* gevent,
-                                                 gpointer data) {
-  MessagePumpGlibX* pump = static_cast<MessagePumpGlibX*>(data);
+GdkFilterReturn MessagePumpX::GdkEventFilter(GdkXEvent* gxevent,
+                                             GdkEvent* gevent,
+                                             gpointer data) {
+  MessagePumpX* pump = static_cast<MessagePumpX*>(data);
   XEvent* xev = static_cast<XEvent*>(gxevent);
 
   if (pump->ShouldCaptureXEvent(xev) && pump->GetDispatcher()) {
     pump->ProcessXEvent(xev);
     return GDK_FILTER_REMOVE;
   }
 
   return GDK_FILTER_CONTINUE;
 }
 
-bool MessagePumpGlibX::WillProcessXEvent(XEvent* xevent) {
-  ObserverListBase<Observer>::Iterator it(observers());
-  Observer* obs;
+bool MessagePumpX::WillProcessXEvent(XEvent* xevent) {
+  ObserverListBase<MessagePumpObserver>::Iterator it(observers());
+  MessagePumpObserver* obs;
   while ((obs = it.GetNext()) != NULL) {
-    MessagePumpXObserver* xobs =
-        static_cast<MessagePumpXObserver*>(obs);
-    if (xobs->WillProcessXEvent(xevent))
+    if (obs->WillProcessXEvent(xevent))
       return true;
   }
   return false;
 }
 
-void MessagePumpGlibX::EventDispatcherX(GdkEvent* event, gpointer data) {
-  MessagePumpGlibX* pump_x = reinterpret_cast<MessagePumpGlibX*>(data);
+void MessagePumpX::EventDispatcherX(GdkEvent* event, gpointer data) {
+  MessagePumpX* pump_x = reinterpret_cast<MessagePumpX*>(data);
 
   if (!pump_x->gdksource_) {
     pump_x->gdksource_ = g_main_current_source();
     if (pump_x->gdksource_)
       pump_x->gdkdispatcher_ = pump_x->gdksource_->source_funcs->dispatch;
   } else if (!pump_x->IsDispatchingEvent()) {
     if (event->type != GDK_NOTHING &&
         pump_x->capture_gdk_events_[event->type]) {
       NOTREACHED() << "GDK received an event it shouldn't have";
     }
   }
 
-  pump_x->DispatchEvents(event);
+  gtk_main_do_event(event);
 }
 
-void MessagePumpGlibX::InitializeEventsToCapture(void) {
+void MessagePumpX::InitializeEventsToCapture(void) {
   // TODO(sad): Decide which events we want to capture and update the tables
   // accordingly.
   capture_x_events_[KeyPress] = true;
   capture_gdk_events_[GDK_KEY_PRESS] = true;
 
   capture_x_events_[KeyRelease] = true;
   capture_gdk_events_[GDK_KEY_RELEASE] = true;
 
   capture_x_events_[ButtonPress] = true;
   capture_gdk_events_[GDK_BUTTON_PRESS] = true;
 
   capture_x_events_[ButtonRelease] = true;
   capture_gdk_events_[GDK_BUTTON_RELEASE] = true;
 
   capture_x_events_[MotionNotify] = true;
   capture_gdk_events_[GDK_MOTION_NOTIFY] = true;
 
 #if defined(HAVE_XINPUT2)
   capture_x_events_[GenericEvent] = true;
 #endif
 }
 
 #if defined(HAVE_XINPUT2)
-void MessagePumpGlibX::InitializeXInput2(void) {
+void MessagePumpX::InitializeXInput2(void) {
   GdkDisplay* display = gdk_display_get_default();
   if (!display)
     return;
 
   Display* xdisplay = GDK_DISPLAY_XDISPLAY(display);
   int event, err;
 
   if (!XQueryExtension(xdisplay, "XInputExtension", &xiopcode_, &event, &err)) {
     VLOG(1) << "X Input extension not available.";
     xiopcode_ = -1;
     return;
   }
 
   int major = 2, minor = 0;
   if (XIQueryVersion(xdisplay, &major, &minor) == BadRequest) {
     VLOG(1) << "XInput2 not supported in the server.";
     xiopcode_ = -1;
     return;
   }
 }
 #endif  // HAVE_XINPUT2
 
-bool MessagePumpXObserver::WillProcessXEvent(XEvent* xev) {
+bool MessagePumpObserver::WillProcessXEvent(XEvent* xev) {
   return false;
 }
 
 }  // namespace base