touch: Always expect XInput2 availability.

base/message_pump_glib_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 <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(),
-#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() {
   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.
 }
 
 bool MessagePumpGlibX::ShouldCaptureXEvent(XEvent* xev) {
-  return capture_x_events_[xev->type]
-#if defined(HAVE_XINPUT2)
-        && (xev->type != GenericEvent || xev->xcookie.extension == xiopcode_)
-#endif
-    ;
+  return capture_x_events_[xev->type] &&
+         (xev->type != GenericEvent || xev->xcookie.extension == xiopcode_);
 }
 
 
 bool MessagePumpGlibX::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);
 
     if (status == MessagePumpGlibXDispatcher::EVENT_QUIT) {
       should_quit = true;
       Quit();
     } else if (status == MessagePumpGlibXDispatcher::EVENT_IGNORED) {
       DLOG(WARNING) << "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) {
   GdkDisplay* gdisp = gdk_display_get_default();
   if (!gdisp || !GetDispatcher())
     return MessagePumpForUI::RunOnce(context, block);
 
   Display* display = GDK_DISPLAY_XDISPLAY(gdisp);
@@ skipping 90 matching lines @@
 
   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) {
   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)) {
     DLOG(WARNING) << "X Input extension not available.";
     xiopcode_ = -1;
     return;
   }
 
   int major = 2, minor = 0;
   if (XIQueryVersion(xdisplay, &major, &minor) == BadRequest) {
     DLOG(WARNING) << "XInput2 not supported in the server.";
     xiopcode_ = -1;
     return;
   }
 }
-#endif  // HAVE_XINPUT2
 
 bool MessagePumpXObserver::WillProcessXEvent(XEvent* xev) {
   return false;
 }
 
 }  // namespace base