DefaultDispatcher for MessagePumpX

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_x.h"
 
 #include <X11/extensions/XInput2.h>
 
 #include "base/basictypes.h"
 #include "base/message_loop.h"
@@ skipping 27 matching lines @@
   XSourceDispatch,
   NULL
 };
 
 // The opcode used for checking events.
 int xiopcode = -1;
 
 // The message-pump opens a connection to the display and owns it.
 Display* g_xdisplay = NULL;
 
+// The default dispatcher to process native events when no dispatcher
+// is specified.
+base::MessagePumpDispatcher* g_default_dispatcher = NULL;
+
 void InitializeXInput2(void) {
   Display* display = base::MessagePumpX::GetDefaultXDisplay();
   if (!display)
     return;
 
   int event, err;
 
   if (!XQueryExtension(display, "XInputExtension", &xiopcode, &event, &err)) {
     DVLOG(1) << "X Input extension not available.";
     xiopcode = -1;
@@ skipping 43 matching lines @@
   if (!g_xdisplay)
     g_xdisplay = XOpenDisplay(NULL);
   return g_xdisplay;
 }
 
 // static
 bool MessagePumpX::HasXInput2() {
   return xiopcode != -1;
 }
 
+// static
+void MessagePumpX::SetDefaultDispatcher(MessagePumpDispatcher* dispatcher) {
+  DCHECK(!g_default_dispatcher || !dispatcher);

[sadrul, 2011/11/22 20:25:55]

Is this check necessary? Do we want to prevent a default dispatcher to be
replaced by another one?

[oshima, 2011/11/22 21:20:13]

I wanted to do this to make sure that each tests runs using the correct default
dispatcher.

+  g_default_dispatcher = dispatcher;
+}
+
 void MessagePumpX::InitXSource() {
   DCHECK(!x_source_);
   GPollFD* x_poll = new GPollFD();
   Display* display = GetDefaultXDisplay();
   DCHECK(display) << "Unable to get connection to X server";
   x_poll->fd = ConnectionNumber(display);
   x_poll->events = G_IO_IN;
 
   x_source_ = g_source_new(&XSourceFuncs, sizeof(GSource));
   g_source_add_poll(x_source_, x_poll);
   g_source_set_can_recurse(x_source_, FALSE);
   g_source_attach(x_source_, g_main_context_default());
 }
 
-bool MessagePumpX::ProcessXEvent(XEvent* xev) {
+bool MessagePumpX::ProcessXEvent(MessagePumpDispatcher* dispatcher,
+                                 XEvent* xev) {
   bool should_quit = false;
 
   bool have_cookie = false;
   if (xev->type == GenericEvent &&
       XGetEventData(xev->xgeneric.display, &xev->xcookie)) {
     have_cookie = true;
   }
 
   if (WillProcessXEvent(xev) == EVENT_CONTINUE) {
     MessagePumpDispatcher::DispatchStatus status =
-        GetDispatcher()->Dispatch(xev);
+        dispatcher->Dispatch(xev);
 
     if (status == MessagePumpDispatcher::EVENT_QUIT) {
       should_quit = true;
       Quit();
     } else if (status == MessagePumpDispatcher::EVENT_IGNORED) {
       DVLOG(1) << "Event (" << xev->type << ") not handled.";
     }
     DidProcessXEvent(xev);
   }
 
   if (have_cookie) {
     XFreeEventData(xev->xgeneric.display, &xev->xcookie);
   }
 
   return should_quit;
 }
 
 bool MessagePumpX::RunOnce(GMainContext* context, bool block) {
   Display* display = GetDefaultXDisplay();
-  if (!display || !GetDispatcher())
+  MessagePumpDispatcher* dispatcher =
+      GetDispatcher() ? GetDispatcher() : g_default_dispatcher;

[sadrul, 2011/11/22 20:25:55]

Does it make sense to override GetDispatcher to return the default dispatcher if
none is set for the current state?

[oshima, 2011/11/22 21:20:13]

GetDispatcher is defined in MessagePumpGlib to give a subclass access to the
dispatcher in current state, so I think this is better, but i don't feel
strongly about it, so I can make that change if you want. Please let me know.

+
+  if (!display || !dispatcher)
     return g_main_context_iteration(context, block);
 
   // In the general case, we want to handle all pending events before running
   // the tasks. This is what happens in the message_pump_glib case.
   while (XPending(display)) {
     XEvent xev;
     XNextEvent(display, &xev);
-    if (ProcessXEvent(&xev))
+    if (ProcessXEvent(dispatcher, &xev))
       return true;
   }
 
   return g_main_context_iteration(context, block);
 }
 
 bool MessagePumpX::WillProcessXEvent(XEvent* xevent) {
   ObserverListBase<MessagePumpObserver>::Iterator it(observers());
   MessagePumpObserver* obs;
   while ((obs = it.GetNext()) != NULL) {
     if (obs->WillProcessEvent(xevent))
       return true;
   }
   return false;
 }
 
 void MessagePumpX::DidProcessXEvent(XEvent* xevent) {
   ObserverListBase<MessagePumpObserver>::Iterator it(observers());
   MessagePumpObserver* obs;
   while ((obs = it.GetNext()) != NULL) {
     obs->DidProcessEvent(xevent);
   }
 }
 
 }  // namespace base