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)));
+  }

[Wez, 2015/02/05 02:09:07]

nit: Blank line between this and the next block

[Rintaro Kuroiwa, 2015/02/06 23:35:02]

Done.

+  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);

[Wez, 2015/02/05 02:09:07]

Why is this not just in the sequence |s|?

[Rintaro Kuroiwa, 2015/02/06 23:35:02]

This test works with InSequence. Removed ExpecatationSet.

+
+  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)));
+  }

[Wez, 2015/02/05 02:09:07]

nit: Blank line before next logical block.

[Rintaro Kuroiwa, 2015/02/06 23:35:02]

Done.

+  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);

[Wez, 2015/02/05 02:09:07]

Why is this not just in the sequence |s|?

[Rintaro Kuroiwa, 2015/02/06 23:35:02]

This test works with InSequence. Removed ExpecatationSet.

+
+  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.

[Wez, 2015/02/05 02:09:08]

Do you mean "test that no touch events are generated if all events are released
before releaseall() is called"?

This test feels a little overkill, given the test above; it's just a degenerate
case of injecting and then removing some touch points before releasing?

[Rintaro Kuroiwa, 2015/02/06 23:35:02]

Yes, that's what I meant :)

True, the test above tests that END (I should test CANCEL) event does remove the
point and will not be in ReleaseAll(). Removing this test.

And adding CANCEL event to the test above.

+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