Change device IDs from unsigned to signed.

ui/events/x/events_x_unittest.cc

 // Copyright (c) 2012 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 <cstring>
 #include <set>
 
 #include <X11/extensions/XInput2.h>
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
@@ skipping 212 matching lines @@
       event.xbutton.time = time_stamp.InMilliseconds();
       MouseEvent mouseev(&event);
       EXPECT_EQ(ui::ET_MOUSE_RELEASED, mouseev.type());
       EXPECT_EQ(i, mouseev.GetClickCount());
     }
     time_stamp += base::TimeDelta::FromMilliseconds(1);
   }
 }
 
 TEST_F(EventsXTest, TouchEventBasic) {
-  std::vector<unsigned int> devices;
+  std::vector<int> devices;
   devices.push_back(0);
   ui::SetUpTouchDevicesForTest(devices);
   std::vector<Valuator> valuators;
 
   // Init touch begin with tracking id 5, touch id 0.
   valuators.push_back(Valuator(DeviceDataManagerX11::DT_TOUCH_MAJOR, 20));
   valuators.push_back(
       Valuator(DeviceDataManagerX11::DT_TOUCH_ORIENTATION, 0.3f));
   valuators.push_back(Valuator(DeviceDataManagerX11::DT_TOUCH_PRESSURE, 100));
   ui::ScopedXI2Event scoped_xevent;
@@ skipping 64 matching lines @@
 int GetTouchIdForTrackingId(uint32 tracking_id) {
   int slot = 0;
   bool success =
       TouchFactory::GetInstance()->QuerySlotForTrackingID(tracking_id, &slot);
   if (success)
     return slot;
   return -1;
 }
 
 TEST_F(EventsXTest, TouchEventNotRemovingFromNativeMapping) {
-  std::vector<unsigned int> devices;
+  std::vector<int> devices;
   devices.push_back(0);
   ui::SetUpTouchDevicesForTest(devices);
   std::vector<Valuator> valuators;
 
   const int kTrackingId = 5;
 
   // Two touch presses with the same tracking id.
   ui::ScopedXI2Event xpress0;
   xpress0.InitTouchEvent(
       0, XI_TouchBegin, kTrackingId, gfx::Point(10, 10), valuators);
@@ skipping 25 matching lines @@
   {
     ui::TouchEvent urelease1(xrelease1);
   }
   EXPECT_EQ(-1, GetTouchIdForTrackingId(kTrackingId));
 }
 
 // Copied events should not remove native touch id mappings, as this causes a
 // crash (crbug.com/467102). Copied events do not contain a proper
 // base::NativeEvent and should not attempt to access it.
 TEST_F(EventsXTest, CopiedTouchEventNotRemovingFromNativeMapping) {
-  std::vector<unsigned int> devices;
+  std::vector<int> devices;
   devices.push_back(0);
   ui::SetUpTouchDevicesForTest(devices);
   std::vector<Valuator> valuators;
 
   // Create a release event which has a native touch id mapping.
   ui::ScopedXI2Event xrelease0;
   xrelease0.InitTouchEvent(0, XI_TouchEnd, 0, gfx::Point(10, 10), valuators);
   ui::TouchEvent urelease0(xrelease0);
   {
     // When the copy is destructed it should not attempt to remove the mapping.
@@ skipping 157 matching lines @@
   // Max function key code plus 1.
   EXPECT_FALSE(HasFunctionKeyFlagSetIfSupported(display, XK_F35 + 1));
 }
 
 // Verifies that the type of events from a disabled keyboard is ET_UNKNOWN, but
 // that an exception list of keys can still be processed.
 TEST_F(EventsXTest, DisableKeyboard) {
   DeviceDataManagerX11* device_data_manager =
       static_cast<DeviceDataManagerX11*>(
           DeviceDataManager::GetInstance());
-  unsigned int blocked_device_id = 1;
-  unsigned int other_device_id = 2;
-  unsigned int master_device_id = 3;
+  int blocked_device_id = 1;
+  int other_device_id = 2;
+  int master_device_id = 3;
   device_data_manager->DisableDevice(blocked_device_id);
 
   scoped_ptr<std::set<KeyboardCode> > excepted_keys(new std::set<KeyboardCode>);
   excepted_keys->insert(VKEY_B);
   device_data_manager->SetDisabledKeyboardAllowedKeys(excepted_keys.Pass());
 
   ScopedXI2Event xev;
   // A is not allowed on the blocked keyboard, and should return ET_UNKNOWN.
   xev.InitGenericKeyEvent(master_device_id,
                           blocked_device_id,
@@ skipping 34 matching lines @@
                           ui::VKEY_A,
                           0);
   EXPECT_EQ(ui::ET_KEY_PRESSED, ui::EventTypeFromNative(xev));
 }
 
 // Verifies that the type of events from a disabled mouse is ET_UNKNOWN.
 TEST_F(EventsXTest, DisableMouse) {
   DeviceDataManagerX11* device_data_manager =
       static_cast<DeviceDataManagerX11*>(
           DeviceDataManager::GetInstance());
-  unsigned int blocked_device_id = 1;
-  unsigned int other_device_id = 2;
-  std::vector<unsigned int> device_list;
+  int blocked_device_id = 1;
+  int other_device_id = 2;
+  std::vector<int> device_list;
   device_list.push_back(blocked_device_id);
   device_list.push_back(other_device_id);
   TouchFactory::GetInstance()->SetPointerDeviceForTest(device_list);
 
   device_data_manager->DisableDevice(blocked_device_id);
 
   ScopedXI2Event xev;
   xev.InitGenericButtonEvent(blocked_device_id, ET_MOUSE_PRESSED, gfx::Point(),
       EF_LEFT_MOUSE_BUTTON);
   EXPECT_EQ(ui::ET_UNKNOWN, ui::EventTypeFromNative(xev));
@@ skipping 43 matching lines @@
         KeyEventTestApi test_event(&key_event);
         test_event.set_is_char(true);
       }
       EXPECT_FALSE(key_event.flags() & ui::EF_IME_FABRICATED_KEY);
     }
   }
 }
 #endif
 
 }  // namespace ui