x11: Always require XI2.2 for X11.

ui/events/platform/x11/x11_hotplug_event_handler.cc

 // Copyright 2014 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 "ui/events/platform/x11/x11_hotplug_event_handler.h"
 
 #include <X11/Xatom.h>
 #include <X11/extensions/XInput.h>
 #include <X11/extensions/XInput2.h>
 
@@ skipping 82 matching lines @@
         name(device.name),
         use(device.use),
         enabled(device.enabled),
         path(path) {
     for (int i = 0; i < device.num_classes; ++i) {
       switch (device.classes[i]->type) {
         case XIValuatorClass:
           valuator_class_infos.push_back(ValuatorClassInfo(
               *reinterpret_cast<XIValuatorClassInfo*>(device.classes[i])));
           break;
-#if defined(USE_XI2_MT)
         case XITouchClass:
           touch_class_infos.push_back(TouchClassInfo(
               *reinterpret_cast<XITouchClassInfo*>(device.classes[i])));
           break;
-#endif
         default:
           break;
       }
     }
   }
 
   // Unique device identifier.
   int id;
 
   // Internal device name.
   std::string name;
 
   // Device type (ie: XIMasterPointer)
   int use;
 
   // Specifies if the device is enabled and can send events.
   bool enabled;
 
   // Path to the actual device (ie: /dev/input/eventXX)
   base::FilePath path;
 
   std::vector<ValuatorClassInfo> valuator_class_infos;
 
-#if defined(USE_XI2_MT)
   std::vector<TouchClassInfo> touch_class_infos;
-#endif
 };
 
 // X11 display cache used on worker threads. This is filled on the UI thread and
 // passed in to the worker threads.
 struct DisplayState {
   Atom mt_position_x;
   Atom mt_position_y;
 };
 
 // Returns true if |name| is the name of a known keyboard device. Note, this may
@@ skipping 129 matching lines @@
         }
       } else if (display_state.mt_position_y == valuator.label) {
         // Ignore Y axis valuator with unexpected properties
         if (valuator.number == 1 && valuator.mode == Absolute &&
             valuator.min == 0.0) {
           max_y = valuator.max;
         }
       }
     }
 
-#if defined(USE_XI2_MT)
     for (const TouchClassInfo& info : device_info.touch_class_infos) {
       is_direct_touch = info.mode == XIDirectTouch;
     }
-#endif
 
     // Touchscreens should have absolute X and Y axes, and be direct touch
     // devices.
     if (max_x > 0.0 && max_y > 0.0 && is_direct_touch) {
       InputDeviceType type = IsTouchscreenInternal(device_info.path)
               ? InputDeviceType::INPUT_DEVICE_INTERNAL
               : InputDeviceType::INPUT_DEVICE_EXTERNAL;
       // |max_x| and |max_y| are inclusive values, so we need to add 1 to get
       // the size.
       devices.push_back(TouchscreenDevice(
@@ skipping 65 matching lines @@
   base::WorkerPool::PostTask(FROM_HERE,
                              base::Bind(&HandleHotplugEventInWorker,
                                         device_infos,
                                         display_state,
                                         base::ThreadTaskRunnerHandle::Get(),
                                         callbacks),
                              true /* task_is_slow */);
 }
 
 }  // namespace ui