Add touch events to the protocol, the stub layer, and to the client plugin.

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 "remoting/proto/event.pb.h"
 #include "remoting/protocol/protocol_mock_objects.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 26 matching lines @@
   return arg.usb_keycode() == static_cast<uint32>(usb_keycode) &&
           arg.pressed() == pressed &&
           arg.lock_states() == kTestLockStates;
 }
 
 MATCHER_P4(EqualsMouseEvent, x, y, button, down, "") {
   return arg.x() == x && arg.y() == y && arg.button() == button &&
          arg.button_down() == down;
 }
 
+MATCHER_P2(TouchPointIdsAndTypeEqual, ids, type, "") {
+  if (arg.event_type() != type)
+    return false;
+
+  std::set<uint32> 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) {
   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(kTestLockStates);
   return event;
 }
 
 static void PressAndReleaseUsb(InputStub* input_stub,
                                uint32 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) {
+  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);
 
   {
     InSequence s;
 
     EXPECT_CALL(mock_stub, InjectKeyEvent(EqualsUsbEvent(1, true)));
     EXPECT_CALL(mock_stub, InjectKeyEvent(EqualsUsbEvent(1, false)));
@@ skipping 147 matching lines @@
   PressAndReleaseUsb(&input_tracker, 2);
 
   EXPECT_FALSE(input_tracker.IsKeyPressed(1));
   EXPECT_FALSE(input_tracker.IsKeyPressed(2));
   EXPECT_TRUE(input_tracker.IsKeyPressed(3));
   EXPECT_EQ(1, input_tracker.PressedKeyCount());
 
   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);
+  ExpectationSet injects;
+
+  std::set<uint32> expected_ids1;
+  expected_ids1.insert(1);
+  expected_ids1.insert(2);
+  std::set<uint32> expected_ids2;
+  expected_ids2.insert(3);
+  expected_ids2.insert(5);
+  expected_ids2.insert(8);
+
+  {
+    InSequence s;
+    injects += EXPECT_CALL(
+        mock_stub, InjectTouchEvent(TouchPointIdsAndTypeEqual(
+                       expected_ids1, TouchEvent::TOUCH_POINT_START)));
+    injects += EXPECT_CALL(
+        mock_stub, InjectTouchEvent(TouchPointIdsAndTypeEqual(
+                       expected_ids2, TouchEvent::TOUCH_POINT_START)));
+  }
+  std::set<uint32> 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());
+  EXPECT_CALL(mock_stub,
+              InjectTouchEvent(TouchPointIdsAndTypeEqual(
+                  all_touch_point_ids, TouchEvent::TOUCH_POINT_CANCEL)))
+      .After(injects);
+
+  TouchEvent start_event1;
+  start_event1.set_event_type(TouchEvent::TOUCH_POINT_START);
+  AddTouchPoint(1, &start_event1);
+  AddTouchPoint(2, &start_event1);
+  input_tracker.InjectTouchEvent(start_event1);
+
+  TouchEvent start_event2;
+  start_event2.set_event_type(TouchEvent::TOUCH_POINT_START);
+  AddTouchPoint(3, &start_event2);
+  AddTouchPoint(5, &start_event2);
+  AddTouchPoint(8, &start_event2);
+  input_tracker.InjectTouchEvent(start_event2);
+
+  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);
+  ExpectationSet injects;
+
+  std::set<uint32> start_expected_ids;
+  start_expected_ids.insert(1);
+  start_expected_ids.insert(2);
+  std::set<uint32> end_expected_ids;
+  end_expected_ids.insert(1);
+
+  {
+    InSequence s;
+    injects += EXPECT_CALL(
+        mock_stub,
+        InjectTouchEvent(TouchPointIdsAndTypeEqual(
+            start_expected_ids, TouchEvent::TOUCH_POINT_START)));
+    injects += EXPECT_CALL(
+        mock_stub,
+        InjectTouchEvent(TouchPointIdsAndTypeEqual(
+            end_expected_ids, TouchEvent::TOUCH_POINT_END)));
+  }
+  std::set<uint32> all_remaining_touch_point_ids;
+  all_remaining_touch_point_ids.insert(2);
+  EXPECT_CALL(mock_stub, InjectTouchEvent(TouchPointIdsAndTypeEqual(
+                             all_remaining_touch_point_ids,
+                             TouchEvent::TOUCH_POINT_CANCEL)))
+      .After(injects);
+
+  TouchEvent start_event;
+  start_event.set_event_type(TouchEvent::TOUCH_POINT_START);
+  AddTouchPoint(1, &start_event);
+  AddTouchPoint(2, &start_event);
+  input_tracker.InjectTouchEvent(start_event);
+
+  TouchEvent end_event;
+  end_event.set_event_type(TouchEvent::TOUCH_POINT_END);
+  AddTouchPoint(1, &end_event);
+  input_tracker.InjectTouchEvent(end_event);
+
+  input_tracker.ReleaseAll();
+}
+
+// All touch points are released before ReleaseAll() is called.
+TEST(InputEventTrackerTest, NoTouchPointsForReleaseAll) {
+  ::testing::StrictMock<MockInputStub> mock_stub;
+  InputEventTracker input_tracker(&mock_stub);
+
+  std::set<uint32> expected_ids;
+  expected_ids.insert(13);
+  expected_ids.insert(59);
+  {
+    InSequence s;
+    EXPECT_CALL(mock_stub,
+                InjectTouchEvent(TouchPointIdsAndTypeEqual(
+                    expected_ids, TouchEvent::TOUCH_POINT_START)));
+    EXPECT_CALL(mock_stub,
+                InjectTouchEvent(TouchPointIdsAndTypeEqual(
+                    expected_ids, TouchEvent::TOUCH_POINT_END)));
+  }
+
+  TouchEvent start_touch_event;
+  start_touch_event.set_event_type(TouchEvent::TOUCH_POINT_START);
+  AddTouchPoint(13, &start_touch_event);
+  AddTouchPoint(59, &start_touch_event);
+  input_tracker.InjectTouchEvent(start_touch_event);
+
+  TouchEvent end_touch_event;
+  end_touch_event.set_event_type(TouchEvent::TOUCH_POINT_END);
+  AddTouchPoint(13, &end_touch_event);
+  AddTouchPoint(59, &end_touch_event);
+  input_tracker.InjectTouchEvent(end_touch_event);
+
+  input_tracker.ReleaseAll();
+}
+
 }  // namespace protocol
 }  // namespace remoting