x11: Always require XI2.2 for X11.

ui/events/devices/x11/device_data_manager_x11.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/devices/x11/device_data_manager_x11.h"
 
 #include <X11/extensions/XInput.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/Xlib.h>
 
@@ skipping 147 matching lines @@
   // Check if XInput is available on the system.
   xi_opcode_ = -1;
   int opcode, event, error;
   if (!XQueryExtension(
       gfx::GetXDisplay(), "XInputExtension", &opcode, &event, &error)) {
     VLOG(1) << "X Input extension not available: error=" << error;
     return false;
   }
 
   // Check the XInput version.
-#if defined(USE_XI2_MT)
-  int major = 2, minor = USE_XI2_MT;
-#else
-  int major = 2, minor = 0;
-#endif
+  int major = 2, minor = 2;
   if (XIQueryVersion(gfx::GetXDisplay(), &major, &minor) == BadRequest) {
     VLOG(1) << "XInput2 not supported in the server.";
     return false;
   }
-#if defined(USE_XI2_MT)
-  if (major < 2 || (major == 2 && minor < USE_XI2_MT)) {
+  if (major < 2 || (major == 2 && minor < 2)) {
     DVLOG(1) << "XI version on server is " << major << "." << minor << ". "
-            << "But 2." << USE_XI2_MT << " is required.";
+            << "But 2.2 is required.";
     return false;
   }
-#endif
 
   xi_opcode_ = opcode;
   CHECK_NE(-1, xi_opcode_);
 
   // Possible XI event types for XIDeviceEvent. See the XI2 protocol
   // specification.
   xi_device_event_types_[XI_KeyPress] = true;
   xi_device_event_types_[XI_KeyRelease] = true;
   xi_device_event_types_[XI_ButtonPress] = true;
   xi_device_event_types_[XI_ButtonRelease] = true;
@@ skipping 89 matching lines @@
         }
       }
     }
 
     if (possible_cmt && !not_cmt)
       cmt_devices_[deviceid] = true;
   }
 }
 
 bool DeviceDataManagerX11::GetSlotNumber(const XIDeviceEvent* xiev, int* slot) {
-#if defined(USE_XI2_MT)
   ui::TouchFactory* factory = ui::TouchFactory::GetInstance();
   if (!factory->IsMultiTouchDevice(xiev->sourceid)) {
     *slot = 0;
     return true;
   }
   return factory->QuerySlotForTrackingID(xiev->detail, slot);
-#else
-  *slot = 0;
-  return true;
-#endif
 }
 
 void DeviceDataManagerX11::GetEventRawData(const XEvent& xev, EventData* data) {
   if (xev.type != GenericEvent)
     return;
 
   XIDeviceEvent* xiev = static_cast<XIDeviceEvent*>(xev.xcookie.data);
   if (xiev->sourceid >= kMaxDeviceNum || xiev->deviceid >= kMaxDeviceNum)
     return;
   data->clear();
@@ skipping 353 matching lines @@
     valuator_lookup_[deviceid][j] = valuator_count_[deviceid];
     data_type_lookup_[deviceid][valuator_count_[deviceid]] = j;
     valuator_min_[deviceid][j] = min_value;
     valuator_max_[deviceid][j] = max_value;
     valuator_count_[deviceid]++;
   }
 }
 
 bool DeviceDataManagerX11::TouchEventNeedsCalibrate(
     unsigned int touch_device_id) const {
-#if defined(OS_CHROMEOS) && defined(USE_XI2_MT)
+#if defined(OS_CHROMEOS) && defined(USE_X11)
   int64 touch_display_id = GetDisplayForTouchDevice(touch_device_id);
   if (base::SysInfo::IsRunningOnChromeOS() &&
       touch_display_id == gfx::Display::InternalDisplayId()) {
     return true;
   }
-#endif  // defined(OS_CHROMEOS) && defined(USE_XI2_MT)
+#endif  // defined(OS_CHROMEOS) && defined(USE_X11)
   return false;
 }
 
 void DeviceDataManagerX11::SetDisabledKeyboardAllowedKeys(
     scoped_ptr<std::set<KeyboardCode> > excepted_keys) {
   DCHECK(!excepted_keys.get() ||
          !blocked_keyboard_allowed_keys_.get());
   blocked_keyboard_allowed_keys_ = excepted_keys.Pass();
 }
 
@@ skipping 66 matching lines @@
     } else {
       keyboards.erase(it);
       ++blocked_iter;
     }
   }
   // Notify base class of updated list.
   DeviceDataManager::OnKeyboardDevicesUpdated(keyboards);
 }
 
 }  // namespace ui