Merge DeviceDataManagerX11 valuator information.

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 <stddef.h>
 #include <X11/extensions/XInput.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/Xlib.h>
@@ skipping 214 matching lines @@
 }
 
 void DeviceDataManagerX11::UpdateDeviceList(Display* display) {
   cmt_devices_.reset();
   touchpads_.reset();
   master_pointers_.clear();
   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();
     scroll_data_[i].horizontal.number = -1;
     scroll_data_[i].horizontal.seen = false;
     scroll_data_[i].vertical.number = -1;
     scroll_data_[i].vertical.seen = false;
     for (int j = 0; j < kMaxSlotNum; j++)
       last_seen_valuator_[i][j].clear();
   }
 
   // Find all the touchpad devices.
   const XDeviceList& dev_list =
@@ skipping 31 matching lines @@
       if (info.classes[j]->type == XIValuatorClass)
         ++valuator_count_[deviceid];
       else if (info.classes[j]->type == XIScrollClass)
         not_cmt = true;
     }
 
     // Skip devices that don't use any valuator
     if (!valuator_count_[deviceid])
       continue;
 
-    valuator_lookup_[deviceid].resize(DT_LAST_ENTRY, -1);
+    valuator_lookup_[deviceid].resize(DT_LAST_ENTRY);
     data_type_lookup_[deviceid].resize(
         valuator_count_[deviceid], DT_LAST_ENTRY);
