Change device IDs from unsigned to signed.

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 93 matching lines @@
 // types.
 const int kCMTDataTypeStart = ui::DeviceDataManagerX11::DT_CMT_SCROLL_X;
 const int kCMTDataTypeEnd = ui::DeviceDataManagerX11::DT_CMT_FINGER_COUNT;
 const int kTouchDataTypeStart = ui::DeviceDataManagerX11::DT_TOUCH_MAJOR;
 const int kTouchDataTypeEnd = ui::DeviceDataManagerX11::DT_TOUCH_RAW_TIMESTAMP;
 
 namespace ui {
 
 namespace {
 
-bool DeviceHasId(const ui::InputDevice input_device, unsigned int id) {
+bool DeviceHasId(const ui::InputDevice input_device, int id) {
   return input_device.id == id;
 }
 
 }  // namespace
 
 bool DeviceDataManagerX11::IsCMTDataType(const int type) {
   return (type >= kCMTDataTypeStart) && (type <= kCMTDataTypeEnd);
 }
 
 bool DeviceDataManagerX11::IsTouchDataType(const int type) {
@@ skipping 438 matching lines @@
 
   EventData data;
   GetEventRawData(*native_event, &data);
 
   if (data.find(DT_CMT_START_TIME) != data.end())
     *start_time = data[DT_CMT_START_TIME];
   if (data.find(DT_CMT_END_TIME) != data.end())
     *end_time = data[DT_CMT_END_TIME];
 }
 
-bool DeviceDataManagerX11::NormalizeData(unsigned int deviceid,
+bool DeviceDataManagerX11::NormalizeData(int deviceid,
                                          const DataType type,
                                          double* value) {
   double max_value;
   double min_value;
   if (GetDataRange(deviceid, type, &min_value, &max_value)) {
     *value = (*value - min_value) / (max_value - min_value);
     DCHECK(*value >= 0.0 && *value <= 1.0);
     return true;
   }
   return false;
 }
 
-bool DeviceDataManagerX11::GetDataRange(unsigned int deviceid,
+bool DeviceDataManagerX11::GetDataRange(int deviceid,
                                         const DataType type,
                                         double* min,
                                         double* max) {
-  if (deviceid >= static_cast<unsigned int>(kMaxDeviceNum))
+  if (deviceid >= kMaxDeviceNum)
     return false;
   if (valuator_lookup_[deviceid][type] >= 0) {
     *min = valuator_min_[deviceid][type];
     *max = valuator_max_[deviceid][type];
     return true;
   }
   return false;
 }
 
 void DeviceDataManagerX11::SetDeviceListForTest(
-    const std::vector<unsigned int>& touchscreen,
-    const std::vector<unsigned int>& cmt_devices) {
+    const std::vector<int>& touchscreen,
+    const std::vector<int>& cmt_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 (size_t i = 0; i < touchscreen.size(); i++) {
-    unsigned int deviceid = touchscreen[i];
+    int deviceid = touchscreen[i];
     InitializeValuatorsForTest(deviceid, kTouchDataTypeStart, kTouchDataTypeEnd,
                                0, 1000);
   }
 
   cmt_devices_.reset();
   for (size_t i = 0; i < cmt_devices.size(); ++i) {
-    unsigned int deviceid = cmt_devices[i];
+    int deviceid = cmt_devices[i];
     cmt_devices_[deviceid] = true;
     touchpads_[deviceid] = true;
     InitializeValuatorsForTest(deviceid, kCMTDataTypeStart, kCMTDataTypeEnd,
                                -1000, 1000);
   }
 }
 
 void DeviceDataManagerX11::SetValuatorDataForTest(XIDeviceEvent* xievent,
                                                   DataType type,
                                                   double value) {
@@ skipping 26 matching lines @@
     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];
     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 {
+bool DeviceDataManagerX11::TouchEventNeedsCalibrate(int touch_device_id) const {
 #if defined(OS_CHROMEOS)
   if (!base::SysInfo::IsRunningOnChromeOS())
     return false;
 
   const std::vector<TouchscreenDevice>& touch_devices =
       ui::DeviceDataManager::GetInstance()->touchscreen_devices();
   std::vector<TouchscreenDevice>::const_iterator it =
       std::find_if(touch_devices.begin(), touch_devices.end(),
                    std::bind2nd(std::ptr_fun(&DeviceHasId), touch_device_id));
   return it != touch_devices.end() && it->type == INPUT_DEVICE_INTERNAL;
 #endif  // defined(OS_CHROMEOS)
   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();
 }
 
-void DeviceDataManagerX11::DisableDevice(unsigned int deviceid) {
+void DeviceDataManagerX11::DisableDevice(int deviceid) {
   blocked_devices_.set(deviceid, true);
   // TODO(rsadam@): Support blocking touchscreen devices.
   std::vector<KeyboardDevice> keyboards = keyboard_devices();
   std::vector<KeyboardDevice>::iterator it =
       std::find_if(keyboards.begin(),
                    keyboards.end(),
                    std::bind2nd(std::ptr_fun(&DeviceHasId), deviceid));
   if (it != std::end(keyboards)) {
     blocked_keyboards_.insert(
-        std::pair<unsigned int, KeyboardDevice>(deviceid, *it));
+        std::pair<int, KeyboardDevice>(deviceid, *it));
     keyboards.erase(it);
     DeviceDataManager::OnKeyboardDevicesUpdated(keyboards);
   }
 }
 
-void DeviceDataManagerX11::EnableDevice(unsigned int deviceid) {
+void DeviceDataManagerX11::EnableDevice(int deviceid) {
   blocked_devices_.set(deviceid, false);
-  std::map<unsigned int, KeyboardDevice>::iterator it =
+  std::map<int, KeyboardDevice>::iterator it =
       blocked_keyboards_.find(deviceid);
   if (it != blocked_keyboards_.end()) {
     std::vector<KeyboardDevice> devices = keyboard_devices();
     // Add device to current list of active devices.
     devices.push_back((*it).second);
     blocked_keyboards_.erase(it);
     DeviceDataManager::OnKeyboardDevicesUpdated(devices);
   }
 }
 
@@ skipping 13 matching lines @@
           blocked_keyboard_allowed_keys_->end()) {
     return false;
   }
 
   return blocked_devices_.test(xievent->sourceid);
 }
 
 void DeviceDataManagerX11::OnKeyboardDevicesUpdated(
     const std::vector<KeyboardDevice>& devices) {
   std::vector<KeyboardDevice> keyboards(devices);
-  for (std::map<unsigned int, KeyboardDevice>::iterator blocked_iter =
+  for (std::map<int, KeyboardDevice>::iterator blocked_iter =
            blocked_keyboards_.begin();
        blocked_iter != blocked_keyboards_.end();) {
     // Check if the blocked device still exists in list of devices.
     std::vector<KeyboardDevice>::iterator it = std::find_if(
         keyboards.begin(), keyboards.end(),
         std::bind2nd(std::ptr_fun(&DeviceHasId), (*blocked_iter).first));
     // If the device no longer exists, unblock it, else filter it out from our
     // active list.
     if (it == keyboards.end()) {
       blocked_devices_.set((*blocked_iter).first, false);
       blocked_keyboards_.erase(blocked_iter++);
     } else {
       keyboards.erase(it);
       ++blocked_iter;
     }
   }
   // Notify base class of updated list.
   DeviceDataManager::OnKeyboardDevicesUpdated(keyboards);
 }
 
 }  // namespace ui