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.h

 // 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.
 
-#ifndef BASE_MESSAGE_PUMP_GLIB_X_H
-#define BASE_MESSAGE_PUMP_GLIB_X_H
+#ifndef BASE_MESSAGE_PUMP_X_H
+#define BASE_MESSAGE_PUMP_X_H

[oshima, 2011/06/24 05:55:15]

We will need glib even after we remove gtk (for ibus/libcros), so GLIB_X still
makes sense to me. What do you think?

[sadrul, 2011/06/24 06:35:32]

I changed the name because GlibX seems a bit too verbose for me, and I think
it's a good assumption that we will always be using glib, so having it in the
name doesn't convey any extra information anyway.

 
 #include "base/message_pump.h"
 #include "base/message_pump_glib.h"
 
 #include <bitset>
 
 #include <glib.h>
 #include <gtk/gtk.h>
-#include <X11/X.h>
 
 typedef union _XEvent XEvent;
 
 namespace base {
 
-class MessagePumpGlibX : public MessagePumpForUI {
+// The documentation for this class is in message_pump_glib.h
+class MessagePumpDispatcher {
  public:
-  MessagePumpGlibX();
-  virtual ~MessagePumpGlibX();
+  virtual ~MessagePumpDispatcher() {}
+
+  enum DispatchStatus {
+    EVENT_IGNORED,    // The event was not processed.
+    EVENT_PROCESSED,  // The event has been processed.
+    EVENT_QUIT        // The event was processed and the message-loop should
+                      // terminate.
+  };
+
+  // Dispatches the event. EVENT_IGNORED is returned if the event was ignored
+  // (i.e. not processed). EVENT_PROCESSED is returned if the event was
+  // processed. The nested loop exits immediately if EVENT_QUIT is returned.
+  virtual DispatchStatus DispatchX(XEvent* xevent) = 0;
+};
+
+// The documentation for this class is in message_pump_glib.h
+class BASE_API MessagePumpObserver {
+ public:
+  virtual ~MessagePumpObserver() {}
+
+  // This method is called before processing an XEvent. If the method returns
+  // true, it indicates the event has already been handled, so the event is not
+  // processed any farther. If the method returns false, the event dispatching
+  // proceeds as normal.
+  virtual bool WillProcessXEvent(XEvent* xevent);
+};
+
+// This class implements a message-pump for dispatching X events.
+class MessagePumpX : public MessagePumpGlib {
+ public:
+  MessagePumpX();
+  virtual ~MessagePumpX();
 
   // Indicates whether a GDK event was injected by chrome (when |true|) or if it
   // was captured and being processed by GDK (when |false|).
   bool IsDispatchingEvent(void) { return dispatching_event_; }
 
-  // Overridden from MessagePumpForUI:
-  virtual bool RunOnce(GMainContext* context, bool block);
+  // Overridden from MessagePumpGlib:
+  virtual bool RunOnce(GMainContext* context, bool block) OVERRIDE;
 
  private:
   // Some XEvent's can't be directly read from X event queue and will go
   // through GDK's dispatching process and may get discarded. This function
   // sets up a filter to intercept those XEvent's we are interested in
   // and dispatches them so that they won't get lost.
   static GdkFilterReturn GdkEventFilter(GdkXEvent* gxevent,
                                         GdkEvent* gevent,
                                         gpointer data);
 
@@ skipping 34 matching lines @@
   // was captured and being processed by GDK (when |false|).
   bool dispatching_event_;
 
 #if ! GTK_CHECK_VERSION(2,18,0)
 // GDK_EVENT_LAST was introduced in GTK+ 2.18.0. For earlier versions, we pick a
 // large enough value (the value of GDK_EVENT_LAST in 2.18.0) so that it works
 // for all versions.
 #define GDK_EVENT_LAST 37
 #endif
 
+// Ideally we would #include X.h for LASTEvent, but it brings in a lot of stupid
+// shit (like Time, CurrentTime etc.) that messes up a lot of things. So define
+// XLASTEvent here to a large enough value so that it works.
+#define XLASTEvent 40

[oshima, 2011/06/24 05:55:15]

can you add compile time check if this value is good enough , may be at the end
of  .cc?

[sadrul, 2011/06/24 06:35:32]

Sounds like a good idea. Done!

+
   // We do not want to process all the events ourselves. So we use a lookup
   // table to quickly check if a particular event should be handled by us or if
   // it should be passed on to the default GDK handler.
-  std::bitset<LASTEvent> capture_x_events_;
+  std::bitset<XLASTEvent> capture_x_events_;
   std::bitset<GDK_EVENT_LAST> capture_gdk_events_;
 
-  DISALLOW_COPY_AND_ASSIGN(MessagePumpGlibX);
+  DISALLOW_COPY_AND_ASSIGN(MessagePumpX);
 };
 
+typedef MessagePumpX MessagePumpForUI;
+
 }  // namespace base
 
-#endif  // BASE_MESSAGE_PUMP_GLIB_X_H
+#endif  // BASE_MESSAGE_PUMP_X_H