-    valuator_min_[deviceid].resize(DT_LAST_ENTRY, 0);
-    valuator_max_[deviceid].resize(DT_LAST_ENTRY, 0);
     for (int j = 0; j < kMaxSlotNum; j++)
       last_seen_valuator_[deviceid][j].resize(DT_LAST_ENTRY, 0);
     for (int j = 0; j < info.num_classes; ++j) {
       if (info.classes[j]->type == XIValuatorClass) {
         if (UpdateValuatorClassDevice(
                 reinterpret_cast<XIValuatorClassInfo*>(info.classes[j]), atoms,
                 deviceid))
           possible_cmt = true;
       } else if (info.classes[j]->type == XIScrollClass) {
         UpdateScrollClassDevice(
@@ skipping 63 matching lines @@
     if (xiev->evtype == XI_TouchBegin ||
         xiev->evtype == XI_TouchEnd ||
         xiev->evtype == XI_TouchUpdate) {
       *value = xiev->detail;
     } else {
       *value = 0;
     }
     return true;
   }
 
-  int val_index = valuator_lookup_[sourceid][type];
+  int val_index = valuator_lookup_[sourceid][type].number;
   int slot = 0;
   if (val_index >= 0) {
     if (XIMaskIsSet(xiev->valuators.mask, val_index)) {
       double* valuators = xiev->valuators.values;
       while (val_index--) {
         if (XIMaskIsSet(xiev->valuators.mask, val_index))
           ++valuators;
       }
       *value = *valuators;
       if (IsTouchDataType(type)) {
@@ skipping 73 matching lines @@
   return (IsScrollEvent(xev) || IsFlingEvent(xev) || IsCMTMetricsEvent(xev));
 }
 
 bool DeviceDataManagerX11::HasEventData(
     const XIDeviceEvent* xiev, const DataType type) const {
   CHECK_GE(xiev->sourceid, 0);
   if (xiev->sourceid >= kMaxDeviceNum)
     return false;
   if (type >= valuator_lookup_[xiev->sourceid].size())
     return false;
-  const int idx = valuator_lookup_[xiev->sourceid][type];
+  const int idx = valuator_lookup_[xiev->sourceid][type].number;
   return (idx >= 0) && XIMaskIsSet(xiev->valuators.mask, idx);
 }
 
 bool DeviceDataManagerX11::IsScrollEvent(const XEvent& xev) const {
   if (!IsCMTDeviceEvent(xev))
     return false;
 
   XIDeviceEvent* xiev = static_cast<XIDeviceEvent*>(xev.xcookie.data);
   return (HasEventData(xiev, DT_CMT_SCROLL_X) ||
           HasEventData(xiev, DT_CMT_SCROLL_Y));
@@ skipping 194 matching lines @@
 
 bool DeviceDataManagerX11::GetDataRange(int deviceid,
                                         const DataType type,
                                         double* min,
                                         double* max) {
   CHECK_GE(deviceid, 0);
   if (deviceid >= kMaxDeviceNum)
     return false;
   if (valuator_lookup_[deviceid].empty())
     return false;
-  if (valuator_lookup_[deviceid][type] >= 0) {
-    *min = valuator_min_[deviceid][type];
-    *max = valuator_max_[deviceid][type];
+  if (valuator_lookup_[deviceid][type].number >= 0) {
+    *min = valuator_lookup_[deviceid][type].min;
+    *max = valuator_lookup_[deviceid][type].max;
     return true;
   }
   return false;
 }
 
 void DeviceDataManagerX11::SetDeviceListForTest(
     const std::vector<int>& touchscreen,
     const std::vector<int>& cmt_devices,
     const std::vector<int>& other_devices) {
   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();
   }
 
   for (int deviceid : touchscreen) {
     InitializeValuatorsForTest(deviceid, kTouchDataTypeStart, kTouchDataTypeEnd,
                                0, 1000);
   }
 
   cmt_devices_.reset();
   for (int deviceid : cmt_devices) {
     cmt_devices_[deviceid] = true;
     touchpads_[deviceid] = true;
     InitializeValuatorsForTest(deviceid, kCMTDataTypeStart, kCMTDataTypeEnd,
                                -1000, 1000);
   }
 
   for (int deviceid : other_devices) {
     InitializeValuatorsForTest(deviceid, kCMTDataTypeStart, kCMTDataTypeEnd,
                                -1000, 1000);
   }
 }
 
 void DeviceDataManagerX11::SetValuatorDataForTest(XIDeviceEvent* xievent,
                                                   DataType type,
                                                   double value) {
-  int index = valuator_lookup_[xievent->deviceid][type];
+  int index = valuator_lookup_[xievent->deviceid][type].number;
   CHECK(!XIMaskIsSet(xievent->valuators.mask, index));
   CHECK(index >= 0 && index < valuator_count_[xievent->deviceid]);
   XISetMask(xievent->valuators.mask, index);
 
   double* valuators = xievent->valuators.values;
   for (int i = 0; i < index; ++i) {
     if (XIMaskIsSet(xievent->valuators.mask, i))
       valuators++;
   }
   for (int i = DT_LAST_ENTRY - 1; i > valuators - xievent->valuators.values;
        --i)
     xievent->valuators.values[i] = xievent->valuators.values[i - 1];
   *valuators = value;
 }
 
 void DeviceDataManagerX11::InitializeValuatorsForTest(int deviceid,
                                                       int start_valuator,
                                                       int end_valuator,
                                                       double min_value,
                                                       double max_value) {
-  valuator_lookup_[deviceid].resize(DT_LAST_ENTRY, -1);
+  valuator_lookup_[deviceid].resize(DT_LAST_ENTRY);
   data_type_lookup_[deviceid].resize(DT_LAST_ENTRY, DT_LAST_ENTRY);
-  valuator_min_[deviceid].resize(DT_LAST_ENTRY, 0);
-  valuator_max_[deviceid].resize(DT_LAST_ENTRY, 0);
   for (int j = 0; j < kMaxSlotNum; j++)
     last_seen_valuator_[deviceid][j].resize(DT_LAST_ENTRY, 0);
   for (int j = start_valuator; j <= end_valuator; ++j) {
-    valuator_lookup_[deviceid][j] = valuator_count_[deviceid];
+    valuator_lookup_[deviceid][j].number = valuator_count_[deviceid];

[sadrul, 2017/05/01 16:03:56]

Maybe something like:
  ValuatorInfo* info = &valuator_look_[device_id][j];
  info->... = ...

and so on

[kylechar, 2017/05/01 16:10:17]

Done with "auto& valuator_info = ...".

+    valuator_lookup_[deviceid][j].min = min_value;
+    valuator_lookup_[deviceid][j].max = max_value;
     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::UpdateValuatorClassDevice(
     XIValuatorClassInfo* valuator_class_info,
     Atom* atoms,
     int deviceid) {
   DCHECK(deviceid >= 0 && deviceid < kMaxDeviceNum);
   Atom* label =
       std::find(atoms, atoms + DT_LAST_ENTRY, valuator_class_info->label);
   if (label == atoms + DT_LAST_ENTRY) {
     return false;
   }
   int data_type = label - atoms;
   DCHECK_GE(data_type, 0);
   DCHECK_LT(data_type, DT_LAST_ENTRY);
 
-  valuator_lookup_[deviceid][data_type] = valuator_class_info->number;
+  valuator_lookup_[deviceid][data_type].number = valuator_class_info->number;
+  valuator_lookup_[deviceid][data_type].min = valuator_class_info->min;
+  valuator_lookup_[deviceid][data_type].max = valuator_class_info->max;

[sadrul, 2017/05/01 16:03:56]

ditto

[kylechar, 2017/05/01 16:10:17]

Done.

   data_type_lookup_[deviceid][valuator_class_info->number] = data_type;
-  valuator_min_[deviceid][data_type] = valuator_class_info->min;
-  valuator_max_[deviceid][data_type] = valuator_class_info->max;
   return IsCMTDataType(data_type);
 }
 
 void DeviceDataManagerX11::UpdateScrollClassDevice(
     XIScrollClassInfo* scroll_class_info,
     int deviceid) {
   if (high_precision_scrolling_disabled_)
     return;
 
   DCHECK(deviceid >= 0 && deviceid < kMaxDeviceNum);
@@ skipping 108 matching lines @@
     } else {
       keyboards.erase(it);
       ++blocked_iter;
     }
   }
   // Notify base class of updated list.
   DeviceDataManager::OnKeyboardDevicesUpdated(keyboards);
 }
 
 }  // namespace ui