touch: Always expect XInput2 availability.

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>
-#if defined(HAVE_XINPUT2)
 #include <X11/extensions/XInput2.h>
-#else
-#include <X11/Xlib.h>
-#endif
 
 #include "base/basictypes.h"
 #include "base/message_loop.h"
 
 namespace {
 
 gboolean PlaceholderDispatch(GSource* source,
                              GSourceFunc cb,
                              gpointer data) {
   return TRUE;
 }
 
 // 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;
 
 }  // namespace
 
 namespace base {
 
 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
   if (use_gtk_message_pump)
     InitializeEventsToCapture();
 }
 
 MessagePumpX::~MessagePumpX() {
   gdk_window_remove_filter(NULL, &GdkEventFilter, this);
   gdk_event_handler_set(reinterpret_cast<GdkEventFunc>(gtk_main_do_event),
                         this, NULL);
 }
 
 // static
 void MessagePumpX::DisableGtkMessagePump() {
   use_gtk_message_pump = false;
 }
 
 bool MessagePumpX::ShouldCaptureXEvent(XEvent* xev) {
   return (!use_gtk_message_pump || capture_x_events_[xev->type])
-#if defined(HAVE_XINPUT2)
       && (xev->type != GenericEvent || xev->xcookie.extension == xiopcode_)
-#endif
       ;
 }
 
 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) == MessagePumpObserver::EVENT_CONTINUE) {
     MessagePumpDispatcher::DispatchStatus status =
         GetDispatcher()->Dispatch(xev);
 
     if (status == MessagePumpDispatcher::EVENT_QUIT) {
       should_quit = true;
       Quit();
     } 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 MessagePumpX::RunOnce(GMainContext* context, bool block) {
   Display* display = MessageLoopForUI::current()->GetDisplay();
   if (!display || !GetDispatcher())
     return g_main_context_iteration(context, block);
 
   if (XPending(display)) {
@@ skipping 87 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 MessagePumpX::InitializeXInput2(void) {
   Display* display = MessageLoopForUI::current()->GetDisplay();
   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;
   }
 }
-#endif  // HAVE_XINPUT2
 
 MessagePumpObserver::EventStatus
     MessagePumpObserver::WillProcessXEvent(XEvent* xev) {
   return EVENT_CONTINUE;
 }
 
 COMPILE_ASSERT(XLASTEvent >= LASTEvent, XLASTEvent_too_small);
 
 }  // namespace base