touch: Always expect XInput2 availability.

views/focus/accelerator_handler_touch.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 "views/focus/accelerator_handler.h"
 
 #include <bitset>
 #include <gtk/gtk.h>
-#if defined(HAVE_XINPUT2)
 #include <X11/extensions/XInput2.h>
-#else
-#include <X11/Xlib.h>
-#endif
 
 #include "views/accelerator.h"
 #include "views/events/event.h"
 #include "views/focus/focus_manager.h"
 #include "views/ime/input_method.h"
 #include "views/touchui/touch_factory.h"
 #include "views/view.h"
 #include "views/widget/native_widget.h"
 
 namespace views {
@@ skipping 12 matching lines @@
 
   if (!widget) {
     DLOG(WARNING) << "no NativeWidgetGtk found for that GtkWidget";
     return NULL;
   }
   return widget->GetWidget();
 }
 
 }  // namespace
 
-#if defined(HAVE_XINPUT2)
 bool DispatchX2Event(Widget* widget, XEvent* xev) {
   XGenericEventCookie* cookie = &xev->xcookie;
   switch (cookie->evtype) {
     case XI_KeyPress:
     case XI_KeyRelease: {
       // TODO(sad): We don't capture XInput2 events from keyboard yet.
       break;
     }
     case XI_ButtonPress:
     case XI_ButtonRelease:
@@ skipping 43 matching lines @@
                         mouseev.IsOnlyRightMouseButton());
         TouchFactory::GetInstance()->SetCursorVisible(true, start_timer);
 
         return widget->OnMouseEvent(mouseev);
       }
     }
   }
   return false;
 }
 
-#endif  // HAVE_XINPUT2
-
 bool DispatchXEvent(XEvent* xev) {
   GdkDisplay* gdisp = gdk_display_get_default();
   XID xwindow = xev->xany.window;
 
-#if defined(HAVE_XINPUT2)
   if (xev->type == GenericEvent) {
     if (!TouchFactory::GetInstance()->ShouldProcessXI2Event(xev))
       return true;  // Consume the event.
 
     XGenericEventCookie* cookie = &xev->xcookie;
     if (cookie->evtype == XI_HierarchyChanged) {
       TouchFactory::GetInstance()->UpdateDeviceList(cookie->display);
       return true;
     }
 
     XIDeviceEvent* xiev = static_cast<XIDeviceEvent*>(cookie->data);
     xwindow = xiev->event;
   }
-#endif
 
   GdkWindow* gwind = gdk_window_lookup_for_display(gdisp, xwindow);
   Widget* widget = FindWidgetForGdkWindow(gwind);
   if (widget) {
     Event::FromNativeEvent2 from_native;
     switch (xev->type) {
       case KeyPress:
       case KeyRelease: {
         KeyEvent keyev(xev, from_native);
         InputMethod* ime = widget->GetInputMethod();
@@ skipping 11 matching lines @@
           // Scrolling the wheel triggers button press/release events.
           MouseWheelEvent wheelev(xev, from_native);
           return widget->OnMouseEvent(wheelev);
         }
         // fallthrough
       case MotionNotify: {
         MouseEvent mouseev(xev, from_native);
         return widget->OnMouseEvent(mouseev);
       }
 
-#if defined(HAVE_XINPUT2)
       case GenericEvent: {
         return DispatchX2Event(widget, xev);
       }
-#endif
     }
   }
 
   return false;
 }
 
-#if defined(HAVE_XINPUT2)
 void SetTouchDeviceList(std::vector<unsigned int>& devices) {
   TouchFactory::GetInstance()->SetTouchDeviceList(devices);
 }
-#endif
 
 AcceleratorHandler::AcceleratorHandler() {}
 
 bool AcceleratorHandler::Dispatch(GdkEvent* event) {
   gtk_main_do_event(event);
   return true;
 }
 
 base::MessagePumpGlibXDispatcher::DispatchStatus
     AcceleratorHandler::DispatchX(XEvent* xev) {
   return DispatchXEvent(xev) ?
       base::MessagePumpGlibXDispatcher::EVENT_PROCESSED :
       base::MessagePumpGlibXDispatcher::EVENT_IGNORED;
 }
 
 }  // namespace views