Add getCoalescedEvents API to PointerEvent

third_party/WebKit/Source/core/events/PointerEventFactoryTest.cpp

 // 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 "core/events/PointerEventFactory.h"
 
 #include "core/frame/FrameView.h"
 #include "core/page/Page.h"
 #include "public/platform/WebPointerProperties.h"
 #include <climits>
 #include <gtest/gtest.h>
 
 namespace blink {
 
+namespace {
+
+const char* pointerTypeNameForWebPointPointerType(
+    WebPointerProperties::PointerType type) {
+  switch (type) {
+    case WebPointerProperties::PointerType::Unknown:
+      return "";
+    case WebPointerProperties::PointerType::Touch:
+      return "touch";
+    case WebPointerProperties::PointerType::Pen:
+    case WebPointerProperties::PointerType::Eraser:
+      return "pen";
+    case WebPointerProperties::PointerType::Mouse:
+      return "mouse";
+  }
+  NOTREACHED();
+  return "";
+}
+}
+
 class PointerEventFactoryTest : public ::testing::Test {
  protected:
   void SetUp() override;
   PointerEvent* createAndCheckTouchCancel(WebPointerProperties::PointerType,
                                           int rawId,
                                           int uniqueId,
                                           bool isPrimary);
   PointerEvent* createAndCheckTouchEvent(
       WebPointerProperties::PointerType,
       int rawId,
       int uniqueId,
       bool isPrimary,
-      PlatformTouchPoint::TouchState = PlatformTouchPoint::TouchPressed);
+      PlatformTouchPoint::TouchState = PlatformTouchPoint::TouchPressed,
+      size_t coalescedEventCount = 0);
   PointerEvent* createAndCheckMouseEvent(
       WebPointerProperties::PointerType,
       int rawId,
       int uniqueId,
       bool isPrimary,
-      PlatformEvent::Modifiers = PlatformEvent::NoModifiers);
+      PlatformEvent::Modifiers = PlatformEvent::NoModifiers,
+      size_t coalescedEventCount = 0);
   void createAndCheckPointerTransitionEvent(PointerEvent*, const AtomicString&);
 
   PointerEventFactory m_pointerEventFactory;
   unsigned m_expectedMouseId;
   unsigned m_mappedIdStart;
 
   class PlatformTouchPointBuilder : public PlatformTouchPoint {
    public:
     PlatformTouchPointBuilder(WebPointerProperties::PointerType,
                               int,
@@ skipping 34 matching lines @@
 
 PointerEvent* PointerEventFactoryTest::createAndCheckTouchCancel(
     WebPointerProperties::PointerType pointerType,
     int rawId,
     int uniqueId,
     bool isPrimary) {
   PointerEvent* pointerEvent =
       m_pointerEventFactory.createPointerCancelEvent(uniqueId, pointerType);
   EXPECT_EQ(uniqueId, pointerEvent->pointerId());
   EXPECT_EQ(isPrimary, pointerEvent->isPrimary());
+  EXPECT_EQ(pointerTypeNameForWebPointPointerType(pointerType),
+            pointerEvent->pointerType());
   return pointerEvent;
 }
 
 void PointerEventFactoryTest::createAndCheckPointerTransitionEvent(
     PointerEvent* pointerEvent,
     const AtomicString& type) {
   PointerEvent* clonePointerEvent =
       m_pointerEventFactory.createPointerBoundaryEvent(pointerEvent, type,
                                                        nullptr);
   EXPECT_EQ(clonePointerEvent->pointerType(), pointerEvent->pointerType());
   EXPECT_EQ(clonePointerEvent->pointerId(), pointerEvent->pointerId());
   EXPECT_EQ(clonePointerEvent->isPrimary(), pointerEvent->isPrimary());
   EXPECT_EQ(clonePointerEvent->type(), type);
 }
 
 PointerEvent* PointerEventFactoryTest::createAndCheckTouchEvent(
     WebPointerProperties::PointerType pointerType,
     int rawId,
     int uniqueId,
     bool isPrimary,
-    PlatformTouchPoint::TouchState state) {
+    PlatformTouchPoint::TouchState state,
+    size_t coalescedEventCount) {
+  Vector<PlatformTouchPoint> coalescedEvents;
+  for (size_t i = 0; i < coalescedEventCount; i++) {
+    coalescedEvents.append(PointerEventFactoryTest::PlatformTouchPointBuilder(
+        pointerType, rawId, state));
+  }
   PointerEvent* pointerEvent = m_pointerEventFactory.create(
-      EventTypeNames::pointerdown,
       PointerEventFactoryTest::PlatformTouchPointBuilder(pointerType, rawId,
                                                          state),
-      PlatformEvent::NoModifiers, FloatSize(), FloatPoint(), nullptr);
+      coalescedEvents, PlatformEvent::NoModifiers, nullptr, nullptr);
   EXPECT_EQ(uniqueId, pointerEvent->pointerId());
   EXPECT_EQ(isPrimary, pointerEvent->isPrimary());
+  const char* expectedPointerType =
+      pointerTypeNameForWebPointPointerType(pointerType);
+  EXPECT_EQ(expectedPointerType, pointerEvent->pointerType());
+  EXPECT_EQ(coalescedEventCount, pointerEvent->getCoalescedEvents().size());
+  for (size_t i = 0; i < coalescedEventCount; i++) {
+    EXPECT_EQ(uniqueId, pointerEvent->getCoalescedEvents()[i]->pointerId());
+    EXPECT_EQ(isPrimary, pointerEvent->getCoalescedEvents()[i]->isPrimary());
+    EXPECT_EQ(expectedPointerType, pointerEvent->pointerType());
+  }
   return pointerEvent;
 }
 
 PointerEvent* PointerEventFactoryTest::createAndCheckMouseEvent(
     WebPointerProperties::PointerType pointerType,
     int rawId,
     int uniqueId,
     bool isPrimary,
-    PlatformEvent::Modifiers modifiers) {
+    PlatformEvent::Modifiers modifiers,
+    size_t coalescedEventCount) {
+  Vector<PlatformMouseEvent> coalescedEvents;
+  for (size_t i = 0; i < coalescedEventCount; i++) {
+    coalescedEvents.append(PointerEventFactoryTest::PlatformMouseEventBuilder(
+        pointerType, rawId, modifiers));
+  }
   PointerEvent* pointerEvent = m_pointerEventFactory.create(
-      EventTypeNames::mousedown,
-      PlatformMouseEventBuilder(pointerType, rawId, modifiers), nullptr);
+      coalescedEventCount ? EventTypeNames::mousemove
+                          : EventTypeNames::mousedown,
+      PointerEventFactoryTest::PlatformMouseEventBuilder(pointerType, rawId,
+                                                         modifiers),
+      coalescedEvents, nullptr);
   EXPECT_EQ(uniqueId, pointerEvent->pointerId());
   EXPECT_EQ(isPrimary, pointerEvent->isPrimary());
+  const char* expectedPointerType =
+      pointerTypeNameForWebPointPointerType(pointerType);
+  EXPECT_EQ(expectedPointerType, pointerEvent->pointerType());
+  EXPECT_EQ(coalescedEventCount, pointerEvent->getCoalescedEvents().size());
+  for (size_t i = 0; i < coalescedEventCount; i++) {
+    EXPECT_EQ(uniqueId, pointerEvent->getCoalescedEvents()[i]->pointerId());
+    EXPECT_EQ(isPrimary, pointerEvent->getCoalescedEvents()[i]->isPrimary());
+    EXPECT_EQ(expectedPointerType, pointerEvent->pointerType());
+  }
   return pointerEvent;
 }
 
 TEST_F(PointerEventFactoryTest, MousePointer) {
   EXPECT_TRUE(m_pointerEventFactory.isActive(m_expectedMouseId));
   EXPECT_FALSE(m_pointerEventFactory.isActiveButtonsState(m_expectedMouseId));
 
   PointerEvent* pointerEvent1 = createAndCheckMouseEvent(
       WebPointerProperties::PointerType::Mouse, 0, m_expectedMouseId, true);
   PointerEvent* pointerEvent2 = createAndCheckMouseEvent(
@@ skipping 241 matching lines @@
   }
 
   for (int i = 0; i < 100; ++i) {
     createAndCheckTouchEvent(WebPointerProperties::PointerType::Mouse, i,
                              m_expectedMouseId, true);
   }
   createAndCheckTouchCancel(WebPointerProperties::PointerType::Mouse, 0,
                             m_expectedMouseId, true);
 }
 
+TEST_F(PointerEventFactoryTest, CoalescedEvents) {
+  createAndCheckMouseEvent(WebPointerProperties::PointerType::Mouse, 0,
+                           m_expectedMouseId, true, PlatformEvent::NoModifiers,
+                           4);
+  createAndCheckTouchEvent(WebPointerProperties::PointerType::Touch, 0,
+                           m_mappedIdStart, true,
+                           PlatformTouchPoint::TouchMoved, 3);
+}
+
 }  // namespace blink