Consolidate WebInputEvent Coalescing unit tests

content/common/input/event_with_latency_info_unittest.cc

 // Copyright 2015 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 "content/common/input/event_with_latency_info.h"
 
+#include <limits>
+
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 
 using blink::WebGestureEvent;
 using blink::WebInputEvent;
 using blink::WebMouseEvent;
 using blink::WebMouseWheelEvent;
 using blink::WebTouchEvent;
+using blink::WebTouchPoint;
+using std::numeric_limits;
 
 namespace content {
 namespace {
 
-class EventWithLatencyInfoTest : public testing::Test {
- protected:
-  TouchEventWithLatencyInfo CreateTouchEvent(WebInputEvent::Type type,
-                                             double timestamp) {
-    TouchEventWithLatencyInfo touch;
-    touch.event.touchesLength = 1;
-    touch.event.type = type;
-    touch.event.timeStampSeconds = timestamp;
-    return touch;
-  }
+using EventWithLatencyInfoTest = testing::Test;
 
-  MouseEventWithLatencyInfo CreateMouseEvent(WebInputEvent::Type type,
-                                             double timestamp) {
-    MouseEventWithLatencyInfo mouse;
-    mouse.event.type = type;
-    mouse.event.timeStampSeconds = timestamp;
-    return mouse;
-  }
+TouchEventWithLatencyInfo CreateTouchEvent(WebInputEvent::Type type,
+                                           double timestamp,
+                                           unsigned touch_count = 1) {
+  TouchEventWithLatencyInfo touch;
+  touch.event.touchesLength = touch_count;
+  touch.event.type = type;
+  touch.event.timeStampSeconds = timestamp;
+  return touch;
+}
 
-  MouseWheelEventWithLatencyInfo CreateMouseWheelEvent(double timestamp) {
-    MouseWheelEventWithLatencyInfo mouse_wheel;
-    mouse_wheel.event.type = WebInputEvent::MouseWheel;
-    mouse_wheel.event.timeStampSeconds = timestamp;
-    return mouse_wheel;
-  }
+MouseEventWithLatencyInfo CreateMouseEvent(WebInputEvent::Type type,
+                                           double timestamp) {
+  MouseEventWithLatencyInfo mouse;
+  mouse.event.type = type;
+  mouse.event.timeStampSeconds = timestamp;
+  return mouse;
+}
 
-  GestureEventWithLatencyInfo CreateGestureEvent(WebInputEvent::Type type,
-                                                 double timestamp) {
-    GestureEventWithLatencyInfo gesture;
-    gesture.event.type = type;
-    gesture.event.timeStampSeconds = timestamp;
-    return gesture;
-  }
-};
+MouseWheelEventWithLatencyInfo CreateMouseWheelEvent(double timestamp,
+                                                     float deltaX = 0.0f,
+                                                     float deltaY = 0.0f) {
+  MouseWheelEventWithLatencyInfo mouse_wheel;
+  mouse_wheel.event.type = WebInputEvent::MouseWheel;
+  mouse_wheel.event.deltaX = deltaX;
+  mouse_wheel.event.deltaY = deltaY;
+  mouse_wheel.event.timeStampSeconds = timestamp;
+  return mouse_wheel;
+}
+
+GestureEventWithLatencyInfo CreateGestureEvent(WebInputEvent::Type type,
+                                               double timestamp,
+                                               float x = 0.0f,
+                                               float y = 0.0f) {
+  GestureEventWithLatencyInfo gesture;
+  gesture.event.type = type;
+  gesture.event.x = x;
+  gesture.event.y = y;
+  gesture.event.timeStampSeconds = timestamp;
+  return gesture;
+}
 
 TEST_F(EventWithLatencyInfoTest, TimestampCoalescingForMouseEvent) {
   MouseEventWithLatencyInfo mouse_0 = CreateMouseEvent(
       WebInputEvent::MouseMove, 5.0);
   MouseEventWithLatencyInfo mouse_1 = CreateMouseEvent(
       WebInputEvent::MouseMove, 10.0);
 
   ASSERT_TRUE(mouse_0.CanCoalesceWith(mouse_1));
   mouse_0.CoalesceWith(mouse_1);
   // Coalescing WebMouseEvent preserves newer timestamp.
@@ skipping 48 matching lines @@
   EXPECT_FALSE(mouse_1.latency.FindLatency(
       ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT, 0, &component));
 
   mouse_0.CoalesceWith(mouse_1);
 
   // Coalescing WebMouseEvent preservers older LatencyInfo.
   EXPECT_TRUE(mouse_1.latency.FindLatency(
       ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT, 0, &component));
 }
 
+WebTouchPoint CreateTouchPoint(WebTouchPoint::State state, int id) {
+  WebTouchPoint touch;
+  touch.state = state;
+  touch.id = id;
+  return touch;
+}
+
+TouchEventWithLatencyInfo CreateTouch(WebInputEvent::Type type,
+                                      unsigned touch_count = 1) {
+  return CreateTouchEvent(type, 0.0, touch_count);
+}
+
+GestureEventWithLatencyInfo CreateGesture(WebInputEvent::Type type,
+                                          float x,
+                                          float y) {
+  return CreateGestureEvent(type, 0.0, x, y);
+}
+
+MouseWheelEventWithLatencyInfo CreateMouseWheel(float deltaX, float deltaY) {
+  return CreateMouseWheelEvent(0.0, deltaX, deltaY);
+}
+
+template <class T>
+bool CanCoalesce(const T& event_to_coalesce, const T& event) {
+  return event.CanCoalesceWith(event_to_coalesce);
+}
+
+template <class T>
+void Coalesce(const T& event_to_coalesce, T* event) {
+  return event->CoalesceWith(event_to_coalesce);
+}
+

[tapted, 2016/07/01 07:39:40]

Everything below here is a verbatim move except with
"TEST_F(WebInputEventTraitsTest" now "TEST_F(EventWithLatencyInfoTest". Happy to
remove some of the helper methods if you think it's nicer to consolidate
further, or make less use of default arguments.

[tdresser, 2016/07/01 12:52:42]

If anything, I'd be a fan of getting rid of the CanCoalesce and Coalesce helper
methods, but I'm fine landing this.

+TEST_F(EventWithLatencyInfoTest, TouchEventCoalescing) {
+  TouchEventWithLatencyInfo touch0 = CreateTouch(WebInputEvent::TouchStart);
+  TouchEventWithLatencyInfo touch1 = CreateTouch(WebInputEvent::TouchMove);
+
+  // Non touch-moves won't coalesce.
+  EXPECT_FALSE(CanCoalesce(touch0, touch0));
+
+  // Touches of different types won't coalesce.
+  EXPECT_FALSE(CanCoalesce(touch0, touch1));
+
+  // Touch moves with idential touch lengths and touch ids should coalesce.
+  EXPECT_TRUE(CanCoalesce(touch1, touch1));
+
+  // Touch moves with different touch ids should not coalesce.
+  touch0 = CreateTouch(WebInputEvent::TouchMove);
+  touch1 = CreateTouch(WebInputEvent::TouchMove);
+  touch0.event.touches[0].id = 7;
+  EXPECT_FALSE(CanCoalesce(touch0, touch1));
+  touch0 = CreateTouch(WebInputEvent::TouchMove, 2);
+  touch1 = CreateTouch(WebInputEvent::TouchMove, 2);
+  touch0.event.touches[0].id = 1;
+  touch1.event.touches[0].id = 0;
+  EXPECT_FALSE(CanCoalesce(touch0, touch1));
+
+  // Touch moves with different touch lengths should not coalesce.
+  touch0 = CreateTouch(WebInputEvent::TouchMove, 1);
+  touch1 = CreateTouch(WebInputEvent::TouchMove, 2);
+  EXPECT_FALSE(CanCoalesce(touch0, touch1));
+
+  // Touch moves with identical touch ids in different orders should coalesce.
+  touch0 = CreateTouch(WebInputEvent::TouchMove, 2);
+  touch1 = CreateTouch(WebInputEvent::TouchMove, 2);
+  touch0.event.touches[0] = touch1.event.touches[1] =
+      CreateTouchPoint(WebTouchPoint::StateMoved, 1);
+  touch0.event.touches[1] = touch1.event.touches[0] =
+      CreateTouchPoint(WebTouchPoint::StateMoved, 0);
+  EXPECT_TRUE(CanCoalesce(touch0, touch1));
+
+  // Pointers with the same ID's should coalesce.
+  touch0 = CreateTouch(WebInputEvent::TouchMove, 2);
+  touch1 = CreateTouch(WebInputEvent::TouchMove, 2);
+  touch0.event.touches[0] = touch1.event.touches[1] =
+      CreateTouchPoint(WebTouchPoint::StateMoved, 1);
+  Coalesce(touch0, &touch1);
+  ASSERT_EQ(1, touch1.event.touches[0].id);
+  ASSERT_EQ(0, touch1.event.touches[1].id);
+  EXPECT_EQ(WebTouchPoint::StateUndefined, touch1.event.touches[1].state);
+  EXPECT_EQ(WebTouchPoint::StateMoved, touch1.event.touches[0].state);
+
+  // Movement from now-stationary pointers should be preserved.
+  touch0 = touch1 = CreateTouch(WebInputEvent::TouchMove, 2);
+  touch0.event.touches[0] = CreateTouchPoint(WebTouchPoint::StateMoved, 1);
+  touch1.event.touches[1] = CreateTouchPoint(WebTouchPoint::StateStationary, 1);
+  touch0.event.touches[1] = CreateTouchPoint(WebTouchPoint::StateStationary, 0);
+  touch1.event.touches[0] = CreateTouchPoint(WebTouchPoint::StateMoved, 0);
+  Coalesce(touch0, &touch1);
+  ASSERT_EQ(1, touch1.event.touches[0].id);
+  ASSERT_EQ(0, touch1.event.touches[1].id);
+  EXPECT_EQ(WebTouchPoint::StateMoved, touch1.event.touches[0].state);
+  EXPECT_EQ(WebTouchPoint::StateMoved, touch1.event.touches[1].state);
+
+  // Touch moves with different dispatchTypes coalesce.
+  touch0 = CreateTouch(WebInputEvent::TouchMove, 2);
+  touch0.event.dispatchType = WebInputEvent::DispatchType::Blocking;
+  touch1 = CreateTouch(WebInputEvent::TouchMove, 2);
+  touch1.event.dispatchType = WebInputEvent::DispatchType::EventNonBlocking;
+  touch0.event.touches[0] = touch1.event.touches[1] =
+      CreateTouchPoint(WebTouchPoint::StateMoved, 1);
+  touch0.event.touches[1] = touch1.event.touches[0] =
+      CreateTouchPoint(WebTouchPoint::StateMoved, 0);
+  EXPECT_TRUE(CanCoalesce(touch0, touch1));
+  Coalesce(touch0, &touch1);
+  ASSERT_EQ(WebInputEvent::DispatchType::Blocking, touch1.event.dispatchType);
+
+  touch0 = CreateTouch(WebInputEvent::TouchMove, 2);
+  touch0.event.dispatchType =
+      WebInputEvent::DispatchType::ListenersForcedNonBlockingPassive;
+  touch1 = CreateTouch(WebInputEvent::TouchMove, 2);
+  touch1.event.dispatchType =
+      WebInputEvent::DispatchType::ListenersNonBlockingPassive;
+  touch0.event.touches[0] = touch1.event.touches[1] =
+      CreateTouchPoint(WebTouchPoint::StateMoved, 1);
+  touch0.event.touches[1] = touch1.event.touches[0] =
+      CreateTouchPoint(WebTouchPoint::StateMoved, 0);
+  EXPECT_TRUE(CanCoalesce(touch0, touch1));
+  Coalesce(touch0, &touch1);
+  ASSERT_EQ(WebInputEvent::DispatchType::ListenersNonBlockingPassive,
+            touch1.event.dispatchType);
+}
+
+TEST_F(EventWithLatencyInfoTest, PinchEventCoalescing) {
+  GestureEventWithLatencyInfo pinch0 =
+      CreateGesture(WebInputEvent::GesturePinchBegin, 1, 1);
+  GestureEventWithLatencyInfo pinch1 =
+      CreateGesture(WebInputEvent::GesturePinchUpdate, 2, 2);
+
+  // Only GesturePinchUpdate's coalesce.
+  EXPECT_FALSE(CanCoalesce(pinch0, pinch0));
+
+  // Pinch gestures of different types should not coalesce.
+  EXPECT_FALSE(CanCoalesce(pinch0, pinch1));
+
+  // Pinches with different focal points should not coalesce.
+  pinch0 = CreateGesture(WebInputEvent::GesturePinchUpdate, 1, 1);
+  pinch1 = CreateGesture(WebInputEvent::GesturePinchUpdate, 2, 2);
+  EXPECT_FALSE(CanCoalesce(pinch0, pinch1));
+  EXPECT_TRUE(CanCoalesce(pinch0, pinch0));
+
+  // Coalesced scales are multiplicative.
+  pinch0 = CreateGesture(WebInputEvent::GesturePinchUpdate, 1, 1);
+  pinch0.event.data.pinchUpdate.scale = 2.f;
+  pinch1 = CreateGesture(WebInputEvent::GesturePinchUpdate, 1, 1);
+  pinch1.event.data.pinchUpdate.scale = 3.f;
+  EXPECT_TRUE(CanCoalesce(pinch0, pinch0));
+  Coalesce(pinch0, &pinch1);
+  EXPECT_EQ(2.f * 3.f, pinch1.event.data.pinchUpdate.scale);
+
+  // Scales have a minimum value and can never reach 0.
+  ASSERT_GT(numeric_limits<float>::min(), 0);
+  pinch0 = CreateGesture(WebInputEvent::GesturePinchUpdate, 1, 1);
+  pinch0.event.data.pinchUpdate.scale = numeric_limits<float>::min() * 2.0f;
+  pinch1 = CreateGesture(WebInputEvent::GesturePinchUpdate, 1, 1);
+  pinch1.event.data.pinchUpdate.scale = numeric_limits<float>::min() * 5.0f;
+  EXPECT_TRUE(CanCoalesce(pinch0, pinch1));
+  Coalesce(pinch0, &pinch1);
+  EXPECT_EQ(numeric_limits<float>::min(), pinch1.event.data.pinchUpdate.scale);
+
+  // Scales have a maximum value and can never reach Infinity.
+  pinch0 = CreateGesture(WebInputEvent::GesturePinchUpdate, 1, 1);
+  pinch0.event.data.pinchUpdate.scale = numeric_limits<float>::max() / 2.0f;
+  pinch1 = CreateGesture(WebInputEvent::GesturePinchUpdate, 1, 1);
+  pinch1.event.data.pinchUpdate.scale = 10.0f;
+  EXPECT_TRUE(CanCoalesce(pinch0, pinch1));
+  Coalesce(pinch0, &pinch1);
+  EXPECT_EQ(numeric_limits<float>::max(), pinch1.event.data.pinchUpdate.scale);
+}
+
+TEST_F(EventWithLatencyInfoTest, WebMouseWheelEventCoalescing) {
+  MouseWheelEventWithLatencyInfo mouse_wheel_0 = CreateMouseWheel(1, 1);
+  MouseWheelEventWithLatencyInfo mouse_wheel_1 = CreateMouseWheel(2, 2);
+
+  // WebMouseWheelEvent objects with same values except different deltaX and
+  // deltaY should coalesce.
+  EXPECT_TRUE(CanCoalesce(mouse_wheel_0, mouse_wheel_1));
+
+  // WebMouseWheelEvent objects with different modifiers should not coalesce.
+  mouse_wheel_0 = CreateMouseWheel(1, 1);
+  mouse_wheel_1 = CreateMouseWheel(1, 1);
+  mouse_wheel_0.event.modifiers = WebInputEvent::ControlKey;
+  mouse_wheel_1.event.modifiers = WebInputEvent::ShiftKey;
+  EXPECT_FALSE(CanCoalesce(mouse_wheel_0, mouse_wheel_1));
+}
+
+// Coalescing preserves the newer timestamp.
+TEST_F(EventWithLatencyInfoTest, TimestampCoalescing) {
+  MouseWheelEventWithLatencyInfo mouse_wheel_0 = CreateMouseWheel(1, 1);
+  mouse_wheel_0.event.timeStampSeconds = 5.0;
+  MouseWheelEventWithLatencyInfo mouse_wheel_1 = CreateMouseWheel(2, 2);
+  mouse_wheel_1.event.timeStampSeconds = 10.0;
+
+  EXPECT_TRUE(CanCoalesce(mouse_wheel_0, mouse_wheel_1));
+  Coalesce(mouse_wheel_1, &mouse_wheel_0);
+  EXPECT_EQ(10.0, mouse_wheel_0.event.timeStampSeconds);
+}
+
 }  // namespace
 }  // namespace content