aura: Explicitly disable GTK

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 <gdk/gdkx.h>
 #include <X11/extensions/XInput2.h>
 
 #include "base/basictypes.h"
 #include "base/message_loop.h"
 
+#if defined(TOOLKIT_USES_GTK)
+#include <gdk/gdkx.h>
+#endif
+
 namespace {
 
 gboolean XSourcePrepare(GSource* source, gint* timeout_ms) {
   if (XPending(base::MessagePumpX::GetDefaultXDisplay()))
     *timeout_ms = 0;
   else
     *timeout_ms = -1;
   return FALSE;
 }
 
@@ skipping 10 matching lines @@
   return TRUE;
 }
 
 GSourceFuncs XSourceFuncs = {
   XSourcePrepare,
   XSourceCheck,
   XSourceDispatch,
   NULL
 };
 
-// A flag to disable GTK's message pump. This is intermediate step
-// to remove gtk and will be removed once migration is complete.
-bool use_gtk_message_pump = true;
-
 // The opcode used for checking events.
 int xiopcode = -1;
 
 // When the GTK/GDK event processing is disabled, the message-pump opens a
 // connection to the display and owns it.
 Display* g_xdisplay = NULL;
 
+#if defined(TOOLKIT_USES_GTK)
+// A flag to disable GTK's message pump. This is intermediate step
+// to remove gtk and will be removed once migration is complete.
+bool use_gtk_message_pump = true;
+
 gboolean PlaceholderDispatch(GSource* source,
                              GSourceFunc cb,
                              gpointer data) {
   return TRUE;
 }
