touch_disposition_gesture_filter_unittest.cc 48 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264
  1. // Copyright 2014 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "ui/events/gesture_detection/touch_disposition_gesture_filter.h"
  5. #include <stddef.h>
  6. #include <stdint.h>
  7. #include <memory>
  8. #include "testing/gtest/include/gtest/gtest.h"
  9. #include "ui/events/test/motion_event_test_utils.h"
  10. using ui::test::MockMotionEvent;
  11. namespace ui {
  12. namespace {
  13. const int kDefaultEventFlags = EF_ALT_DOWN | EF_SHIFT_DOWN;
  14. } // namespace
  15. class TouchDispositionGestureFilterTest
  16. : public testing::Test,
  17. public TouchDispositionGestureFilterClient {
  18. public:
  19. TouchDispositionGestureFilterTest()
  20. : cancel_after_next_gesture_(false), sent_gesture_count_(0) {}
  21. ~TouchDispositionGestureFilterTest() override {}
  22. // testing::Test
  23. void SetUp() override {
  24. queue_ = std::make_unique<TouchDispositionGestureFilter>(this);
  25. touch_event_.set_flags(kDefaultEventFlags);
  26. }
  27. void TearDown() override { queue_.reset(); }
  28. // TouchDispositionGestureFilterClient
  29. void ForwardGestureEvent(const GestureEventData& event) override {
  30. EXPECT_EQ(GestureDeviceType::DEVICE_TOUCHSCREEN,
  31. event.details.device_type());
  32. ++sent_gesture_count_;
  33. last_sent_gesture_ = std::make_unique<GestureEventData>(event);
  34. sent_gestures_.push_back(event.type());
  35. if (event.type() == ET_GESTURE_SHOW_PRESS)
  36. show_press_bounding_box_ = event.details.bounding_box();
  37. if (cancel_after_next_gesture_) {
  38. cancel_after_next_gesture_ = false;
  39. SendPacket(CancelTouchPoint(), NoGestures());
  40. SendTouchNotConsumedAckForLastTouch();
  41. }
  42. }
  43. protected:
  44. typedef std::vector<EventType> GestureList;
  45. ::testing::AssertionResult GesturesMatch(const GestureList& expected,
  46. const GestureList& actual) {
  47. if (expected.size() != actual.size()) {
  48. return ::testing::AssertionFailure()
  49. << "actual.size(" << actual.size()
  50. << ") != expected.size(" << expected.size() << ")";
  51. }
  52. for (size_t i = 0; i < expected.size(); ++i) {
  53. if (expected[i] != actual[i]) {
  54. return ::testing::AssertionFailure()
  55. << "actual[" << i << "] ("
  56. << actual[i]
  57. << ") != expected[" << i << "] ("
  58. << expected[i] << ")";
  59. }
  60. }
  61. return ::testing::AssertionSuccess();
  62. }
  63. GestureList NoGestures() { return GestureList(0); }
  64. GestureList Gestures(EventType type) {
  65. return GestureList(1, type);
  66. }
  67. GestureList Gestures(EventType type0, EventType type1) {
  68. GestureList gestures(2);
  69. gestures[0] = type0;
  70. gestures[1] = type1;
  71. return gestures;
  72. }
  73. GestureList Gestures(EventType type0,
  74. EventType type1,
  75. EventType type2) {
  76. GestureList gestures(3);
  77. gestures[0] = type0;
  78. gestures[1] = type1;
  79. gestures[2] = type2;
  80. return gestures;
  81. }
  82. GestureList Gestures(EventType type0,
  83. EventType type1,
  84. EventType type2,
  85. EventType type3) {
  86. GestureList gestures(4);
  87. gestures[0] = type0;
  88. gestures[1] = type1;
  89. gestures[2] = type2;
  90. gestures[3] = type3;
  91. return gestures;
  92. }
  93. TouchDispositionGestureFilter::PacketResult SendTouchGesturesWithResult(
  94. const MotionEvent& touch,
  95. const GestureEventDataPacket& packet) {
  96. GestureEventDataPacket touch_packet =
  97. GestureEventDataPacket::FromTouch(touch);
  98. for (size_t i = 0; i < packet.gesture_count(); ++i)
  99. touch_packet.Push(packet.gesture(i));
  100. return queue_->OnGesturePacket(touch_packet);
  101. }
  102. uint32_t SendTouchGestures(const MotionEvent& touch,
  103. const GestureEventDataPacket& packet) {
  104. SendTouchGesturesWithResult(touch, packet);
  105. last_sent_touch_event_id_ = touch.GetUniqueEventId();
  106. return touch.GetUniqueEventId();
  107. }
  108. TouchDispositionGestureFilter::PacketResult
  109. SendTimeoutGesture(EventType type) {
  110. return queue_->OnGesturePacket(
  111. GestureEventDataPacket::FromTouchTimeout(CreateGesture(type)));
  112. }
  113. TouchDispositionGestureFilter::PacketResult
  114. SendGesturePacket(const GestureEventDataPacket& packet) {
  115. return queue_->OnGesturePacket(packet);
  116. }
  117. void SendTouchEventAck(uint32_t touch_event_id,
  118. bool event_consumed,
  119. bool is_source_touch_event_set_blocking) {
  120. queue_->OnTouchEventAck(touch_event_id, event_consumed,
  121. is_source_touch_event_set_blocking);
  122. }
  123. void SendTouchConsumedAck(uint32_t touch_event_id) {
  124. SendTouchEventAck(touch_event_id, true /* event_consumed */,
  125. false /* is_source_touch_event_set_blocking */);
  126. }
  127. void SendTouchNotConsumedAck(uint32_t touch_event_id) {
  128. SendTouchEventAck(touch_event_id, false /* event_consumed */,
  129. false /* is_source_touch_event_set_blocking */);
  130. }
  131. void SendTouchConsumedAckForLastTouch() {
  132. SendTouchEventAck(last_sent_touch_event_id_, true /* event_consumed */,
  133. false /* is_source_touch_event_set_blocking */);
  134. }
  135. void SendTouchNotConsumedAckForLastTouch() {
  136. SendTouchEventAck(last_sent_touch_event_id_, false /* event_consumed */,
  137. false /* is_source_touch_event_set_blocking */);
  138. }
  139. void PushGesture(EventType type) {
  140. pending_gesture_packet_.Push(CreateGesture(type));
  141. }
  142. void PushGesture(EventType type, float x, float y, float diameter) {
  143. pending_gesture_packet_.Push(CreateGesture(type, x, y, diameter));
  144. }
  145. const MockMotionEvent& PressTouchPoint(float x, float y) {
  146. touch_event_.PressPoint(x, y);
  147. touch_event_.SetRawOffset(raw_offset_.x(), raw_offset_.y());
  148. return touch_event_;
  149. }
  150. const MockMotionEvent& PressTouchPoint() { return PressTouchPoint(0, 0); }
  151. const MockMotionEvent& MoveTouchPoint() {
  152. touch_event_.MovePoint(0, 0, 0);
  153. touch_event_.set_event_time(base::TimeTicks::Now());
  154. return touch_event_;
  155. }
  156. const MockMotionEvent& ReleaseTouchPoint() {
  157. touch_event_.ReleasePoint();
  158. touch_event_.set_event_time(base::TimeTicks::Now());
  159. return touch_event_;
  160. }
  161. const MockMotionEvent& CancelTouchPoint() {
  162. touch_event_.CancelPoint();
  163. touch_event_.set_event_time(base::TimeTicks::Now());
  164. return touch_event_;
  165. }
  166. uint32_t SendPacket(const MockMotionEvent& touch_event,
  167. GestureList gesture_list) {
  168. GestureEventDataPacket gesture_packet;
  169. for (EventType type : gesture_list)
  170. gesture_packet.Push(CreateGesture(type));
  171. last_sent_touch_event_id_ = touch_event.GetUniqueEventId();
  172. EXPECT_EQ(TouchDispositionGestureFilter::SUCCESS,
  173. SendTouchGesturesWithResult(touch_event, gesture_packet));
  174. return touch_event.GetUniqueEventId();
  175. }
  176. void SetRawTouchOffset(const gfx::Vector2dF& raw_offset) {
  177. raw_offset_ = raw_offset;
  178. }
  179. const MockMotionEvent& ResetTouchPoints() {
  180. touch_event_ = MockMotionEvent();
  181. return touch_event_;
  182. }
  183. bool GesturesSent() const { return !sent_gestures_.empty(); }
  184. const GestureEventData& last_sent_gesture() const {
  185. CHECK(last_sent_gesture_);
  186. return *last_sent_gesture_;
  187. }
  188. base::TimeTicks LastSentGestureTime() const {
  189. return last_sent_gesture().time;
  190. }
  191. base::TimeTicks CurrentTouchTime() const {
  192. return touch_event_.GetEventTime();
  193. }
  194. bool IsEmpty() const { return queue_->IsEmpty(); }
  195. GestureList GetAndResetSentGestures() {
  196. GestureList sent_gestures;
  197. sent_gestures.swap(sent_gestures_);
  198. return sent_gestures;
  199. }
  200. gfx::PointF LastSentGestureLocation() const {
  201. return gfx::PointF(last_sent_gesture().x, last_sent_gesture().y);
  202. }
  203. gfx::PointF LastSentGestureRawLocation() const {
  204. return gfx::PointF(last_sent_gesture().raw_x, last_sent_gesture().raw_y);
  205. }
  206. int LastSentGestureFlags() const {
  207. return last_sent_gesture().flags;
  208. }
  209. const gfx::Rect& ShowPressBoundingBox() const {
  210. return show_press_bounding_box_;
  211. }
  212. void SetCancelAfterNextGesture(bool cancel_after_next_gesture) {
  213. cancel_after_next_gesture_ = cancel_after_next_gesture;
  214. }
  215. GestureEventData CreateGesture(EventType type) {
  216. return CreateGesture(type, 0, 0, 0);
  217. }
  218. GestureEventData CreateGesture(EventType type,
  219. float x,
  220. float y,
  221. float diameter) {
  222. GestureEventDetails details(type);
  223. details.set_device_type(GestureDeviceType::DEVICE_TOUCHSCREEN);
  224. return GestureEventData(
  225. details, 0, MotionEvent::ToolType::FINGER, base::TimeTicks(), x, y, 0,
  226. 0, 1,
  227. gfx::RectF(x - diameter / 2, y - diameter / 2, diameter, diameter),
  228. kDefaultEventFlags, 0U);
  229. }
  230. private:
  231. std::unique_ptr<TouchDispositionGestureFilter> queue_;
  232. bool cancel_after_next_gesture_;
  233. MockMotionEvent touch_event_;
  234. GestureEventDataPacket pending_gesture_packet_;
  235. size_t sent_gesture_count_;
  236. GestureList sent_gestures_;
  237. gfx::Vector2dF raw_offset_;
  238. std::unique_ptr<GestureEventData> last_sent_gesture_;
  239. gfx::Rect show_press_bounding_box_;
  240. uint32_t last_sent_touch_event_id_;
  241. };
  242. TEST_F(TouchDispositionGestureFilterTest, BasicNoGestures) {
  243. uint32_t touch_press_event_id = PressTouchPoint().GetUniqueEventId();
  244. EXPECT_FALSE(GesturesSent());
  245. uint32_t touch_move_event_id = MoveTouchPoint().GetUniqueEventId();
  246. EXPECT_FALSE(GesturesSent());
  247. // No gestures should be dispatched by the ack, as the queued packets
  248. // contained no gestures.
  249. SendTouchConsumedAck(touch_press_event_id);
  250. EXPECT_FALSE(GesturesSent());
  251. // Release the touch gesture.
  252. uint32_t touch_release_event_id = ReleaseTouchPoint().GetUniqueEventId();
  253. SendTouchConsumedAck(touch_move_event_id);
  254. SendTouchConsumedAck(touch_release_event_id);
  255. EXPECT_FALSE(GesturesSent());
  256. }
  257. TEST_F(TouchDispositionGestureFilterTest, BasicGestures) {
  258. GestureList press_gestures =
  259. Gestures(ET_GESTURE_BEGIN, ET_GESTURE_SCROLL_BEGIN);
  260. // An unconsumed touch's gesture should be sent.
  261. SendPacket(PressTouchPoint(), press_gestures);
  262. EXPECT_FALSE(GesturesSent());
  263. SendTouchNotConsumedAckForLastTouch();
  264. EXPECT_TRUE(GesturesMatch(press_gestures, GetAndResetSentGestures()));
  265. // Multiple gestures can be queued for a single event.
  266. GestureList release_gestures =
  267. Gestures(ET_SCROLL_FLING_START, ET_SCROLL_FLING_CANCEL, ET_GESTURE_END);
  268. SendPacket(ReleaseTouchPoint(), release_gestures);
  269. EXPECT_FALSE(GesturesSent());
  270. SendTouchNotConsumedAckForLastTouch();
  271. EXPECT_TRUE(GesturesMatch(release_gestures, GetAndResetSentGestures()));
  272. }
  273. TEST_F(TouchDispositionGestureFilterTest, BasicGesturesConsumed) {
  274. // A consumed touch's gesture should not be sent.
  275. SendPacket(PressTouchPoint(),
  276. Gestures(ET_GESTURE_BEGIN, ET_GESTURE_SCROLL_BEGIN));
  277. SendTouchConsumedAckForLastTouch();
  278. EXPECT_FALSE(GesturesSent());
  279. SendPacket(MoveTouchPoint(), Gestures(ET_GESTURE_SCROLL_UPDATE));
  280. SendTouchConsumedAckForLastTouch();
  281. EXPECT_FALSE(GesturesSent());
  282. SendPacket(
  283. ReleaseTouchPoint(),
  284. Gestures(ET_SCROLL_FLING_START, ET_SCROLL_FLING_CANCEL, ET_GESTURE_END));
  285. SendTouchConsumedAckForLastTouch();
  286. EXPECT_FALSE(GesturesSent());
  287. }
  288. TEST_F(TouchDispositionGestureFilterTest, ConsumedThenNotConsumed) {
  289. // A consumed touch's gesture should not be sent.
  290. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_SCROLL_BEGIN));
  291. SendTouchConsumedAckForLastTouch();
  292. EXPECT_FALSE(GesturesSent());
  293. // Even if the subsequent touch is not consumed, continue dropping gestures.
  294. SendPacket(MoveTouchPoint(), Gestures(ET_GESTURE_SCROLL_UPDATE));
  295. SendTouchNotConsumedAckForLastTouch();
  296. EXPECT_FALSE(GesturesSent());
  297. // Even if the subsequent touch had no consumer, continue dropping gestures.
  298. SendPacket(ReleaseTouchPoint(), Gestures(ET_SCROLL_FLING_START));
  299. SendTouchNotConsumedAckForLastTouch();
  300. EXPECT_FALSE(GesturesSent());
  301. }
  302. TEST_F(TouchDispositionGestureFilterTest, NotConsumedThenConsumed) {
  303. // A not consumed touch's gesture should be sent.
  304. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_SCROLL_BEGIN));
  305. SendTouchNotConsumedAckForLastTouch();
  306. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN),
  307. GetAndResetSentGestures()));
  308. // A newly consumed gesture should not be sent.
  309. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_PINCH_BEGIN));
  310. SendTouchConsumedAckForLastTouch();
  311. EXPECT_FALSE(GesturesSent());
  312. // And subsequent non-consumed pinch updates should not be sent.
  313. SendPacket(MoveTouchPoint(),
  314. Gestures(ET_GESTURE_SCROLL_UPDATE, ET_GESTURE_PINCH_UPDATE));
  315. SendTouchNotConsumedAckForLastTouch();
  316. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_UPDATE),
  317. GetAndResetSentGestures()));
  318. // End events dispatched only when their start events were.
  319. SendPacket(ReleaseTouchPoint(), Gestures(ET_GESTURE_PINCH_END));
  320. SendTouchNotConsumedAckForLastTouch();
  321. EXPECT_FALSE(GesturesSent());
  322. SendPacket(ReleaseTouchPoint(), Gestures(ET_GESTURE_SCROLL_END));
  323. SendTouchConsumedAckForLastTouch();
  324. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_END),
  325. GetAndResetSentGestures()));
  326. }
  327. TEST_F(TouchDispositionGestureFilterTest, ScrollAlternatelyConsumed) {
  328. // A consumed touch's gesture should not be sent.
  329. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_SCROLL_BEGIN));
  330. SendTouchNotConsumedAckForLastTouch();
  331. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN),
  332. GetAndResetSentGestures()));
  333. for (size_t i = 0; i < 3; ++i) {
  334. SendPacket(MoveTouchPoint(), Gestures(ET_GESTURE_SCROLL_UPDATE));
  335. SendTouchConsumedAckForLastTouch();
  336. EXPECT_FALSE(GesturesSent());
  337. SendPacket(MoveTouchPoint(), Gestures(ET_GESTURE_SCROLL_UPDATE));
  338. SendTouchNotConsumedAckForLastTouch();
  339. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_UPDATE),
  340. GetAndResetSentGestures()));
  341. }
  342. SendPacket(ReleaseTouchPoint(), Gestures(ET_GESTURE_SCROLL_END));
  343. SendTouchConsumedAckForLastTouch();
  344. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_END),
  345. GetAndResetSentGestures()));
  346. }
  347. TEST_F(TouchDispositionGestureFilterTest, NotConsumedThenNoConsumer) {
  348. // An unconsumed touch's gesture should be sent.
  349. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_SCROLL_BEGIN));
  350. SendTouchNotConsumedAckForLastTouch();
  351. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN),
  352. GetAndResetSentGestures()));
  353. // If the subsequent touch has no consumer (e.g., a secondary pointer is
  354. // pressed but not on a touch handling rect), send the gesture.
  355. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_PINCH_BEGIN));
  356. SendTouchNotConsumedAckForLastTouch();
  357. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_PINCH_BEGIN),
  358. GetAndResetSentGestures()));
  359. // End events should be dispatched when their start events were, independent
  360. // of the ack state.
  361. SendPacket(ReleaseTouchPoint(), Gestures(ET_GESTURE_PINCH_END));
  362. SendTouchConsumedAckForLastTouch();
  363. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_PINCH_END),
  364. GetAndResetSentGestures()));
  365. SendPacket(ReleaseTouchPoint(), Gestures(ET_GESTURE_SCROLL_END));
  366. SendTouchConsumedAckForLastTouch();
  367. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_END),
  368. GetAndResetSentGestures()));
  369. }
  370. TEST_F(TouchDispositionGestureFilterTest, EndingEventsSent) {
  371. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_SCROLL_BEGIN));
  372. SendTouchNotConsumedAckForLastTouch();
  373. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN),
  374. GetAndResetSentGestures()));
  375. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_PINCH_BEGIN));
  376. SendTouchNotConsumedAckForLastTouch();
  377. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_PINCH_BEGIN),
  378. GetAndResetSentGestures()));
  379. // Consuming the touchend event can't suppress the match end gesture.
  380. SendPacket(ReleaseTouchPoint(), Gestures(ET_GESTURE_PINCH_END));
  381. SendTouchConsumedAckForLastTouch();
  382. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_PINCH_END),
  383. GetAndResetSentGestures()));
  384. // But other events in the same packet are still suppressed.
  385. SendPacket(ReleaseTouchPoint(),
  386. Gestures(ET_GESTURE_SCROLL_UPDATE, ET_GESTURE_SCROLL_END));
  387. SendTouchConsumedAckForLastTouch();
  388. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_END),
  389. GetAndResetSentGestures()));
  390. // ET_GESTURE_SCROLL_END and ET_SCROLL_FLING_START behave the same in this
  391. // regard.
  392. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_SCROLL_BEGIN));
  393. SendTouchNotConsumedAckForLastTouch();
  394. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN),
  395. GetAndResetSentGestures()));
  396. SendPacket(ReleaseTouchPoint(), Gestures(ET_SCROLL_FLING_START));
  397. SendTouchConsumedAckForLastTouch();
  398. EXPECT_TRUE(GesturesMatch(Gestures(ET_SCROLL_FLING_START),
  399. GetAndResetSentGestures()));
  400. }
  401. TEST_F(TouchDispositionGestureFilterTest, EndingEventsNotSent) {
  402. // Consuming a begin event ensures no end events are sent.
  403. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_SCROLL_BEGIN));
  404. SendTouchConsumedAckForLastTouch();
  405. EXPECT_FALSE(GesturesSent());
  406. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_PINCH_BEGIN));
  407. SendTouchNotConsumedAckForLastTouch();
  408. EXPECT_FALSE(GesturesSent());
  409. SendPacket(ReleaseTouchPoint(), Gestures(ET_GESTURE_PINCH_END));
  410. SendTouchNotConsumedAckForLastTouch();
  411. EXPECT_FALSE(GesturesSent());
  412. SendPacket(ReleaseTouchPoint(), Gestures(ET_GESTURE_SCROLL_END));
  413. SendTouchNotConsumedAckForLastTouch();
  414. EXPECT_FALSE(GesturesSent());
  415. }
  416. TEST_F(TouchDispositionGestureFilterTest, UpdateEventsSuppressedPerEvent) {
  417. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_SCROLL_BEGIN));
  418. SendTouchNotConsumedAckForLastTouch();
  419. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN),
  420. GetAndResetSentGestures()));
  421. // Consuming a single scroll or pinch update should suppress only that event.
  422. SendPacket(MoveTouchPoint(), Gestures(ET_GESTURE_SCROLL_UPDATE));
  423. SendTouchConsumedAckForLastTouch();
  424. EXPECT_FALSE(GesturesSent());
  425. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_PINCH_BEGIN));
  426. SendTouchNotConsumedAckForLastTouch();
  427. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_PINCH_BEGIN),
  428. GetAndResetSentGestures()));
  429. SendPacket(MoveTouchPoint(), Gestures(ET_GESTURE_PINCH_UPDATE));
  430. SendTouchConsumedAckForLastTouch();
  431. EXPECT_FALSE(GesturesSent());
  432. // Subsequent updates should not be affected.
  433. SendPacket(MoveTouchPoint(), Gestures(ET_GESTURE_SCROLL_UPDATE));
  434. SendTouchNotConsumedAckForLastTouch();
  435. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_UPDATE),
  436. GetAndResetSentGestures()));
  437. SendPacket(MoveTouchPoint(), Gestures(ET_GESTURE_PINCH_UPDATE));
  438. SendTouchNotConsumedAckForLastTouch();
  439. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_PINCH_UPDATE),
  440. GetAndResetSentGestures()));
  441. SendPacket(ReleaseTouchPoint(), Gestures(ET_GESTURE_PINCH_END));
  442. SendTouchConsumedAckForLastTouch();
  443. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_PINCH_END),
  444. GetAndResetSentGestures()));
  445. SendPacket(ReleaseTouchPoint(), Gestures(ET_GESTURE_SCROLL_END));
  446. SendTouchConsumedAckForLastTouch();
  447. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_END),
  448. GetAndResetSentGestures()));
  449. }
  450. TEST_F(TouchDispositionGestureFilterTest, UpdateEventsDependOnBeginEvents) {
  451. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_SCROLL_BEGIN));
  452. SendTouchConsumedAckForLastTouch();
  453. EXPECT_FALSE(GesturesSent());
  454. // Scroll and pinch gestures depend on the scroll begin gesture being
  455. // dispatched.
  456. SendPacket(MoveTouchPoint(), Gestures(ET_GESTURE_SCROLL_UPDATE));
  457. SendTouchNotConsumedAckForLastTouch();
  458. EXPECT_FALSE(GesturesSent());
  459. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_PINCH_BEGIN));
  460. SendTouchNotConsumedAckForLastTouch();
  461. EXPECT_FALSE(GesturesSent());
  462. SendPacket(MoveTouchPoint(), Gestures(ET_GESTURE_PINCH_UPDATE));
  463. SendTouchConsumedAckForLastTouch();
  464. EXPECT_FALSE(GesturesSent());
  465. SendPacket(ReleaseTouchPoint(), Gestures(ET_GESTURE_PINCH_END));
  466. SendTouchNotConsumedAckForLastTouch();
  467. EXPECT_FALSE(GesturesSent());
  468. SendPacket(ReleaseTouchPoint(), Gestures(ET_GESTURE_SCROLL_END));
  469. SendTouchNotConsumedAckForLastTouch();
  470. EXPECT_FALSE(GesturesSent());
  471. }
  472. TEST_F(TouchDispositionGestureFilterTest, MultipleTouchSequences) {
  473. // Queue two touch-to-gestures sequences.
  474. uint32_t touch_press_event_id1 =
  475. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_TAP_DOWN));
  476. uint32_t touch_release_event_id1 =
  477. SendPacket(ReleaseTouchPoint(), Gestures(ET_GESTURE_TAP));
  478. uint32_t touch_press_event_id2 =
  479. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_SCROLL_BEGIN));
  480. uint32_t touch_release_event_id2 =
  481. SendPacket(ReleaseTouchPoint(), Gestures(ET_GESTURE_SCROLL_END));
  482. // The first gesture sequence should not be allowed.
  483. SendTouchConsumedAck(touch_press_event_id1);
  484. SendTouchNotConsumedAck(touch_release_event_id1);
  485. EXPECT_FALSE(GesturesSent());
  486. // The subsequent sequence should "reset" allowance.
  487. SendTouchNotConsumedAck(touch_press_event_id2);
  488. SendTouchNotConsumedAck(touch_release_event_id2);
  489. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN,
  490. ET_GESTURE_SCROLL_END),
  491. GetAndResetSentGestures()));
  492. }
  493. TEST_F(TouchDispositionGestureFilterTest, FlingCancelledOnNewTouchSequence) {
  494. const gfx::Vector2dF raw_offset(1.3f, 3.7f);
  495. SetRawTouchOffset(raw_offset);
  496. // Simulate a fling.
  497. SendPacket(PressTouchPoint(),
  498. Gestures(ET_GESTURE_TAP_DOWN, ET_GESTURE_SCROLL_BEGIN));
  499. SendTouchNotConsumedAckForLastTouch();
  500. EXPECT_TRUE(GesturesMatch(
  501. Gestures(
  502. ET_GESTURE_TAP_DOWN, ET_GESTURE_TAP_CANCEL, ET_GESTURE_SCROLL_BEGIN),
  503. GetAndResetSentGestures()));
  504. SendPacket(ReleaseTouchPoint(), Gestures(ET_SCROLL_FLING_START));
  505. SendTouchNotConsumedAckForLastTouch();
  506. EXPECT_TRUE(GesturesMatch(Gestures(ET_SCROLL_FLING_START),
  507. GetAndResetSentGestures()));
  508. // A new touch sequence should cancel the outstanding fling.
  509. SendPacket(PressTouchPoint(1, 1), NoGestures());
  510. SendTouchNotConsumedAckForLastTouch();
  511. EXPECT_TRUE(GesturesMatch(Gestures(ET_SCROLL_FLING_CANCEL),
  512. GetAndResetSentGestures()));
  513. EXPECT_EQ(CurrentTouchTime(), LastSentGestureTime());
  514. EXPECT_EQ(LastSentGestureLocation(), gfx::PointF(1, 1));
  515. EXPECT_EQ(LastSentGestureRawLocation(), gfx::PointF(1, 1) + raw_offset);
  516. SendPacket(ReleaseTouchPoint(), NoGestures());
  517. SendTouchNotConsumedAckForLastTouch();
  518. EXPECT_FALSE(GesturesSent());
  519. }
  520. TEST_F(TouchDispositionGestureFilterTest, ScrollEndedOnTouchReleaseIfNoFling) {
  521. // Simulate a scroll.
  522. // Touch position will be used for synthesized scroll end gesture.
  523. SendPacket(PressTouchPoint(2, 3),
  524. Gestures(ET_GESTURE_TAP_DOWN, ET_GESTURE_SCROLL_BEGIN));
  525. SendTouchNotConsumedAckForLastTouch();
  526. EXPECT_TRUE(GesturesMatch(
  527. Gestures(
  528. ET_GESTURE_TAP_DOWN, ET_GESTURE_TAP_CANCEL, ET_GESTURE_SCROLL_BEGIN),
  529. GetAndResetSentGestures()));
  530. SendPacket(ReleaseTouchPoint(), NoGestures());
  531. SendTouchNotConsumedAckForLastTouch();
  532. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_END),
  533. GetAndResetSentGestures()));
  534. EXPECT_EQ(CurrentTouchTime(), LastSentGestureTime());
  535. EXPECT_EQ(LastSentGestureLocation(), gfx::PointF(2, 3));
  536. }
  537. TEST_F(TouchDispositionGestureFilterTest, ScrollEndedOnNewTouchSequence) {
  538. // Simulate a scroll.
  539. SendPacket(PressTouchPoint(),
  540. Gestures(ET_GESTURE_TAP_DOWN, ET_GESTURE_SCROLL_BEGIN));
  541. SendTouchNotConsumedAckForLastTouch();
  542. EXPECT_TRUE(GesturesMatch(
  543. Gestures(
  544. ET_GESTURE_TAP_DOWN, ET_GESTURE_TAP_CANCEL, ET_GESTURE_SCROLL_BEGIN),
  545. GetAndResetSentGestures()));
  546. // A new touch sequence should end the outstanding scroll.
  547. ResetTouchPoints();
  548. // Touch position will be used for synthesized scroll end gesture.
  549. SendPacket(PressTouchPoint(2, 3), NoGestures());
  550. SendTouchConsumedAckForLastTouch();
  551. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_END),
  552. GetAndResetSentGestures()));
  553. EXPECT_EQ(CurrentTouchTime(), LastSentGestureTime());
  554. EXPECT_EQ(LastSentGestureLocation(), gfx::PointF(2, 3));
  555. }
  556. TEST_F(TouchDispositionGestureFilterTest, FlingCancelledOnScrollBegin) {
  557. // Simulate a fling sequence.
  558. SendPacket(PressTouchPoint(),
  559. Gestures(ET_GESTURE_TAP_DOWN, ET_GESTURE_SCROLL_BEGIN,
  560. ET_SCROLL_FLING_START));
  561. SendTouchNotConsumedAckForLastTouch();
  562. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN,
  563. ET_GESTURE_TAP_CANCEL,
  564. ET_GESTURE_SCROLL_BEGIN,
  565. ET_SCROLL_FLING_START),
  566. GetAndResetSentGestures()));
  567. // The new fling should cancel the preceding one.
  568. SendPacket(ReleaseTouchPoint(),
  569. Gestures(ET_GESTURE_SCROLL_BEGIN, ET_SCROLL_FLING_START));
  570. SendTouchNotConsumedAckForLastTouch();
  571. EXPECT_TRUE(GesturesMatch(Gestures(ET_SCROLL_FLING_CANCEL,
  572. ET_GESTURE_SCROLL_BEGIN,
  573. ET_SCROLL_FLING_START),
  574. GetAndResetSentGestures()));
  575. }
  576. TEST_F(TouchDispositionGestureFilterTest, FlingNotCancelledIfGFCEventReceived) {
  577. // Simulate a fling that is started then cancelled.
  578. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_SCROLL_BEGIN));
  579. SendTouchNotConsumedAckForLastTouch();
  580. SendPacket(MoveTouchPoint(), Gestures(ET_SCROLL_FLING_START));
  581. SendTouchNotConsumedAckForLastTouch();
  582. GestureEventDataPacket packet;
  583. packet.Push(CreateGesture(ET_SCROLL_FLING_CANCEL, 2, 3, 0));
  584. SendTouchGestures(ReleaseTouchPoint(), packet);
  585. SendTouchNotConsumedAckForLastTouch();
  586. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN,
  587. ET_SCROLL_FLING_START,
  588. ET_SCROLL_FLING_CANCEL),
  589. GetAndResetSentGestures()));
  590. EXPECT_EQ(LastSentGestureLocation(), gfx::PointF(2, 3));
  591. // A new touch sequence will not inject a ET_SCROLL_FLING_CANCEL, as the fling
  592. // has already been cancelled.
  593. SendPacket(PressTouchPoint(), NoGestures());
  594. SendTouchNotConsumedAckForLastTouch();
  595. SendPacket(ReleaseTouchPoint(), NoGestures());
  596. SendTouchNotConsumedAckForLastTouch();
  597. EXPECT_FALSE(GesturesSent());
  598. }
  599. TEST_F(TouchDispositionGestureFilterTest, TapCancelledWhenScrollBegins) {
  600. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_TAP_DOWN));
  601. SendTouchNotConsumedAckForLastTouch();
  602. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN),
  603. GetAndResetSentGestures()));
  604. // If the subsequent touch turns into a scroll, the tap should be cancelled.
  605. SendPacket(MoveTouchPoint(), Gestures(ET_GESTURE_SCROLL_BEGIN));
  606. SendTouchNotConsumedAckForLastTouch();
  607. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_CANCEL,
  608. ET_GESTURE_SCROLL_BEGIN),
  609. GetAndResetSentGestures()));
  610. }
  611. TEST_F(TouchDispositionGestureFilterTest, TapCancelledWhenTouchConsumed) {
  612. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_TAP_DOWN));
  613. SendTouchNotConsumedAckForLastTouch();
  614. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN),
  615. GetAndResetSentGestures()));
  616. // If the subsequent touch is consumed, the tap should be cancelled.
  617. GestureEventDataPacket packet;
  618. packet.Push(CreateGesture(ET_GESTURE_SCROLL_BEGIN, 2, 3, 0));
  619. SendTouchGestures(MoveTouchPoint(), packet);
  620. SendTouchConsumedAckForLastTouch();
  621. EXPECT_TRUE(
  622. GesturesMatch(Gestures(ET_GESTURE_TAP_CANCEL, ET_GESTURE_SCROLL_BEGIN),
  623. GetAndResetSentGestures()));
  624. EXPECT_EQ(LastSentGestureLocation(), gfx::PointF(2, 3));
  625. }
  626. TEST_F(TouchDispositionGestureFilterTest,
  627. TapNotCancelledIfTapEndingEventReceived) {
  628. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_TAP_DOWN));
  629. SendTouchNotConsumedAckForLastTouch();
  630. EXPECT_TRUE(
  631. GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN), GetAndResetSentGestures()));
  632. SendPacket(ReleaseTouchPoint(), Gestures(ET_GESTURE_TAP));
  633. SendTouchNotConsumedAckForLastTouch();
  634. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SHOW_PRESS, ET_GESTURE_TAP),
  635. GetAndResetSentGestures()));
  636. // The tap should not be cancelled as it was terminated by a |ET_GESTURE_TAP|.
  637. SendPacket(PressTouchPoint(), NoGestures());
  638. SendTouchConsumedAckForLastTouch();
  639. EXPECT_FALSE(GesturesSent());
  640. }
  641. TEST_F(TouchDispositionGestureFilterTest, TimeoutGestures) {
  642. // If the sequence is allowed, and there are no preceding gestures, the
  643. // timeout gestures should be forwarded immediately.
  644. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_TAP_DOWN));
  645. SendTouchNotConsumedAckForLastTouch();
  646. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN),
  647. GetAndResetSentGestures()));
  648. SendTimeoutGesture(ET_GESTURE_SHOW_PRESS);
  649. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SHOW_PRESS),
  650. GetAndResetSentGestures()));
  651. SendTimeoutGesture(ET_GESTURE_LONG_PRESS);
  652. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_LONG_PRESS),
  653. GetAndResetSentGestures()));
  654. SendPacket(ReleaseTouchPoint(), Gestures(ET_GESTURE_LONG_TAP));
  655. SendTouchNotConsumedAckForLastTouch();
  656. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_CANCEL,
  657. ET_GESTURE_LONG_TAP),
  658. GetAndResetSentGestures()));
  659. // If the sequence is disallowed, and there are no preceding gestures, the
  660. // timeout gestures should be dropped immediately.
  661. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_TAP_DOWN));
  662. SendTouchConsumedAckForLastTouch();
  663. EXPECT_FALSE(GesturesSent());
  664. SendTimeoutGesture(ET_GESTURE_SHOW_PRESS);
  665. EXPECT_FALSE(GesturesSent());
  666. SendPacket(ReleaseTouchPoint(), NoGestures());
  667. SendTouchNotConsumedAckForLastTouch();
  668. // If the sequence has a pending ack, the timeout gestures should
  669. // remain queued until the ack is received.
  670. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_TAP_DOWN));
  671. EXPECT_FALSE(GesturesSent());
  672. SendTimeoutGesture(ET_GESTURE_LONG_PRESS);
  673. EXPECT_FALSE(GesturesSent());
  674. SendTouchNotConsumedAckForLastTouch();
  675. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN,
  676. ET_GESTURE_LONG_PRESS),
  677. GetAndResetSentGestures()));
  678. }
  679. TEST_F(TouchDispositionGestureFilterTest, SpuriousAcksIgnored) {
  680. // Acks received when the queue is empty will be safely ignored.
  681. ASSERT_TRUE(IsEmpty());
  682. SendTouchConsumedAck(0);
  683. EXPECT_FALSE(GesturesSent());
  684. uint32_t touch_press_event_id =
  685. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_SCROLL_BEGIN));
  686. uint32_t touch_move_event_id =
  687. SendPacket(MoveTouchPoint(), Gestures(ET_GESTURE_SCROLL_UPDATE));
  688. SendTouchNotConsumedAck(touch_press_event_id);
  689. SendTouchNotConsumedAck(touch_move_event_id);
  690. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN,
  691. ET_GESTURE_SCROLL_UPDATE),
  692. GetAndResetSentGestures()));
  693. // Even if all packets have been dispatched, the filter may not be empty as
  694. // there could be follow-up timeout events. Spurious acks in such cases
  695. // should also be safely ignored.
  696. ASSERT_FALSE(IsEmpty());
  697. SendTouchConsumedAck(0);
  698. EXPECT_FALSE(GesturesSent());
  699. }
  700. TEST_F(TouchDispositionGestureFilterTest, PacketWithInvalidTypeIgnored) {
  701. GestureEventDataPacket packet;
  702. EXPECT_EQ(TouchDispositionGestureFilter::INVALID_PACKET_TYPE,
  703. SendGesturePacket(packet));
  704. EXPECT_TRUE(IsEmpty());
  705. }
  706. TEST_F(TouchDispositionGestureFilterTest, PacketsWithInvalidOrderIgnored) {
  707. EXPECT_EQ(TouchDispositionGestureFilter::INVALID_PACKET_ORDER,
  708. SendTimeoutGesture(ET_GESTURE_SHOW_PRESS));
  709. EXPECT_TRUE(IsEmpty());
  710. }
  711. TEST_F(TouchDispositionGestureFilterTest, ConsumedTouchCancel) {
  712. // An unconsumed touch's gesture should be sent.
  713. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_TAP_DOWN));
  714. EXPECT_FALSE(GesturesSent());
  715. SendTouchNotConsumedAckForLastTouch();
  716. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN),
  717. GetAndResetSentGestures()));
  718. SendPacket(CancelTouchPoint(),
  719. Gestures(ET_GESTURE_TAP_CANCEL, ET_GESTURE_SCROLL_END));
  720. EXPECT_FALSE(GesturesSent());
  721. SendTouchConsumedAckForLastTouch();
  722. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_CANCEL,
  723. ET_GESTURE_SCROLL_END),
  724. GetAndResetSentGestures()));
  725. }
  726. TEST_F(TouchDispositionGestureFilterTest, TimeoutEventAfterRelease) {
  727. SendPacket(PressTouchPoint(), NoGestures());
  728. SendTouchNotConsumedAckForLastTouch();
  729. EXPECT_FALSE(GesturesSent());
  730. SendPacket(ReleaseTouchPoint(),
  731. Gestures(ET_GESTURE_TAP_DOWN, ET_GESTURE_TAP_UNCONFIRMED));
  732. SendTouchNotConsumedAckForLastTouch();
  733. EXPECT_TRUE(
  734. GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN, ET_GESTURE_TAP_UNCONFIRMED),
  735. GetAndResetSentGestures()));
  736. SendTimeoutGesture(ET_GESTURE_TAP);
  737. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SHOW_PRESS, ET_GESTURE_TAP),
  738. GetAndResetSentGestures()));
  739. }
  740. TEST_F(TouchDispositionGestureFilterTest, ShowPressInsertedBeforeTap) {
  741. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_TAP_DOWN));
  742. SendTouchNotConsumedAckForLastTouch();
  743. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN),
  744. GetAndResetSentGestures()));
  745. SendTimeoutGesture(ET_GESTURE_TAP_UNCONFIRMED);
  746. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_UNCONFIRMED),
  747. GetAndResetSentGestures()));
  748. SendPacket(ReleaseTouchPoint(), Gestures(ET_GESTURE_TAP));
  749. SendTouchNotConsumedAckForLastTouch();
  750. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SHOW_PRESS,
  751. ET_GESTURE_TAP),
  752. GetAndResetSentGestures()));
  753. }
  754. TEST_F(TouchDispositionGestureFilterTest, ShowPressNotInsertedIfAlreadySent) {
  755. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_TAP_DOWN));
  756. SendTouchNotConsumedAckForLastTouch();
  757. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN),
  758. GetAndResetSentGestures()));
  759. SendTimeoutGesture(ET_GESTURE_SHOW_PRESS);
  760. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SHOW_PRESS),
  761. GetAndResetSentGestures()));
  762. SendPacket(ReleaseTouchPoint(), Gestures(ET_GESTURE_TAP));
  763. SendTouchNotConsumedAckForLastTouch();
  764. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP),
  765. GetAndResetSentGestures()));
  766. }
  767. TEST_F(TouchDispositionGestureFilterTest, TapAndScrollCancelledOnTouchCancel) {
  768. const gfx::Vector2dF raw_offset(1.3f, 3.7f);
  769. SetRawTouchOffset(raw_offset);
  770. SendPacket(PressTouchPoint(1, 1), Gestures(ET_GESTURE_TAP_DOWN));
  771. SendTouchNotConsumedAckForLastTouch();
  772. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN),
  773. GetAndResetSentGestures()));
  774. // A cancellation motion event should cancel the tap.
  775. SendPacket(CancelTouchPoint(), NoGestures());
  776. SendTouchNotConsumedAckForLastTouch();
  777. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_CANCEL),
  778. GetAndResetSentGestures()));
  779. EXPECT_EQ(CurrentTouchTime(), LastSentGestureTime());
  780. EXPECT_EQ(LastSentGestureLocation(), gfx::PointF(1, 1));
  781. EXPECT_EQ(LastSentGestureRawLocation(), gfx::PointF(1, 1) + raw_offset);
  782. SendPacket(PressTouchPoint(1, 1), Gestures(ET_GESTURE_SCROLL_BEGIN));
  783. SendTouchNotConsumedAckForLastTouch();
  784. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN),
  785. GetAndResetSentGestures()));
  786. // A cancellation motion event should end the scroll, even if the touch was
  787. // consumed.
  788. SendPacket(CancelTouchPoint(), NoGestures());
  789. SendTouchConsumedAckForLastTouch();
  790. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_END),
  791. GetAndResetSentGestures()));
  792. EXPECT_EQ(CurrentTouchTime(), LastSentGestureTime());
  793. EXPECT_EQ(LastSentGestureLocation(), gfx::PointF(1, 1));
  794. EXPECT_EQ(LastSentGestureRawLocation(), gfx::PointF(1, 1) + raw_offset);
  795. }
  796. TEST_F(TouchDispositionGestureFilterTest,
  797. ConsumedScrollUpdateMakesFlingScrollEnd) {
  798. // A consumed touch's gesture should not be sent.
  799. SendPacket(PressTouchPoint(),
  800. Gestures(ET_GESTURE_BEGIN, ET_GESTURE_SCROLL_BEGIN));
  801. SendTouchNotConsumedAckForLastTouch();
  802. EXPECT_TRUE(
  803. GesturesMatch(Gestures(ET_GESTURE_BEGIN, ET_GESTURE_SCROLL_BEGIN),
  804. GetAndResetSentGestures()));
  805. SendPacket(MoveTouchPoint(), Gestures(ET_GESTURE_SCROLL_UPDATE));
  806. SendTouchConsumedAckForLastTouch();
  807. EXPECT_FALSE(GesturesSent());
  808. GestureEventDataPacket packet;
  809. packet.Push(CreateGesture(ET_SCROLL_FLING_START));
  810. packet.Push(CreateGesture(ET_SCROLL_FLING_CANCEL));
  811. packet.Push(CreateGesture(ET_GESTURE_END, 2, 3, 0));
  812. SendTouchGestures(ReleaseTouchPoint(), packet);
  813. SendTouchNotConsumedAckForLastTouch();
  814. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_END, ET_GESTURE_END),
  815. GetAndResetSentGestures()));
  816. EXPECT_EQ(LastSentGestureLocation(), gfx::PointF(2, 3));
  817. SendPacket(PressTouchPoint(),
  818. Gestures(ET_GESTURE_BEGIN, ET_GESTURE_SCROLL_BEGIN));
  819. SendTouchNotConsumedAckForLastTouch();
  820. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_BEGIN, ET_GESTURE_SCROLL_BEGIN),
  821. GetAndResetSentGestures()));
  822. }
  823. TEST_F(TouchDispositionGestureFilterTest, TapCancelledOnTouchCancel) {
  824. // Touch position is used for synthesized tap cancel.
  825. SendPacket(PressTouchPoint(2, 3), Gestures(ET_GESTURE_TAP_DOWN));
  826. SendTouchNotConsumedAckForLastTouch();
  827. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN),
  828. GetAndResetSentGestures()));
  829. // A cancellation motion event should cancel the tap.
  830. SendPacket(CancelTouchPoint(), NoGestures());
  831. SendTouchNotConsumedAckForLastTouch();
  832. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_CANCEL),
  833. GetAndResetSentGestures()));
  834. EXPECT_EQ(CurrentTouchTime(), LastSentGestureTime());
  835. EXPECT_EQ(LastSentGestureLocation(), gfx::PointF(2, 3));
  836. }
  837. // Test that a GestureEvent whose dispatch causes a cancel event to be fired
  838. // won't cause a crash.
  839. TEST_F(TouchDispositionGestureFilterTest, TestCancelMidGesture) {
  840. SetCancelAfterNextGesture(true);
  841. // Synthesized tap cancel uses touch position.
  842. SendPacket(PressTouchPoint(1, 1), Gestures(ET_GESTURE_TAP_DOWN));
  843. SendTouchNotConsumedAckForLastTouch();
  844. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN,
  845. ET_GESTURE_TAP_CANCEL),
  846. GetAndResetSentGestures()));
  847. EXPECT_EQ(LastSentGestureLocation(), gfx::PointF(1, 1));
  848. }
  849. // Test that a MultiFingerSwipe event is dispatched when appropriate.
  850. TEST_F(TouchDispositionGestureFilterTest, TestAllowedMultiFingerSwipe) {
  851. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_SCROLL_BEGIN));
  852. SendTouchNotConsumedAckForLastTouch();
  853. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN),
  854. GetAndResetSentGestures()));
  855. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_PINCH_BEGIN));
  856. SendTouchNotConsumedAckForLastTouch();
  857. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_PINCH_BEGIN),
  858. GetAndResetSentGestures()));
  859. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_SWIPE));
  860. SendTouchNotConsumedAckForLastTouch();
  861. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SWIPE),
  862. GetAndResetSentGestures()));
  863. }
  864. // Test that a MultiFingerSwipe event is dispatched when appropriate.
  865. TEST_F(TouchDispositionGestureFilterTest, TestDisallowedMultiFingerSwipe) {
  866. SendPacket(PressTouchPoint(), NoGestures());
  867. SendTouchNotConsumedAckForLastTouch();
  868. SendPacket(MoveTouchPoint(), Gestures(ET_GESTURE_SCROLL_BEGIN));
  869. SendTouchConsumedAckForLastTouch();
  870. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SCROLL_BEGIN),
  871. GetAndResetSentGestures()));
  872. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_PINCH_BEGIN));
  873. SendTouchNotConsumedAckForLastTouch();
  874. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_PINCH_BEGIN),
  875. GetAndResetSentGestures()));
  876. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_SWIPE));
  877. SendTouchConsumedAckForLastTouch();
  878. EXPECT_FALSE(GesturesSent());
  879. }
  880. TEST_F(TouchDispositionGestureFilterTest, TapCancelOnSecondFingerDown) {
  881. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_TAP_DOWN));
  882. SendTouchNotConsumedAckForLastTouch();
  883. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN),
  884. GetAndResetSentGestures()));
  885. SendPacket(PressTouchPoint(), NoGestures());
  886. SendTouchNotConsumedAckForLastTouch();
  887. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_CANCEL),
  888. GetAndResetSentGestures()));
  889. }
  890. TEST_F(TouchDispositionGestureFilterTest, ShowPressBoundingBox) {
  891. GestureEventDataPacket press_packet;
  892. press_packet.Push(CreateGesture(ET_GESTURE_TAP_DOWN, 9, 9, 8));
  893. SendTouchGestures(PressTouchPoint(), press_packet);
  894. SendTouchNotConsumedAckForLastTouch();
  895. EXPECT_TRUE(
  896. GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN), GetAndResetSentGestures()));
  897. GestureEventDataPacket release_packet;
  898. release_packet.Push(CreateGesture(ET_GESTURE_TAP, 10, 10, 10));
  899. SendTouchGestures(ReleaseTouchPoint(), release_packet);
  900. SendTouchNotConsumedAckForLastTouch();
  901. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SHOW_PRESS, ET_GESTURE_TAP),
  902. GetAndResetSentGestures()));
  903. EXPECT_EQ(gfx::Rect(5, 5, 10, 10), ShowPressBoundingBox());
  904. }
  905. TEST_F(TouchDispositionGestureFilterTest, TapCancelledBeforeGestureEnd) {
  906. SendPacket(PressTouchPoint(),
  907. Gestures(ET_GESTURE_BEGIN, ET_GESTURE_TAP_DOWN));
  908. SendTouchNotConsumedAckForLastTouch();
  909. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_BEGIN, ET_GESTURE_TAP_DOWN),
  910. GetAndResetSentGestures()));
  911. SendTimeoutGesture(ET_GESTURE_SHOW_PRESS);
  912. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_SHOW_PRESS),
  913. GetAndResetSentGestures()));
  914. SendTimeoutGesture(ET_GESTURE_LONG_PRESS);
  915. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_LONG_PRESS),
  916. GetAndResetSentGestures()));
  917. SendPacket(CancelTouchPoint(), Gestures(ET_GESTURE_END));
  918. SendTouchNotConsumedAckForLastTouch();
  919. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_CANCEL, ET_GESTURE_END),
  920. GetAndResetSentGestures()));
  921. }
  922. TEST_F(TouchDispositionGestureFilterTest, EventFlagPropagation) {
  923. // Real gestures should propagate flags from their causal touches.
  924. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_TAP_DOWN));
  925. SendTouchNotConsumedAckForLastTouch();
  926. EXPECT_TRUE(
  927. GesturesMatch(Gestures(ET_GESTURE_TAP_DOWN), GetAndResetSentGestures()));
  928. EXPECT_EQ(kDefaultEventFlags, LastSentGestureFlags());
  929. // Synthetic gestures lack flags.
  930. SendPacket(PressTouchPoint(), NoGestures());
  931. SendTouchNotConsumedAckForLastTouch();
  932. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_TAP_CANCEL),
  933. GetAndResetSentGestures()));
  934. EXPECT_EQ(0, LastSentGestureFlags());
  935. }
  936. TEST_F(TouchDispositionGestureFilterTest, PreviousScrollPrevented) {
  937. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_BEGIN));
  938. EXPECT_FALSE(GesturesSent());
  939. SendTouchNotConsumedAckForLastTouch();
  940. EXPECT_TRUE(
  941. GesturesMatch(Gestures(ET_GESTURE_BEGIN), GetAndResetSentGestures()));
  942. // The sent scroll update should always reflect whether any preceding scroll
  943. // update has been dropped.
  944. SendPacket(MoveTouchPoint(), Gestures(ET_GESTURE_SCROLL_UPDATE));
  945. SendTouchNotConsumedAckForLastTouch();
  946. ASSERT_TRUE(GesturesSent());
  947. GetAndResetSentGestures();
  948. SendPacket(MoveTouchPoint(), Gestures(ET_GESTURE_SCROLL_UPDATE));
  949. SendTouchConsumedAckForLastTouch();
  950. EXPECT_FALSE(GesturesSent());
  951. SendPacket(MoveTouchPoint(), Gestures(ET_GESTURE_SCROLL_UPDATE));
  952. SendTouchNotConsumedAckForLastTouch();
  953. ASSERT_TRUE(GesturesSent());
  954. GetAndResetSentGestures();
  955. SendPacket(MoveTouchPoint(), Gestures(ET_GESTURE_SCROLL_UPDATE));
  956. SendTouchNotConsumedAckForLastTouch();
  957. ASSERT_TRUE(GesturesSent());
  958. }
  959. TEST_F(TouchDispositionGestureFilterTest, AckQueueBack) {
  960. SendPacket(PressTouchPoint(1, 1), Gestures(ET_GESTURE_BEGIN));
  961. SendTouchNotConsumedAckForLastTouch();
  962. SendPacket(MoveTouchPoint(), Gestures(ET_GESTURE_SCROLL_BEGIN));
  963. SendTouchNotConsumedAckForLastTouch();
  964. GetAndResetSentGestures();
  965. // Pending touch move.
  966. GestureEventDataPacket packet1;
  967. packet1.Push(CreateGesture(ET_GESTURE_SCROLL_UPDATE, 2, 3, 0));
  968. uint32_t touch_event_id = SendTouchGestures(MoveTouchPoint(), packet1);
  969. EXPECT_FALSE(GesturesSent());
  970. // Additional pending touch move.
  971. SendPacket(MoveTouchPoint(), Gestures(ET_GESTURE_SCROLL_UPDATE));
  972. // Ack back of the queue consumed.
  973. SendTouchConsumedAckForLastTouch();
  974. // Ack the pending touch.
  975. GetAndResetSentGestures();
  976. SendTouchNotConsumedAck(touch_event_id);
  977. // The consumed touch doesn't produce a gesture.
  978. EXPECT_TRUE(GesturesMatch(
  979. Gestures(ET_GESTURE_SCROLL_UPDATE),
  980. GetAndResetSentGestures()));
  981. EXPECT_EQ(gfx::PointF(2, 3), LastSentGestureLocation());
  982. // Pending touch move.
  983. touch_event_id =
  984. SendPacket(MoveTouchPoint(), Gestures(ET_GESTURE_SCROLL_UPDATE));
  985. EXPECT_FALSE(GesturesSent());
  986. // Ack back of the queue unconsumed (twice).
  987. SendPacket(MoveTouchPoint(), Gestures(ET_GESTURE_SCROLL_UPDATE));
  988. SendTouchNotConsumedAckForLastTouch();
  989. GestureEventDataPacket packet2;
  990. packet2.Push(CreateGesture(ET_GESTURE_SCROLL_UPDATE, 7, 8, 0));
  991. SendTouchGestures(MoveTouchPoint(), packet2);
  992. EXPECT_FALSE(GesturesSent());
  993. SendTouchNotConsumedAckForLastTouch();
  994. // Ack the pending touch.
  995. GetAndResetSentGestures();
  996. SendTouchNotConsumedAck(touch_event_id);
  997. // Both touches have now been acked.
  998. EXPECT_TRUE(
  999. GesturesMatch(Gestures(ET_GESTURE_SCROLL_UPDATE, ET_GESTURE_SCROLL_UPDATE,
  1000. ET_GESTURE_SCROLL_UPDATE),
  1001. GetAndResetSentGestures()));
  1002. EXPECT_EQ(gfx::PointF(7, 8), LastSentGestureLocation());
  1003. }
  1004. TEST_F(TouchDispositionGestureFilterTest, AckQueueGestureAtBack) {
  1005. // Send gesture sequence
  1006. uint32_t touch_press_event_id1 =
  1007. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_BEGIN));
  1008. uint32_t touch_release_event_id1 =
  1009. SendPacket(ReleaseTouchPoint(), Gestures(ET_GESTURE_END));
  1010. // Send second gesture sequence, and synchronously ack it.
  1011. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_BEGIN));
  1012. SendTouchNotConsumedAckForLastTouch();
  1013. GestureEventDataPacket packet;
  1014. packet.Push(CreateGesture(ET_GESTURE_END, 2, 3, 0));
  1015. SendTouchGestures(ReleaseTouchPoint(), packet);
  1016. SendTouchNotConsumedAckForLastTouch();
  1017. // The second gesture sequence is blocked on the first.
  1018. EXPECT_FALSE(GesturesSent());
  1019. SendTouchNotConsumedAck(touch_press_event_id1);
  1020. SendTouchNotConsumedAck(touch_release_event_id1);
  1021. // Both gestures have now been acked.
  1022. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_BEGIN, ET_GESTURE_END,
  1023. ET_GESTURE_BEGIN, ET_GESTURE_END),
  1024. GetAndResetSentGestures()));
  1025. EXPECT_EQ(gfx::PointF(2, 3), LastSentGestureLocation());
  1026. }
  1027. TEST_F(TouchDispositionGestureFilterTest,
  1028. SyncAcksOnlyTriggerAppropriateGestures) {
  1029. // Queue a touch press.
  1030. uint32_t touch_press_event_id =
  1031. SendPacket(PressTouchPoint(), Gestures(ET_GESTURE_BEGIN));
  1032. // Send and synchronously ack two touch moves.
  1033. SendPacket(MoveTouchPoint(), Gestures(ET_GESTURE_SCROLL_UPDATE));
  1034. SendTouchNotConsumedAckForLastTouch();
  1035. SendPacket(MoveTouchPoint(), Gestures(ET_GESTURE_SCROLL_UPDATE));
  1036. SendTouchNotConsumedAckForLastTouch();
  1037. // Queue a touch release.
  1038. uint32_t touch_release_event_id =
  1039. SendPacket(ReleaseTouchPoint(), Gestures(ET_GESTURE_END));
  1040. EXPECT_FALSE(GesturesSent());
  1041. // Ack the touch press. All events but the release should be acked.
  1042. SendTouchNotConsumedAck(touch_press_event_id);
  1043. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_BEGIN, ET_GESTURE_SCROLL_UPDATE,
  1044. ET_GESTURE_SCROLL_UPDATE),
  1045. GetAndResetSentGestures()));
  1046. // The touch release still requires an ack.
  1047. SendTouchNotConsumedAck(touch_release_event_id);
  1048. EXPECT_TRUE(GesturesMatch(Gestures(ET_GESTURE_END),
  1049. GetAndResetSentGestures()));
  1050. }
  1051. } // namespace ui