Switch to standard integer types in remoting/.

remoting/protocol/input_event_tracker_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 "remoting/protocol/input_event_tracker.h"
 
+#include <stdint.h>
+
 #include "remoting/proto/event.pb.h"
 #include "remoting/protocol/protocol_mock_objects.h"
 #include "remoting/protocol/test_event_matchers.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::ExpectationSet;
 using ::testing::InSequence;
 
 namespace remoting {
 namespace protocol {
 
 using test::EqualsKeyEventWithCapsLock;
 using test::EqualsMouseEvent;
 using test::EqualsKeyEventWithoutLockStates;
 
 namespace {
 
 static const MouseEvent::MouseButton BUTTON_LEFT = MouseEvent::BUTTON_LEFT;
 static const MouseEvent::MouseButton BUTTON_RIGHT = MouseEvent::BUTTON_RIGHT;
 
 MATCHER_P2(TouchPointIdsAndTypeEqual, ids, type, "") {
   if (arg.event_type() != type)
     return false;
 
-  std::set<uint32> touch_ids;
+  std::set<uint32_t> touch_ids;
   for (const TouchEventPoint& point : arg.touch_points()) {
     touch_ids.insert(point.id());
   }
   return touch_ids == ids;
 }
 
-static KeyEvent NewUsbEvent(uint32 usb_keycode, bool pressed) {
+static KeyEvent NewUsbEvent(uint32_t usb_keycode, bool pressed) {
   KeyEvent event;
   event.set_usb_keycode(usb_keycode);
   event.set_pressed(pressed);
   // Create all key events with the hardcoded |lock_state| in this test.
   event.set_lock_states(KeyEvent::LOCK_STATES_CAPSLOCK);
   return event;
 }
 
-static void PressAndReleaseUsb(InputStub* input_stub, uint32 usb_keycode) {
+static void PressAndReleaseUsb(InputStub* input_stub, uint32_t usb_keycode) {
   input_stub->InjectKeyEvent(NewUsbEvent(usb_keycode, true));
   input_stub->InjectKeyEvent(NewUsbEvent(usb_keycode, false));
 }
 
 static MouseEvent NewMouseEvent(int x,
                                 int y,
                                 MouseEvent::MouseButton button,
                                 bool down) {
   MouseEvent event;
   event.set_x(x);
   event.set_y(y);
   event.set_button(button);
   event.set_button_down(down);
   return event;
 }
 
-void AddTouchPoint(uint32 id, TouchEvent* event) {
+void AddTouchPoint(uint32_t id, TouchEvent* event) {
   TouchEventPoint* p = event->add_touch_points();
   p->set_id(id);
 }
 
 }  // namespace
 
 // Verify that keys that were pressed and released aren't re-released.
 TEST(InputEventTrackerTest, NothingToRelease) {
   MockInputStub mock_stub;
   InputEventTracker input_tracker(&mock_stub);
@@ skipping 176 matching lines @@
 
   input_tracker.ReleaseAll();
 }
 
 // All touch points added with multiple touch events should be released as a
 // cancel event.
 TEST(InputEventTrackerTest, ReleaseAllTouchPoints) {
   MockInputStub mock_stub;
   InputEventTracker input_tracker(&mock_stub);
 
-  std::set<uint32> expected_ids1;
+  std::set<uint32_t> expected_ids1;
   expected_ids1.insert(1);
   expected_ids1.insert(2);
-  std::set<uint32> expected_ids2;
+  std::set<uint32_t> expected_ids2;
   expected_ids2.insert(3);
   expected_ids2.insert(5);
   expected_ids2.insert(8);
 
-  std::set<uint32> all_touch_point_ids;
+  std::set<uint32_t> all_touch_point_ids;
   all_touch_point_ids.insert(expected_ids1.begin(), expected_ids1.end());
   all_touch_point_ids.insert(expected_ids2.begin(), expected_ids2.end());
 
   InSequence s;
   EXPECT_CALL(mock_stub, InjectTouchEvent(TouchPointIdsAndTypeEqual(
                              expected_ids1, TouchEvent::TOUCH_POINT_START)));
   EXPECT_CALL(mock_stub, InjectTouchEvent(TouchPointIdsAndTypeEqual(
                              expected_ids2, TouchEvent::TOUCH_POINT_START)));
 
   EXPECT_CALL(mock_stub,
@@ skipping 15 matching lines @@
 
   input_tracker.ReleaseAll();
 }
 
 // Add some touch points and remove only a subset of them. ReleaseAll() should
 // cancel all the remaining touch points.
 TEST(InputEventTrackerTest, ReleaseAllRemainingTouchPoints) {
   MockInputStub mock_stub;
   InputEventTracker input_tracker(&mock_stub);
 
-  std::set<uint32> start_expected_ids;
+  std::set<uint32_t> start_expected_ids;
   start_expected_ids.insert(1);
   start_expected_ids.insert(2);
   start_expected_ids.insert(3);
 
-  std::set<uint32> end_expected_ids;
+  std::set<uint32_t> end_expected_ids;
   end_expected_ids.insert(1);
-  std::set<uint32> cancel_expected_ids;
+  std::set<uint32_t> cancel_expected_ids;
   cancel_expected_ids.insert(3);
 
-  std::set<uint32> all_remaining_touch_point_ids;
+  std::set<uint32_t> all_remaining_touch_point_ids;
   all_remaining_touch_point_ids.insert(2);
 
   InSequence s;
   EXPECT_CALL(mock_stub,
               InjectTouchEvent(TouchPointIdsAndTypeEqual(
                   start_expected_ids, TouchEvent::TOUCH_POINT_START)));
   EXPECT_CALL(mock_stub, InjectTouchEvent(TouchPointIdsAndTypeEqual(
                              end_expected_ids, TouchEvent::TOUCH_POINT_END)));
   EXPECT_CALL(mock_stub,
               InjectTouchEvent(TouchPointIdsAndTypeEqual(
@@ skipping 18 matching lines @@
   TouchEvent cancel_event;
   cancel_event.set_event_type(TouchEvent::TOUCH_POINT_CANCEL);
   AddTouchPoint(3, &cancel_event);
   input_tracker.InjectTouchEvent(cancel_event);
 
   input_tracker.ReleaseAll();
 }
 
 }  // namespace protocol
 }  // namespace remoting