+#endif  // defined(TOOLKIT_USES_GTK)
 
 void InitializeXInput2(void) {
   Display* display = base::MessagePumpX::GetDefaultXDisplay();
   if (!display)
     return;
 
   int event, err;
 
   if (!XQueryExtension(display, "XInputExtension", &xiopcode, &event, &err)) {
     VLOG(1) << "X Input extension not available.";
     xiopcode = -1;
     return;
   }
 
   int major = 2, minor = 0;
   if (XIQueryVersion(display, &major, &minor) == BadRequest) {
     VLOG(1) << "XInput2 not supported in the server.";
     xiopcode = -1;
     return;
   }
 }
 
 }  // namespace
 
 namespace base {
 
 MessagePumpX::MessagePumpX() : MessagePumpGlib(),
-    x_source_(NULL),
+#if defined(TOOLKIT_USES_GTK)
     gdksource_(NULL),
     dispatching_event_(false),
     capture_x_events_(0),
-    capture_gdk_events_(0) {
+    capture_gdk_events_(0),
+#endif
+    x_source_(NULL) {
+  InitializeXInput2();
+#if defined(TOOLKIT_USES_GTK)
   if (use_gtk_message_pump) {
     gdk_window_add_filter(NULL, &GdkEventFilter, this);
     gdk_event_handler_set(&EventDispatcherX, this, NULL);
   } else {
     GPollFD* x_poll = new GPollFD();

[oshima, 2011/09/20 05:10:17]

Don't you need the have to skip g_source_destroy etc in destructor?

[sadrul, 2011/09/20 18:24:28]

This was actually wrong. The event-source for X was not being initialized for
non-GTK use at all! Oops! Fixed that.

     x_poll->fd = ConnectionNumber(g_xdisplay);
     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());
   }
-
-  InitializeXInput2();
   if (use_gtk_message_pump)
     InitializeEventsToCapture();
+#endif
 }
 
 MessagePumpX::~MessagePumpX() {
+#if defined(TOOLKIT_USES_GTK)
   if (use_gtk_message_pump) {
     gdk_window_remove_filter(NULL, &GdkEventFilter, this);
     gdk_event_handler_set(reinterpret_cast<GdkEventFunc>(gtk_main_do_event),
         this, NULL);
-  } else {
-    g_source_destroy(x_source_);
-    g_source_unref(x_source_);
-    XCloseDisplay(g_xdisplay);
-    g_xdisplay = NULL;
+    return;
   }
+#endif
+
+  g_source_destroy(x_source_);
+  g_source_unref(x_source_);
+  XCloseDisplay(g_xdisplay);
+  g_xdisplay = NULL;
+}
+
+#if defined(TOOLKIT_USES_GTK)
+// static
+void MessagePumpX::DisableGtkMessagePump() {
+  use_gtk_message_pump = false;
+}
+#endif
+
+// static
+Display* MessagePumpX::GetDefaultXDisplay() {
+#if defined(TOOLKIT_USES_GTK)
+  if (use_gtk_message_pump) {
+    static GdkDisplay* display = gdk_display_get_default();
+    return display ? GDK_DISPLAY_XDISPLAY(display) : NULL;
+  }
+#endif
+  if (!g_xdisplay)
+    g_xdisplay = XOpenDisplay(NULL);
+  return g_xdisplay;
 }
 
 // static
-void MessagePumpX::DisableGtkMessagePump() {
-  use_gtk_message_pump = false;
-  g_xdisplay = XOpenDisplay(NULL);
-}
-
-// static
-Display* MessagePumpX::GetDefaultXDisplay() {
-  if (use_gtk_message_pump) {
-    static GdkDisplay* display = gdk_display_get_default();
-    return display ? GDK_DISPLAY_XDISPLAY(display) : NULL;
-  } else {
-    return g_xdisplay;
-  }
-}
-
-// static
 bool MessagePumpX::HasXInput2() {
   return xiopcode != -1;
 }
 
 bool MessagePumpX::ShouldCaptureXEvent(XEvent* xev) {
-  return (!use_gtk_message_pump || capture_x_events_[xev->type])
-      && (xev->type != GenericEvent || xev->xcookie.extension == xiopcode);
+  return
+#if defined(TOOLKIT_USES_GTK)
+      (!use_gtk_message_pump || capture_x_events_[xev->type]) &&
+#endif
+      (xev->type != GenericEvent || xev->xcookie.extension == xiopcode);
 }
 
 bool MessagePumpX::ProcessXEvent(XEvent* xev) {
   bool should_quit = false;
 
   bool have_cookie = false;
   if (xev->type == GenericEvent &&
       XGetEventData(xev->xgeneric.display, &xev->xcookie)) {
     have_cookie = true;
   }
@@ skipping 23 matching lines @@
     return g_main_context_iteration(context, block);
 
   if (XPending(display)) {
     XEvent xev;
     XPeekEvent(display, &xev);
 
     if (ShouldCaptureXEvent(&xev)) {
       XNextEvent(display, &xev);
       if (ProcessXEvent(&xev))
         return true;
+#if defined(TOOLKIT_USES_GTK)
     } else if (use_gtk_message_pump && gdksource_) {
       // TODO(sad): A couple of extra events can still sneak in during this.
       // Those should be sent back to the X queue from the dispatcher
       // EventDispatcherX.
       gdksource_->source_funcs->dispatch = gdkdispatcher_;
       g_main_context_iteration(context, FALSE);
+#endif
     }
   }
 
   bool retvalue;
+#if defined(TOOLKIT_USES_GTK)
   if (gdksource_ && use_gtk_message_pump) {
     // Replace the dispatch callback of the GDK event source temporarily so that
     // it doesn't read events from X.
     gboolean (*cb)(GSource*, GSourceFunc, void*) =
         gdksource_->source_funcs->dispatch;
     gdksource_->source_funcs->dispatch = PlaceholderDispatch;
 
     dispatching_event_ = true;
     retvalue = g_main_context_iteration(context, block);
     dispatching_event_ = false;
 
     gdksource_->source_funcs->dispatch = cb;
   } else {
     retvalue = g_main_context_iteration(context, block);
   }
+#else
+  retvalue = g_main_context_iteration(context, block);
+#endif
 
   return retvalue;
 }
 
+#if defined(TOOLKIT_USES_GTK)
 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;
   }
@@ skipping 43 matching lines @@
 
   capture_x_events_[ButtonRelease] = true;
   capture_gdk_events_[GDK_BUTTON_RELEASE] = true;
 
   capture_x_events_[MotionNotify] = true;
   capture_gdk_events_[GDK_MOTION_NOTIFY] = true;
 
   capture_x_events_[GenericEvent] = true;
 }
 
+COMPILE_ASSERT(XLASTEvent >= LASTEvent, XLASTEvent_too_small);
+
+#endif  // defined(TOOLKIT_USES_GTK)
+
 MessagePumpObserver::EventStatus
     MessagePumpObserver::WillProcessXEvent(XEvent* xev) {
   return EVENT_CONTINUE;
 }
 
-COMPILE_ASSERT(XLASTEvent >= LASTEvent, XLASTEvent_too_small);
-
 }  // namespace base