x11: Move XInput2 availability information out of the message pump.

ui/events/x/device_data_manager.cc

 // Copyright 2013 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/x/device_data_manager.h"
 
 #include <X11/extensions/XInput.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/Xlib.h>
 
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "ui/events/event_constants.h"
-#include "ui/events/event_utils.h"
 #include "ui/events/x/device_list_cache_x.h"
 #include "ui/events/x/touch_factory_x11.h"
 #include "ui/gfx/x/x11_types.h"
 
 // XIScrollClass was introduced in XI 2.1 so we need to define it here
 // for backward-compatibility with older versions of XInput.
 #if !defined(XIScrollClass)
 #define XIScrollClass 3
 #endif
 
@@ skipping 80 matching lines @@
 bool DeviceDataManager::IsTouchDataType(const int type) {
   return (type >= kTouchDataTypeStart) && (type <= kTouchDataTypeEnd);
 }
 
 DeviceDataManager* DeviceDataManager::GetInstance() {
   return Singleton<DeviceDataManager>::get();
 }
 
 DeviceDataManager::DeviceDataManager()
     : natural_scroll_enabled_(false),
+      xi_opcode_(-1),
       atom_cache_(gfx::GetXDisplay(), kCachedAtoms),
       button_map_count_(0) {
+  CHECK(gfx::GetXDisplay());
   InitializeXInputInternal();
 
   // Make sure the sizes of enum and kCachedAtoms are aligned.
   CHECK(arraysize(kCachedAtoms) == static_cast<size_t>(DT_LAST_ENTRY) + 1);
   UpdateDeviceList(gfx::GetXDisplay());
   UpdateButtonMap();
 }
 
 DeviceDataManager::~DeviceDataManager() {
 }
 
 bool DeviceDataManager::InitializeXInputInternal() {
   // 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;
   }
-  xi_opcode_ = opcode;
 
   // Check the XInput version.
 #if defined(USE_XI2_MT)
   int major = 2, minor = USE_XI2_MT;
 #else
   int major = 2, minor = 0;
 #endif
   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)) {
+    DVLOG(1) << "XI version on server is " << major << "." << minor << ". "
+            << "But 2." << USE_XI2_MT << " 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;
   xi_device_event_types_[XI_Motion] = true;
   // Multi-touch support was introduced in XI 2.2.
   if (minor >= 2) {
     xi_device_event_types_[XI_TouchBegin] = true;
     xi_device_event_types_[XI_TouchUpdate] = true;
     xi_device_event_types_[XI_TouchEnd] = true;
   }
   return true;
 }
 
+bool DeviceDataManager::IsXInput2Available() const {
+  return xi_opcode_ != -1;
+}
+
 float DeviceDataManager::GetNaturalScrollFactor(int sourceid) const {
   // Natural scroll is touchpad-only.
   if (sourceid >= kMaxDeviceNum || !touchpads_[sourceid])
     return -1.0f;
 
   return natural_scroll_enabled_ ? 1.0f : -1.0f;
 }
 
 void DeviceDataManager::UpdateDeviceList(Display* display) {
   cmt_devices_.reset();
   touchpads_.reset();
   for (int i = 0; i < kMaxDeviceNum; ++i) {
     valuator_count_[i] = 0;
     valuator_lookup_[i].clear();
     data_type_lookup_[i].clear();
     valuator_min_[i].clear();
     valuator_max_[i].clear();
     for (int j = 0; j < kMaxSlotNum; j++)
       last_seen_valuator_[i][j].clear();
   }
 
   // Find all the touchpad devices.
   XDeviceList dev_list =
       ui::DeviceListCacheX::GetInstance()->GetXDeviceList(display);
   Atom xi_touchpad = XInternAtom(display, XI_TOUCHPAD, false);
   for (int i = 0; i < dev_list.count; ++i)
     if (dev_list[i].type == xi_touchpad)
       touchpads_[dev_list[i].id] = true;
 
+  if (!IsXInput2Available())
+    return;
+
   // Update the structs with new valuator information
   XIDeviceList info_list =
       ui::DeviceListCacheX::GetInstance()->GetXI2DeviceList(display);
   Atom atoms[DT_LAST_ENTRY];
   for (int data_type = 0; data_type < DT_LAST_ENTRY; ++data_type)
     atoms[data_type] = atom_cache_.GetAtom(kCachedAtoms[data_type]);
 
   for (int i = 0; i < info_list.count; ++i) {
     XIDeviceInfo* info = info_list.devices + i;
 
@@ skipping 386 matching lines @@
                                                  int val_index,
                                                  DataType data_type,
                                                  double min,
                                                  double max) {
   valuator_lookup_[deviceid][data_type] = val_index;
   data_type_lookup_[deviceid][val_index] = data_type;
   valuator_min_[deviceid][data_type] = min;
   valuator_max_[deviceid][data_type] = max;
 }
 }  // namespace ui