ozone: evdev: Allow setting slot values in EventDeviceInfo

ui/events/ozone/evdev/event_device_info.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/ozone/evdev/event_device_info.h"
 
 #include <linux/input.h>
 
 #include "base/logging.h"
 #include "base/threading/thread_restrictions.h"
@@ skipping 34 matching lines @@
 }
 
 // |request| needs to be the equivalent to:
 // struct input_mt_request_layout {
 //   uint32_t code;
 //   int32_t values[num_slots];
 // };
 //
 // |size| is num_slots + 1 (for code).
 bool GetSlotValues(int fd, int32_t* request, unsigned int size) {
-  if (ioctl(fd,
-            EVIOCGMTSLOTS(sizeof(int32_t) * size),
-            request) < 0) {
+  size_t data_size = size * sizeof(*request);
+
+  if (ioctl(fd, EVIOCGMTSLOTS(data_size), request) < 0) {
     DLOG(ERROR) << "failed EVIOCGMTSLOTS(" << request[0] << ") on fd " << fd;
     return false;
   }
 
   return true;
 }
 
 void AssignBitset(const unsigned long* src,
                   size_t src_len,
                   unsigned long* dst,
@@ skipping 42 matching lines @@
     return false;
 
   if (!GetPropBits(fd, prop_bits_, sizeof(prop_bits_)))
     return false;
 
   for (unsigned int i = 0; i < ABS_CNT; ++i)
     if (HasAbsEvent(i))
       if (!GetAbsInfo(fd, i, &abs_info_[i]))
         return false;
 
-  int max_num_slots = abs_info_[ABS_MT_SLOT].maximum + 1;
+  int max_num_slots = GetAbsMtSlotCount();
+
   // |request| is MT code + slots.
   int32_t request[max_num_slots + 1];
-  for (unsigned int i = ABS_MT_SLOT + 1; i < ABS_MAX; ++i) {
+  int32_t* request_code = &request[0];
+  int32_t* request_slots = &request[1];
+  for (unsigned int i = EVDEV_ABS_MT_FIRST; i <= EVDEV_ABS_MT_LAST; ++i) {
+    if (!HasAbsEvent(i))
+      continue;
+
     memset(request, 0, sizeof(request));
-    request[0] = i;
-    if (HasAbsEvent(i))
-      if (!GetSlotValues(fd, request, max_num_slots + 1))
-        LOG(WARNING) << "Failed to get multitouch values for code " << i;
+    *request_code = i;
+    if (!GetSlotValues(fd, request, max_num_slots + 1))
+      LOG(WARNING) << "Failed to get multitouch values for code " << i;
 
-    slot_values_[i - ABS_MT_SLOT - 1].assign(
-        request + 1, request + max_num_slots + 1);
+    std::vector<int32_t>* slots = &slot_values_[i - EVDEV_ABS_MT_FIRST];
+    slots->assign(request_slots, request_slots + max_num_slots);
   }
 
   return true;
 }
 
 void EventDeviceInfo::SetEventTypes(const unsigned long* ev_bits, size_t len) {
   AssignBitset(ev_bits, len, ev_bits_, arraysize(ev_bits_));
 }
 
 void EventDeviceInfo::SetKeyEvents(const unsigned long* key_bits, size_t len) {
@@ skipping 25 matching lines @@
 }
 
 void EventDeviceInfo::SetAbsInfo(unsigned int code,
                                  const input_absinfo& abs_info) {
   if (code > ABS_MAX)
     return;
 
   memcpy(&abs_info_[code], &abs_info, sizeof(abs_info));
 }
 
+void EventDeviceInfo::SetAbsMtSlots(int code,
+                                    const std::vector<int32_t>& values) {
+  DCHECK_EQ(GetAbsMtSlotCount(), values.size());
+  int index = code - EVDEV_ABS_MT_FIRST;
+  if (index < 0 || index >= EVDEV_ABS_MT_COUNT)
+    return;
+  slot_values_[index] = values;
+}
+
 bool EventDeviceInfo::HasEventType(unsigned int type) const {
   if (type > EV_MAX)
     return false;
   return EvdevBitIsSet(ev_bits_, type);
 }
 
 bool EventDeviceInfo::HasKeyEvent(unsigned int code) const {
   if (code > KEY_MAX)
     return false;
   return EvdevBitIsSet(key_bits_, code);
@@ skipping 28 matching lines @@
     return false;
   return EvdevBitIsSet(led_bits_, code);
 }
 
 bool EventDeviceInfo::HasProp(unsigned int code) const {
   if (code > INPUT_PROP_MAX)
     return false;
   return EvdevBitIsSet(prop_bits_, code);
 }
 
-int32 EventDeviceInfo::GetAbsMinimum(unsigned int code) const {
+int32_t EventDeviceInfo::GetAbsMinimum(unsigned int code) const {
   return abs_info_[code].minimum;
 }
 
-int32 EventDeviceInfo::GetAbsMaximum(unsigned int code) const {
+int32_t EventDeviceInfo::GetAbsMaximum(unsigned int code) const {
   return abs_info_[code].maximum;
 }
 
-int32 EventDeviceInfo::GetSlotValue(unsigned int code,
-                                    unsigned int slot) const {
-  const std::vector<int32_t>& slots = GetMtSlotsForCode(code);
-  DCHECK_LE(0u, slot) << slot << " is an invalid slot";
-  DCHECK_LT(slot, slots.size()) << slot << " is an invalid slot";
-  return slots[slot];
+uint32_t EventDeviceInfo::GetAbsMtSlotCount() const {
+  if (!HasAbsEvent(ABS_MT_SLOT))
+    return 0;
+  return GetAbsMaximum(ABS_MT_SLOT) + 1;
+}
+
+int32_t EventDeviceInfo::GetAbsMtSlotValue(unsigned int code,
+                                           unsigned int slot) const {
+  unsigned int index = code - EVDEV_ABS_MT_FIRST;
+  DCHECK(index < EVDEV_ABS_MT_COUNT);
+  return slot_values_[index][slot];
+}
+
+int32_t EventDeviceInfo::GetAbsMtSlotValueWithDefault(
+    unsigned int code,
+    unsigned int slot,
+    int32_t default_value) const {
+  if (!HasAbsEvent(code))
+    return default_value;
+  return GetAbsMtSlotValue(code, slot);
 }
 
 bool EventDeviceInfo::HasAbsXY() const {
   return HasAbsEvent(ABS_X) && HasAbsEvent(ABS_Y);
 }
 
 bool EventDeviceInfo::HasMTAbsXY() const {
   return HasAbsEvent(ABS_MT_POSITION_X) && HasAbsEvent(ABS_MT_POSITION_Y);
 }
 
@@ skipping 68 matching lines @@
 }
 
 bool EventDeviceInfo::HasTablet() const {
   return HasAbsXY() && HasPointer() && HasStylus();
 }
 
 bool EventDeviceInfo::HasTouchscreen() const {
   return HasAbsXY() && HasDirect();
 }
 
-const std::vector<int32_t>& EventDeviceInfo::GetMtSlotsForCode(int code) const {
-  int index = code - ABS_MT_SLOT - 1;
-  DCHECK_LE(0, index) << code << " is not a valid multi-touch code";
-  DCHECK_LT(index, EVDEV_ABS_MT_COUNT)
-      << code << " is not a valid multi-touch code";
-  return slot_values_[index];
-}
-
 EventDeviceInfo::LegacyAbsoluteDeviceType
 EventDeviceInfo::ProbeLegacyAbsoluteDevice() const {
   if (!HasAbsXY())
     return LegacyAbsoluteDeviceType::LADT_NONE;
 
   if (HasStylus())
     return LegacyAbsoluteDeviceType::LADT_TABLET;
 
   if (HasKeyEvent(BTN_TOOL_FINGER) && HasKeyEvent(BTN_TOUCH))
     return LegacyAbsoluteDeviceType::LADT_TOUCHPAD;
 
   if (HasKeyEvent(BTN_TOUCH))
     return LegacyAbsoluteDeviceType::LADT_TOUCHSCREEN;
 
   return LegacyAbsoluteDeviceType::LADT_NONE;
 }
 
 }  // namespace ui