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 5 #include <vector> 6 7 #include "base/basictypes.h" 8 #include "base/logging.h" 9 #include "base/memory/scoped_ptr.h" 10 #include "base/message_loop/message_loop.h" 11 #include "base/time/time.h" 12 #include "content/browser/renderer_host/input/gesture_event_queue.h" 13 #include "content/browser/renderer_host/input/touchpad_tap_suppression_controller.h" 14 #include "content/common/input/input_event_ack_state.h" 15 #include "content/common/input/synthetic_web_input_event_builders.h" 16 #include "testing/gtest/include/gtest/gtest.h" 17 #include "third_party/WebKit/public/web/WebInputEvent.h" 18 19 using base::TimeDelta; 20 using blink::WebGestureDevice; 21 using blink::WebGestureEvent; 22 using blink::WebInputEvent; 23 24 namespace content { 25 26 class GestureEventQueueTest : public testing::Test, 27 public GestureEventQueueClient, 28 public TouchpadTapSuppressionControllerClient { 29 public: 30 GestureEventQueueTest() 31 : acked_gesture_event_count_(0), 32 sent_gesture_event_count_(0) {} 33 34 virtual ~GestureEventQueueTest() {} 35 36 // testing::Test 37 virtual void SetUp() OVERRIDE { 38 queue_.reset(new GestureEventQueue(this, this, DefaultConfig())); 39 } 40 41 virtual void TearDown() OVERRIDE { 42 // Process all pending tasks to avoid leaks. 43 RunUntilIdle(); 44 queue_.reset(); 45 } 46 47 // GestureEventQueueClient 48 virtual void SendGestureEventImmediately( 49 const GestureEventWithLatencyInfo& event) OVERRIDE { 50 ++sent_gesture_event_count_; 51 if (sync_ack_result_) { 52 scoped_ptr<InputEventAckState> ack_result = sync_ack_result_.Pass(); 53 SendInputEventACK(event.event.type, *ack_result); 54 } 55 } 56 57 virtual void OnGestureEventAck( 58 const GestureEventWithLatencyInfo& event, 59 InputEventAckState ack_result) OVERRIDE { 60 ++acked_gesture_event_count_; 61 last_acked_event_ = event.event; 62 if (sync_followup_event_) 63 SimulateGestureEvent(*sync_followup_event_.Pass()); 64 } 65 66 // TouchpadTapSuppressionControllerClient 67 virtual void SendMouseEventImmediately( 68 const MouseEventWithLatencyInfo& event) OVERRIDE { 69 } 70 71 protected: 72 static GestureEventQueue::Config DefaultConfig() { 73 return GestureEventQueue::Config(); 74 } 75 76 void SetUpForDebounce(int interval_ms) { 77 queue()->set_debounce_interval_time_ms_for_testing(interval_ms); 78 } 79 80 // Returns the result of |GestureEventQueue::ShouldForward()|. 81 bool SimulateGestureEvent(const WebGestureEvent& gesture) { 82 GestureEventWithLatencyInfo gesture_with_latency(gesture, 83 ui::LatencyInfo()); 84 if (queue()->ShouldForward(gesture_with_latency)) { 85 SendGestureEventImmediately(gesture_with_latency); 86 return true; 87 } 88 return false; 89 } 90 91 void SimulateGestureEvent(WebInputEvent::Type type, 92 WebGestureDevice sourceDevice) { 93 SimulateGestureEvent( 94 SyntheticWebGestureEventBuilder::Build(type, sourceDevice)); 95 } 96 97 void SimulateGestureScrollUpdateEvent(float dX, float dY, int modifiers) { 98 SimulateGestureEvent( 99 SyntheticWebGestureEventBuilder::BuildScrollUpdate(dX, dY, modifiers)); 100 } 101 102 void SimulateGesturePinchUpdateEvent(float scale, 103 float anchorX, 104 float anchorY, 105 int modifiers) { 106 SimulateGestureEvent(SyntheticWebGestureEventBuilder::BuildPinchUpdate( 107 scale, 108 anchorX, 109 anchorY, 110 modifiers, 111 blink::WebGestureDeviceTouchscreen)); 112 } 113 114 void SimulateGestureFlingStartEvent(float velocityX, 115 float velocityY, 116 WebGestureDevice sourceDevice) { 117 SimulateGestureEvent( 118 SyntheticWebGestureEventBuilder::BuildFling(velocityX, 119 velocityY, 120 sourceDevice)); 121 } 122 123 void SendInputEventACK(WebInputEvent::Type type, 124 InputEventAckState ack) { 125 queue()->ProcessGestureAck(ack, type, ui::LatencyInfo()); 126 } 127 128 void RunUntilIdle() { 129 base::MessageLoop::current()->RunUntilIdle(); 130 } 131 132 size_t GetAndResetSentGestureEventCount() { 133 size_t count = sent_gesture_event_count_; 134 sent_gesture_event_count_ = 0; 135 return count; 136 } 137 138 size_t GetAndResetAckedGestureEventCount() { 139 size_t count = acked_gesture_event_count_; 140 acked_gesture_event_count_ = 0; 141 return count; 142 } 143 144 const WebGestureEvent& last_acked_event() const { 145 return last_acked_event_; 146 } 147 148 void set_synchronous_ack(InputEventAckState ack_result) { 149 sync_ack_result_.reset(new InputEventAckState(ack_result)); 150 } 151 152 void set_sync_followup_event(WebInputEvent::Type type, 153 WebGestureDevice sourceDevice) { 154 sync_followup_event_.reset(new WebGestureEvent( 155 SyntheticWebGestureEventBuilder::Build(type, sourceDevice))); 156 } 157 158 unsigned GestureEventQueueSize() { 159 return queue()->coalesced_gesture_events_.size(); 160 } 161 162 WebGestureEvent GestureEventSecondFromLastQueueEvent() { 163 return queue()->coalesced_gesture_events_.at( 164 GestureEventQueueSize() - 2).event; 165 } 166 167 WebGestureEvent GestureEventLastQueueEvent() { 168 return queue()->coalesced_gesture_events_.back().event; 169 } 170 171 unsigned GestureEventDebouncingQueueSize() { 172 return queue()->debouncing_deferral_queue_.size(); 173 } 174 175 WebGestureEvent GestureEventQueueEventAt(int i) { 176 return queue()->coalesced_gesture_events_.at(i).event; 177 } 178 179 bool ScrollingInProgress() { 180 return queue()->scrolling_in_progress_; 181 } 182 183 bool FlingInProgress() { 184 return queue()->fling_in_progress_; 185 } 186 187 bool WillIgnoreNextACK() { 188 return queue()->ignore_next_ack_; 189 } 190 191 GestureEventQueue* queue() const { 192 return queue_.get(); 193 } 194 195 private: 196 scoped_ptr<GestureEventQueue> queue_; 197 size_t acked_gesture_event_count_; 198 size_t sent_gesture_event_count_; 199 WebGestureEvent last_acked_event_; 200 scoped_ptr<InputEventAckState> sync_ack_result_; 201 scoped_ptr<WebGestureEvent> sync_followup_event_; 202 base::MessageLoopForUI message_loop_; 203 }; 204 205 #if GTEST_HAS_PARAM_TEST 206 // This is for tests that are to be run for all source devices. 207 class GestureEventQueueWithSourceTest 208 : public GestureEventQueueTest, 209 public testing::WithParamInterface<WebGestureDevice> {}; 210 #endif // GTEST_HAS_PARAM_TEST 211 212 TEST_F(GestureEventQueueTest, CoalescesScrollGestureEvents) { 213 // Test coalescing of only GestureScrollUpdate events. 214 // Simulate gesture events. 215 216 // Sent. 217 SimulateGestureEvent(WebInputEvent::GestureScrollBegin, 218 blink::WebGestureDeviceTouchscreen); 219 EXPECT_EQ(1U, GetAndResetSentGestureEventCount()); 220 221 // Enqueued. 222 SimulateGestureScrollUpdateEvent(8, -5, 0); 223 224 // Make sure that the queue contains what we think it should. 225 WebGestureEvent merged_event = GestureEventLastQueueEvent(); 226 EXPECT_EQ(2U, GestureEventQueueSize()); 227 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type); 228 EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice); 229 230 // Coalesced. 231 SimulateGestureScrollUpdateEvent(8, -6, 0); 232 233 // Check that coalescing updated the correct values. 234 merged_event = GestureEventLastQueueEvent(); 235 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type); 236 EXPECT_EQ(0, merged_event.modifiers); 237 EXPECT_EQ(16, merged_event.data.scrollUpdate.deltaX); 238 EXPECT_EQ(-11, merged_event.data.scrollUpdate.deltaY); 239 EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice); 240 241 // Enqueued. 242 SimulateGestureScrollUpdateEvent(8, -7, 1); 243 244 // Check that we didn't wrongly coalesce. 245 merged_event = GestureEventLastQueueEvent(); 246 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type); 247 EXPECT_EQ(1, merged_event.modifiers); 248 EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice); 249 250 // Different. 251 SimulateGestureEvent(WebInputEvent::GestureScrollEnd, 252 blink::WebGestureDeviceTouchscreen); 253 254 // Check that only the first event was sent. 255 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 256 257 // Check that the ACK sends the second message. 258 SendInputEventACK(WebInputEvent::GestureScrollBegin, 259 INPUT_EVENT_ACK_STATE_CONSUMED); 260 RunUntilIdle(); 261 EXPECT_EQ(1U, GetAndResetAckedGestureEventCount()); 262 EXPECT_EQ(1U, GetAndResetSentGestureEventCount()); 263 264 // Ack for queued coalesced event. 265 SendInputEventACK(WebInputEvent::GestureScrollUpdate, 266 INPUT_EVENT_ACK_STATE_CONSUMED); 267 RunUntilIdle(); 268 EXPECT_EQ(1U, GetAndResetAckedGestureEventCount()); 269 EXPECT_EQ(1U, GetAndResetSentGestureEventCount()); 270 271 // Ack for queued uncoalesced event. 272 SendInputEventACK(WebInputEvent::GestureScrollUpdate, 273 INPUT_EVENT_ACK_STATE_CONSUMED); 274 RunUntilIdle(); 275 EXPECT_EQ(1U, GetAndResetAckedGestureEventCount()); 276 EXPECT_EQ(1U, GetAndResetSentGestureEventCount()); 277 278 // After the final ack, the queue should be empty. 279 SendInputEventACK(WebInputEvent::GestureScrollEnd, 280 INPUT_EVENT_ACK_STATE_CONSUMED); 281 RunUntilIdle(); 282 EXPECT_EQ(1U, GetAndResetAckedGestureEventCount()); 283 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 284 } 285 286 TEST_F(GestureEventQueueTest, 287 DoesNotCoalesceScrollGestureEventsFromDifferentDevices) { 288 // Test that GestureScrollUpdate events from Touchscreen and Touchpad do not 289 // coalesce. 290 291 // Sent. 292 SimulateGestureEvent(WebInputEvent::GestureScrollBegin, 293 blink::WebGestureDeviceTouchscreen); 294 EXPECT_EQ(1U, GetAndResetSentGestureEventCount()); 295 296 // Enqueued. 297 SimulateGestureScrollUpdateEvent(8, -5, 0); 298 299 // Make sure that the queue contains what we think it should. 300 EXPECT_EQ(2U, GestureEventQueueSize()); 301 EXPECT_EQ(blink::WebGestureDeviceTouchscreen, 302 GestureEventLastQueueEvent().sourceDevice); 303 304 // Coalesced. 305 SimulateGestureScrollUpdateEvent(8, -6, 0); 306 EXPECT_EQ(2U, GestureEventQueueSize()); 307 EXPECT_EQ(blink::WebGestureDeviceTouchscreen, 308 GestureEventLastQueueEvent().sourceDevice); 309 310 // Enqueued. 311 SimulateGestureEvent(WebInputEvent::GestureScrollUpdate, 312 blink::WebGestureDeviceTouchpad); 313 EXPECT_EQ(3U, GestureEventQueueSize()); 314 EXPECT_EQ(blink::WebGestureDeviceTouchpad, 315 GestureEventLastQueueEvent().sourceDevice); 316 317 // Coalesced. 318 SimulateGestureEvent(WebInputEvent::GestureScrollUpdate, 319 blink::WebGestureDeviceTouchpad); 320 EXPECT_EQ(3U, GestureEventQueueSize()); 321 EXPECT_EQ(blink::WebGestureDeviceTouchpad, 322 GestureEventLastQueueEvent().sourceDevice); 323 324 // Enqueued. 325 SimulateGestureScrollUpdateEvent(8, -7, 0); 326 EXPECT_EQ(4U, GestureEventQueueSize()); 327 EXPECT_EQ(blink::WebGestureDeviceTouchscreen, 328 GestureEventLastQueueEvent().sourceDevice); 329 } 330 331 TEST_F(GestureEventQueueTest, CoalescesScrollAndPinchEvents) { 332 // Test coalescing of only GestureScrollUpdate events. 333 // Simulate gesture events. 334 335 // Sent. 336 SimulateGestureEvent(WebInputEvent::GestureScrollBegin, 337 blink::WebGestureDeviceTouchscreen); 338 339 // Sent. 340 SimulateGestureEvent(WebInputEvent::GesturePinchBegin, 341 blink::WebGestureDeviceTouchscreen); 342 343 // Enqueued. 344 SimulateGestureScrollUpdateEvent(8, -4, 1); 345 346 // Make sure that the queue contains what we think it should. 347 WebGestureEvent merged_event = GestureEventLastQueueEvent(); 348 EXPECT_EQ(3U, GestureEventQueueSize()); 349 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type); 350 351 // Coalesced without changing event order. Note anchor at (60, 60). Anchoring 352 // from a point that is not the origin should still give us the right scroll. 353 SimulateGesturePinchUpdateEvent(1.5, 60, 60, 1); 354 EXPECT_EQ(4U, GestureEventQueueSize()); 355 merged_event = GestureEventLastQueueEvent(); 356 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type); 357 EXPECT_EQ(1.5, merged_event.data.pinchUpdate.scale); 358 EXPECT_EQ(1, merged_event.modifiers); 359 EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice); 360 merged_event = GestureEventSecondFromLastQueueEvent(); 361 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type); 362 EXPECT_EQ(8, merged_event.data.scrollUpdate.deltaX); 363 EXPECT_EQ(-4, merged_event.data.scrollUpdate.deltaY); 364 EXPECT_EQ(1, merged_event.modifiers); 365 EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice); 366 367 // Enqueued. 368 SimulateGestureScrollUpdateEvent(6, -3, 1); 369 370 // Check whether coalesced correctly. 371 EXPECT_EQ(4U, GestureEventQueueSize()); 372 merged_event = GestureEventLastQueueEvent(); 373 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type); 374 EXPECT_EQ(1.5, merged_event.data.pinchUpdate.scale); 375 EXPECT_EQ(1, merged_event.modifiers); 376 EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice); 377 merged_event = GestureEventSecondFromLastQueueEvent(); 378 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type); 379 EXPECT_EQ(12, merged_event.data.scrollUpdate.deltaX); 380 EXPECT_EQ(-6, merged_event.data.scrollUpdate.deltaY); 381 EXPECT_EQ(1, merged_event.modifiers); 382 EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice); 383 384 // Enqueued. 385 SimulateGesturePinchUpdateEvent(2, 60, 60, 1); 386 387 // Check whether coalesced correctly. 388 EXPECT_EQ(4U, GestureEventQueueSize()); 389 merged_event = GestureEventLastQueueEvent(); 390 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type); 391 EXPECT_EQ(3, merged_event.data.pinchUpdate.scale); 392 EXPECT_EQ(1, merged_event.modifiers); 393 EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice); 394 merged_event = GestureEventSecondFromLastQueueEvent(); 395 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type); 396 EXPECT_EQ(12, merged_event.data.scrollUpdate.deltaX); 397 EXPECT_EQ(-6, merged_event.data.scrollUpdate.deltaY); 398 EXPECT_EQ(1, merged_event.modifiers); 399 EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice); 400 401 // Enqueued. 402 SimulateGesturePinchUpdateEvent(2, 60, 60, 1); 403 404 // Check whether coalesced correctly. 405 EXPECT_EQ(4U, GestureEventQueueSize()); 406 merged_event = GestureEventLastQueueEvent(); 407 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type); 408 EXPECT_EQ(6, merged_event.data.pinchUpdate.scale); 409 EXPECT_EQ(1, merged_event.modifiers); 410 EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice); 411 merged_event = GestureEventSecondFromLastQueueEvent(); 412 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type); 413 EXPECT_EQ(12, merged_event.data.scrollUpdate.deltaX); 414 EXPECT_EQ(-6, merged_event.data.scrollUpdate.deltaY); 415 EXPECT_EQ(1, merged_event.modifiers); 416 EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice); 417 418 // Check that only the first event was sent. 419 EXPECT_EQ(1U, GetAndResetSentGestureEventCount()); 420 421 // Check that the ACK sends the second message. 422 SendInputEventACK(WebInputEvent::GestureScrollBegin, 423 INPUT_EVENT_ACK_STATE_CONSUMED); 424 RunUntilIdle(); 425 EXPECT_EQ(1U, GetAndResetSentGestureEventCount()); 426 427 // Enqueued. 428 SimulateGestureScrollUpdateEvent(6, -6, 1); 429 430 // Check whether coalesced correctly. 431 EXPECT_EQ(3U, GestureEventQueueSize()); 432 merged_event = GestureEventLastQueueEvent(); 433 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type); 434 EXPECT_EQ(6, merged_event.data.pinchUpdate.scale); 435 EXPECT_EQ(1, merged_event.modifiers); 436 EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice); 437 merged_event = GestureEventSecondFromLastQueueEvent(); 438 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type); 439 EXPECT_EQ(13, merged_event.data.scrollUpdate.deltaX); 440 EXPECT_EQ(-7, merged_event.data.scrollUpdate.deltaY); 441 EXPECT_EQ(1, merged_event.modifiers); 442 EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice); 443 444 // At this point ACKs shouldn't be getting ignored. 445 EXPECT_FALSE(WillIgnoreNextACK()); 446 447 // Check that the ACK sends both scroll and pinch updates. 448 SendInputEventACK(WebInputEvent::GesturePinchBegin, 449 INPUT_EVENT_ACK_STATE_CONSUMED); 450 RunUntilIdle(); 451 EXPECT_EQ(2U, GetAndResetSentGestureEventCount()); 452 453 // The next ACK should be getting ignored. 454 EXPECT_TRUE(WillIgnoreNextACK()); 455 456 // Enqueued. 457 SimulateGestureScrollUpdateEvent(1, -1, 1); 458 459 // Check whether coalesced correctly. 460 EXPECT_EQ(3U, GestureEventQueueSize()); 461 merged_event = GestureEventLastQueueEvent(); 462 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type); 463 EXPECT_EQ(1, merged_event.data.scrollUpdate.deltaX); 464 EXPECT_EQ(-1, merged_event.data.scrollUpdate.deltaY); 465 EXPECT_EQ(1, merged_event.modifiers); 466 EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice); 467 merged_event = GestureEventSecondFromLastQueueEvent(); 468 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type); 469 EXPECT_EQ(6, merged_event.data.pinchUpdate.scale); 470 EXPECT_EQ(1, merged_event.modifiers); 471 EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice); 472 473 // Enqueued. 474 SimulateGestureScrollUpdateEvent(2, -2, 1); 475 476 // Coalescing scrolls should still work. 477 EXPECT_EQ(3U, GestureEventQueueSize()); 478 merged_event = GestureEventLastQueueEvent(); 479 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type); 480 EXPECT_EQ(3, merged_event.data.scrollUpdate.deltaX); 481 EXPECT_EQ(-3, merged_event.data.scrollUpdate.deltaY); 482 EXPECT_EQ(1, merged_event.modifiers); 483 EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice); 484 merged_event = GestureEventSecondFromLastQueueEvent(); 485 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type); 486 EXPECT_EQ(6, merged_event.data.pinchUpdate.scale); 487 EXPECT_EQ(1, merged_event.modifiers); 488 EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice); 489 490 // Enqueued. 491 SimulateGesturePinchUpdateEvent(0.5, 60, 60, 1); 492 493 // Check whether coalesced correctly. 494 EXPECT_EQ(4U, GestureEventQueueSize()); 495 merged_event = GestureEventLastQueueEvent(); 496 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type); 497 EXPECT_EQ(0.5, merged_event.data.pinchUpdate.scale); 498 EXPECT_EQ(1, merged_event.modifiers); 499 EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice); 500 merged_event = GestureEventSecondFromLastQueueEvent(); 501 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type); 502 EXPECT_EQ(3, merged_event.data.scrollUpdate.deltaX); 503 EXPECT_EQ(-3, merged_event.data.scrollUpdate.deltaY); 504 EXPECT_EQ(1, merged_event.modifiers); 505 EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice); 506 507 // Check that the ACK gets ignored. 508 SendInputEventACK(WebInputEvent::GestureScrollUpdate, 509 INPUT_EVENT_ACK_STATE_CONSUMED); 510 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, last_acked_event().type); 511 RunUntilIdle(); 512 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 513 // The flag should have been flipped back to false. 514 EXPECT_FALSE(WillIgnoreNextACK()); 515 516 // Enqueued. 517 SimulateGestureScrollUpdateEvent(2, -2, 2); 518 519 // Shouldn't coalesce with different modifiers. 520 EXPECT_EQ(4U, GestureEventQueueSize()); 521 merged_event = GestureEventLastQueueEvent(); 522 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type); 523 EXPECT_EQ(2, merged_event.data.scrollUpdate.deltaX); 524 EXPECT_EQ(-2, merged_event.data.scrollUpdate.deltaY); 525 EXPECT_EQ(2, merged_event.modifiers); 526 EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice); 527 merged_event = GestureEventSecondFromLastQueueEvent(); 528 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type); 529 EXPECT_EQ(0.5, merged_event.data.pinchUpdate.scale); 530 EXPECT_EQ(1, merged_event.modifiers); 531 EXPECT_EQ(blink::WebGestureDeviceTouchscreen, merged_event.sourceDevice); 532 533 // Check that the ACK sends the next scroll pinch pair. 534 SendInputEventACK(WebInputEvent::GesturePinchUpdate, 535 INPUT_EVENT_ACK_STATE_CONSUMED); 536 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, last_acked_event().type); 537 RunUntilIdle(); 538 EXPECT_EQ(2U, GetAndResetSentGestureEventCount()); 539 540 // Check that the ACK sends the second message. 541 SendInputEventACK(WebInputEvent::GestureScrollUpdate, 542 INPUT_EVENT_ACK_STATE_CONSUMED); 543 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, last_acked_event().type); 544 RunUntilIdle(); 545 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 546 547 // Check that the ACK sends the second event. 548 SendInputEventACK(WebInputEvent::GesturePinchUpdate, 549 INPUT_EVENT_ACK_STATE_CONSUMED); 550 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, last_acked_event().type); 551 RunUntilIdle(); 552 EXPECT_EQ(1U, GetAndResetSentGestureEventCount()); 553 554 // Check that the queue is empty after ACK and no events get sent. 555 SendInputEventACK(WebInputEvent::GestureScrollUpdate, 556 INPUT_EVENT_ACK_STATE_CONSUMED); 557 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, last_acked_event().type); 558 RunUntilIdle(); 559 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 560 EXPECT_EQ(0U, GestureEventQueueSize()); 561 } 562 563 TEST_F(GestureEventQueueTest, CoalescesMultiplePinchEventSequences) { 564 // Simulate a pinch sequence. 565 SimulateGestureEvent(WebInputEvent::GestureScrollBegin, 566 blink::WebGestureDeviceTouchscreen); 567 SimulateGestureEvent(WebInputEvent::GesturePinchBegin, 568 blink::WebGestureDeviceTouchscreen); 569 570 SimulateGestureScrollUpdateEvent(8, -4, 1); 571 // Make sure that the queue contains what we think it should. 572 WebGestureEvent merged_event = GestureEventLastQueueEvent(); 573 size_t expected_events_in_queue = 3; 574 EXPECT_EQ(expected_events_in_queue, GestureEventQueueSize()); 575 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type); 576 577 // Coalesced without changing event order. Note anchor at (60, 60). Anchoring 578 // from a point that is not the origin should still give us the right scroll. 579 SimulateGesturePinchUpdateEvent(1.5, 60, 60, 1); 580 EXPECT_EQ(++expected_events_in_queue, GestureEventQueueSize()); 581 merged_event = GestureEventLastQueueEvent(); 582 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type); 583 EXPECT_EQ(1.5, merged_event.data.pinchUpdate.scale); 584 EXPECT_EQ(1, merged_event.modifiers); 585 merged_event = GestureEventSecondFromLastQueueEvent(); 586 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type); 587 EXPECT_EQ(8, merged_event.data.scrollUpdate.deltaX); 588 EXPECT_EQ(-4, merged_event.data.scrollUpdate.deltaY); 589 EXPECT_EQ(1, merged_event.modifiers); 590 591 // Enqueued. 592 SimulateGestureScrollUpdateEvent(6, -3, 1); 593 594 // Check whether coalesced correctly. 595 EXPECT_EQ(expected_events_in_queue, GestureEventQueueSize()); 596 merged_event = GestureEventLastQueueEvent(); 597 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type); 598 EXPECT_EQ(1.5, merged_event.data.pinchUpdate.scale); 599 EXPECT_EQ(1, merged_event.modifiers); 600 merged_event = GestureEventSecondFromLastQueueEvent(); 601 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type); 602 EXPECT_EQ(12, merged_event.data.scrollUpdate.deltaX); 603 EXPECT_EQ(-6, merged_event.data.scrollUpdate.deltaY); 604 EXPECT_EQ(1, merged_event.modifiers); 605 606 // Now start another sequence before the previous sequence has been ack'ed. 607 SimulateGestureEvent(WebInputEvent::GesturePinchEnd, 608 blink::WebGestureDeviceTouchscreen); 609 SimulateGestureEvent(WebInputEvent::GestureScrollEnd, 610 blink::WebGestureDeviceTouchscreen); 611 SimulateGestureEvent(WebInputEvent::GestureScrollBegin, 612 blink::WebGestureDeviceTouchscreen); 613 SimulateGestureEvent(WebInputEvent::GesturePinchBegin, 614 blink::WebGestureDeviceTouchscreen); 615 616 SimulateGestureScrollUpdateEvent(8, -4, 1); 617 // Make sure that the queue contains what we think it should. 618 expected_events_in_queue += 5; 619 merged_event = GestureEventLastQueueEvent(); 620 EXPECT_EQ(expected_events_in_queue, GestureEventQueueSize()); 621 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type); 622 623 // Coalesced without changing event order. Note anchor at (60, 60). Anchoring 624 // from a point that is not the origin should still give us the right scroll. 625 SimulateGesturePinchUpdateEvent(1.5, 30, 30, 1); 626 EXPECT_EQ(++expected_events_in_queue, GestureEventQueueSize()); 627 merged_event = GestureEventLastQueueEvent(); 628 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type); 629 EXPECT_EQ(1.5, merged_event.data.pinchUpdate.scale); 630 EXPECT_EQ(1, merged_event.modifiers); 631 merged_event = GestureEventSecondFromLastQueueEvent(); 632 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type); 633 EXPECT_EQ(8, merged_event.data.scrollUpdate.deltaX); 634 EXPECT_EQ(-4, merged_event.data.scrollUpdate.deltaY); 635 EXPECT_EQ(1, merged_event.modifiers); 636 637 // Enqueued. 638 SimulateGestureScrollUpdateEvent(6, -3, 1); 639 640 // Check whether coalesced correctly. 641 EXPECT_EQ(expected_events_in_queue, GestureEventQueueSize()); 642 merged_event = GestureEventLastQueueEvent(); 643 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type); 644 EXPECT_EQ(1.5, merged_event.data.pinchUpdate.scale); 645 EXPECT_EQ(1, merged_event.modifiers); 646 merged_event = GestureEventSecondFromLastQueueEvent(); 647 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type); 648 EXPECT_EQ(12, merged_event.data.scrollUpdate.deltaX); 649 EXPECT_EQ(-6, merged_event.data.scrollUpdate.deltaY); 650 EXPECT_EQ(1, merged_event.modifiers); 651 } 652 653 TEST_F(GestureEventQueueTest, CoalescesPinchSequencesWithEarlyAck) { 654 SimulateGestureEvent(WebInputEvent::GestureScrollBegin, 655 blink::WebGestureDeviceTouchscreen); 656 SendInputEventACK(WebInputEvent::GestureScrollBegin, 657 INPUT_EVENT_ACK_STATE_CONSUMED); 658 659 SimulateGestureEvent(WebInputEvent::GesturePinchBegin, 660 blink::WebGestureDeviceTouchscreen); 661 SendInputEventACK(WebInputEvent::GesturePinchBegin, 662 INPUT_EVENT_ACK_STATE_CONSUMED); 663 // ScrollBegin and PinchBegin have been sent 664 EXPECT_EQ(2U, GetAndResetSentGestureEventCount()); 665 EXPECT_EQ(0U, GestureEventQueueSize()); 666 667 SimulateGestureScrollUpdateEvent(5, 5, 1); 668 EXPECT_EQ(1U, GetAndResetSentGestureEventCount()); 669 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, 670 GestureEventLastQueueEvent().type); 671 EXPECT_EQ(1U, GestureEventQueueSize()); 672 673 674 SimulateGesturePinchUpdateEvent(2, 60, 60, 1); 675 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 676 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, 677 GestureEventLastQueueEvent().type); 678 EXPECT_EQ(2U, GestureEventQueueSize()); 679 680 SimulateGesturePinchUpdateEvent(3, 60, 60, 1); 681 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 682 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, 683 GestureEventLastQueueEvent().type); 684 EXPECT_EQ(2U, GestureEventQueueSize()); 685 686 SimulateGestureScrollUpdateEvent(5, 5, 1); 687 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 688 // The coalesced pinch/scroll pair will have been re-arranged, with the 689 // pinch following the scroll. 690 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, 691 GestureEventLastQueueEvent().type); 692 EXPECT_EQ(3U, GestureEventQueueSize()); 693 694 SimulateGesturePinchUpdateEvent(4, 60, 60, 1); 695 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 696 EXPECT_EQ(3U, GestureEventQueueSize()); 697 698 SendInputEventACK(WebInputEvent::GestureScrollUpdate, 699 INPUT_EVENT_ACK_STATE_CONSUMED); 700 EXPECT_EQ(2U, GetAndResetSentGestureEventCount()); 701 EXPECT_EQ(2U, GestureEventQueueSize()); 702 703 SendInputEventACK(WebInputEvent::GestureScrollUpdate, 704 INPUT_EVENT_ACK_STATE_CONSUMED); 705 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, last_acked_event().type); 706 707 SendInputEventACK(WebInputEvent::GesturePinchUpdate, 708 INPUT_EVENT_ACK_STATE_CONSUMED); 709 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, last_acked_event().type); 710 EXPECT_EQ(2.f * 3.f * 4.f, last_acked_event().data.pinchUpdate.scale); 711 712 EXPECT_EQ(0U, GestureEventQueueSize()); 713 } 714 715 TEST_F(GestureEventQueueTest, 716 DoesNotCoalescePinchGestureEventsWithDifferentModifiers) { 717 // Insert an event to force queueing of gestures. 718 SimulateGestureEvent(WebInputEvent::GestureTapCancel, 719 blink::WebGestureDeviceTouchscreen); 720 EXPECT_EQ(1U, GetAndResetSentGestureEventCount()); 721 EXPECT_EQ(1U, GestureEventQueueSize()); 722 723 SimulateGestureScrollUpdateEvent(5, 5, 1); 724 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 725 EXPECT_EQ(2U, GestureEventQueueSize()); 726 727 SimulateGesturePinchUpdateEvent(3, 60, 60, 1); 728 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 729 EXPECT_EQ(3U, GestureEventQueueSize()); 730 731 SimulateGestureScrollUpdateEvent(10, 15, 1); 732 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 733 EXPECT_EQ(3U, GestureEventQueueSize()); 734 735 SimulateGesturePinchUpdateEvent(4, 60, 60, 1); 736 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 737 EXPECT_EQ(3U, GestureEventQueueSize()); 738 739 // Using different modifiers should prevent coalescing. 740 SimulateGesturePinchUpdateEvent(5, 60, 60, 2); 741 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 742 EXPECT_EQ(4U, GestureEventQueueSize()); 743 744 SimulateGesturePinchUpdateEvent(6, 60, 60, 3); 745 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 746 EXPECT_EQ(5U, GestureEventQueueSize()); 747 748 SendInputEventACK(WebInputEvent::GestureTapCancel, 749 INPUT_EVENT_ACK_STATE_CONSUMED); 750 EXPECT_EQ(2U, GetAndResetSentGestureEventCount()); 751 EXPECT_EQ(4U, GestureEventQueueSize()); 752 753 SendInputEventACK(WebInputEvent::GestureScrollUpdate, 754 INPUT_EVENT_ACK_STATE_CONSUMED); 755 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, last_acked_event().type); 756 EXPECT_EQ(3U, GestureEventQueueSize()); 757 758 SendInputEventACK(WebInputEvent::GesturePinchUpdate, 759 INPUT_EVENT_ACK_STATE_CONSUMED); 760 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, last_acked_event().type); 761 EXPECT_EQ(3.f * 4.f, last_acked_event().data.pinchUpdate.scale); 762 EXPECT_EQ(2U, GestureEventQueueSize()); 763 EXPECT_EQ(1U, GetAndResetSentGestureEventCount()); 764 765 SendInputEventACK(WebInputEvent::GesturePinchUpdate, 766 INPUT_EVENT_ACK_STATE_CONSUMED); 767 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, last_acked_event().type); 768 EXPECT_EQ(5.f, last_acked_event().data.pinchUpdate.scale); 769 EXPECT_EQ(1U, GestureEventQueueSize()); 770 EXPECT_EQ(1U, GetAndResetSentGestureEventCount()); 771 772 SendInputEventACK(WebInputEvent::GesturePinchUpdate, 773 INPUT_EVENT_ACK_STATE_CONSUMED); 774 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, last_acked_event().type); 775 EXPECT_EQ(6.f, last_acked_event().data.pinchUpdate.scale); 776 EXPECT_EQ(0U, GestureEventQueueSize()); 777 } 778 779 TEST_F(GestureEventQueueTest, CoalescesScrollAndPinchEventsIdentity) { 780 // Insert an event to force queueing of gestures. 781 SimulateGestureEvent(WebInputEvent::GestureTapCancel, 782 blink::WebGestureDeviceTouchscreen); 783 EXPECT_EQ(1U, GetAndResetSentGestureEventCount()); 784 EXPECT_EQ(1U, GestureEventQueueSize()); 785 786 // Ensure that coalescing yields an identity transform for any pinch/scroll 787 // pair combined with its inverse. 788 SimulateGestureScrollUpdateEvent(5, 5, 1); 789 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 790 EXPECT_EQ(2U, GestureEventQueueSize()); 791 792 SimulateGesturePinchUpdateEvent(5, 10, 10, 1); 793 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 794 EXPECT_EQ(3U, GestureEventQueueSize()); 795 796 SimulateGesturePinchUpdateEvent(.2f, 10, 10, 1); 797 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 798 EXPECT_EQ(3U, GestureEventQueueSize()); 799 800 SimulateGestureScrollUpdateEvent(-5, -5, 1); 801 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 802 EXPECT_EQ(3U, GestureEventQueueSize()); 803 804 SendInputEventACK(WebInputEvent::GestureTapCancel, 805 INPUT_EVENT_ACK_STATE_CONSUMED); 806 EXPECT_EQ(2U, GetAndResetSentGestureEventCount()); 807 EXPECT_EQ(2U, GestureEventQueueSize()); 808 809 SendInputEventACK(WebInputEvent::GestureScrollUpdate, 810 INPUT_EVENT_ACK_STATE_CONSUMED); 811 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, last_acked_event().type); 812 EXPECT_EQ(0.f, last_acked_event().data.scrollUpdate.deltaX); 813 EXPECT_EQ(0.f, last_acked_event().data.scrollUpdate.deltaY); 814 815 SendInputEventACK(WebInputEvent::GesturePinchUpdate, 816 INPUT_EVENT_ACK_STATE_CONSUMED); 817 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, last_acked_event().type); 818 EXPECT_EQ(1.f, last_acked_event().data.pinchUpdate.scale); 819 EXPECT_EQ(0U, GestureEventQueueSize()); 820 821 // Insert an event to force queueing of gestures. 822 SimulateGestureEvent(WebInputEvent::GestureTapCancel, 823 blink::WebGestureDeviceTouchscreen); 824 EXPECT_EQ(1U, GetAndResetSentGestureEventCount()); 825 EXPECT_EQ(1U, GestureEventQueueSize()); 826 827 // Ensure that coalescing yields an identity transform for any pinch/scroll 828 // pair combined with its inverse. 829 SimulateGesturePinchUpdateEvent(2, 10, 10, 1); 830 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 831 EXPECT_EQ(2U, GestureEventQueueSize()); 832 833 SimulateGestureScrollUpdateEvent(20, 20, 1); 834 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 835 EXPECT_EQ(3U, GestureEventQueueSize()); 836 837 SimulateGesturePinchUpdateEvent(0.5f, 20, 20, 1); 838 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 839 EXPECT_EQ(3U, GestureEventQueueSize()); 840 841 SimulateGestureScrollUpdateEvent(-5, -5, 1); 842 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 843 EXPECT_EQ(3U, GestureEventQueueSize()); 844 845 SendInputEventACK(WebInputEvent::GestureTapCancel, 846 INPUT_EVENT_ACK_STATE_CONSUMED); 847 EXPECT_EQ(2U, GetAndResetSentGestureEventCount()); 848 EXPECT_EQ(2U, GestureEventQueueSize()); 849 850 SendInputEventACK(WebInputEvent::GestureScrollUpdate, 851 INPUT_EVENT_ACK_STATE_CONSUMED); 852 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, last_acked_event().type); 853 EXPECT_EQ(0.f, last_acked_event().data.scrollUpdate.deltaX); 854 EXPECT_EQ(0.f, last_acked_event().data.scrollUpdate.deltaY); 855 856 SendInputEventACK(WebInputEvent::GesturePinchUpdate, 857 INPUT_EVENT_ACK_STATE_CONSUMED); 858 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, last_acked_event().type); 859 EXPECT_EQ(1.f, last_acked_event().data.pinchUpdate.scale); 860 } 861 862 // Tests a single event with an synchronous ack. 863 TEST_F(GestureEventQueueTest, SimpleSyncAck) { 864 set_synchronous_ack(INPUT_EVENT_ACK_STATE_CONSUMED); 865 SimulateGestureEvent(WebInputEvent::GestureTapDown, 866 blink::WebGestureDeviceTouchscreen); 867 EXPECT_EQ(1U, GetAndResetSentGestureEventCount()); 868 EXPECT_EQ(0U, GestureEventQueueSize()); 869 EXPECT_EQ(1U, GetAndResetAckedGestureEventCount()); 870 } 871 872 // Tests an event with an synchronous ack which enqueues an additional event. 873 TEST_F(GestureEventQueueTest, SyncAckQueuesEvent) { 874 scoped_ptr<WebGestureEvent> queued_event; 875 set_synchronous_ack(INPUT_EVENT_ACK_STATE_CONSUMED); 876 set_sync_followup_event(WebInputEvent::GestureShowPress, 877 blink::WebGestureDeviceTouchscreen); 878 // This event enqueues the show press event. 879 SimulateGestureEvent(WebInputEvent::GestureTapDown, 880 blink::WebGestureDeviceTouchscreen); 881 EXPECT_EQ(2U, GetAndResetSentGestureEventCount()); 882 EXPECT_EQ(1U, GestureEventQueueSize()); 883 EXPECT_EQ(1U, GetAndResetAckedGestureEventCount()); 884 885 SendInputEventACK(WebInputEvent::GestureShowPress, 886 INPUT_EVENT_ACK_STATE_CONSUMED); 887 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 888 EXPECT_EQ(0U, GestureEventQueueSize()); 889 EXPECT_EQ(1U, GetAndResetAckedGestureEventCount()); 890 } 891 892 // Tests an event with an async ack followed by an event with a sync ack. 893 TEST_F(GestureEventQueueTest, AsyncThenSyncAck) { 894 SimulateGestureEvent(WebInputEvent::GestureTapDown, 895 blink::WebGestureDeviceTouchscreen); 896 897 EXPECT_EQ(1U, GetAndResetSentGestureEventCount()); 898 EXPECT_EQ(1U, GestureEventQueueSize()); 899 EXPECT_EQ(0U, GetAndResetAckedGestureEventCount()); 900 901 SimulateGestureEvent(WebInputEvent::GestureScrollBegin, 902 blink::WebGestureDeviceTouchscreen); 903 set_synchronous_ack(INPUT_EVENT_ACK_STATE_CONSUMED); 904 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 905 EXPECT_EQ(2U, GestureEventQueueSize()); 906 EXPECT_EQ(0U, GetAndResetAckedGestureEventCount()); 907 908 SendInputEventACK(WebInputEvent::GestureTapDown, 909 INPUT_EVENT_ACK_STATE_CONSUMED); 910 EXPECT_EQ(1U, GetAndResetSentGestureEventCount()); 911 EXPECT_EQ(0U, GestureEventQueueSize()); 912 EXPECT_EQ(2U, GetAndResetAckedGestureEventCount()); 913 } 914 915 TEST_F(GestureEventQueueTest, CoalescesScrollAndPinchEventWithSyncAck) { 916 // Simulate a pinch sequence. 917 SimulateGestureEvent(WebInputEvent::GestureScrollBegin, 918 blink::WebGestureDeviceTouchscreen); 919 EXPECT_EQ(1U, GetAndResetSentGestureEventCount()); 920 SimulateGestureEvent(WebInputEvent::GesturePinchBegin, 921 blink::WebGestureDeviceTouchscreen); 922 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 923 924 SimulateGestureScrollUpdateEvent(8, -4, 1); 925 // Make sure that the queue contains what we think it should. 926 WebGestureEvent merged_event = GestureEventLastQueueEvent(); 927 EXPECT_EQ(3U, GestureEventQueueSize()); 928 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type); 929 930 // Coalesced without changing event order. Note anchor at (60, 60). Anchoring 931 // from a point that is not the origin should still give us the right scroll. 932 SimulateGesturePinchUpdateEvent(1.5, 60, 60, 1); 933 EXPECT_EQ(4U, GestureEventQueueSize()); 934 935 SendInputEventACK(WebInputEvent::GestureScrollBegin, 936 INPUT_EVENT_ACK_STATE_CONSUMED); 937 EXPECT_EQ(1U, GetAndResetSentGestureEventCount()); 938 EXPECT_EQ(3U, GestureEventQueueSize()); 939 940 // Ack the PinchBegin, and schedule a synchronous ack for GestureScrollUpdate. 941 set_synchronous_ack(INPUT_EVENT_ACK_STATE_CONSUMED); 942 SendInputEventACK(WebInputEvent::GesturePinchBegin, 943 INPUT_EVENT_ACK_STATE_CONSUMED); 944 945 // Both GestureScrollUpdate and GesturePinchUpdate should have been sent. 946 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, last_acked_event().type); 947 EXPECT_EQ(1U, GestureEventQueueSize()); 948 EXPECT_EQ(2U, GetAndResetSentGestureEventCount()); 949 950 // Ack the final GesturePinchUpdate. 951 SendInputEventACK(WebInputEvent::GesturePinchUpdate, 952 INPUT_EVENT_ACK_STATE_CONSUMED); 953 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, last_acked_event().type); 954 EXPECT_EQ(0U, GestureEventQueueSize()); 955 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 956 } 957 958 #if GTEST_HAS_PARAM_TEST 959 TEST_P(GestureEventQueueWithSourceTest, GestureFlingCancelsFiltered) { 960 WebGestureDevice source_device = GetParam(); 961 962 // GFC without previous GFS is dropped. 963 SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device); 964 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 965 EXPECT_EQ(0U, GestureEventQueueSize()); 966 967 // GFC after previous GFS is dispatched and acked. 968 SimulateGestureFlingStartEvent(0, -10, source_device); 969 EXPECT_TRUE(FlingInProgress()); 970 SendInputEventACK(WebInputEvent::GestureFlingStart, 971 INPUT_EVENT_ACK_STATE_CONSUMED); 972 RunUntilIdle(); 973 EXPECT_EQ(1U, GetAndResetAckedGestureEventCount()); 974 SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device); 975 EXPECT_FALSE(FlingInProgress()); 976 EXPECT_EQ(2U, GetAndResetSentGestureEventCount()); 977 SendInputEventACK(WebInputEvent::GestureFlingCancel, 978 INPUT_EVENT_ACK_STATE_CONSUMED); 979 RunUntilIdle(); 980 EXPECT_EQ(1U, GetAndResetAckedGestureEventCount()); 981 EXPECT_EQ(0U, GestureEventQueueSize()); 982 983 // GFC before previous GFS is acked. 984 SimulateGestureFlingStartEvent(0, -10, source_device); 985 EXPECT_TRUE(FlingInProgress()); 986 SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device); 987 EXPECT_FALSE(FlingInProgress()); 988 EXPECT_EQ(1U, GetAndResetSentGestureEventCount()); 989 EXPECT_EQ(2U, GestureEventQueueSize()); 990 991 // Advance state realistically. 992 SendInputEventACK(WebInputEvent::GestureFlingStart, 993 INPUT_EVENT_ACK_STATE_CONSUMED); 994 RunUntilIdle(); 995 EXPECT_EQ(1U, GetAndResetSentGestureEventCount()); 996 SendInputEventACK(WebInputEvent::GestureFlingCancel, 997 INPUT_EVENT_ACK_STATE_CONSUMED); 998 RunUntilIdle(); 999 EXPECT_EQ(2U, GetAndResetAckedGestureEventCount()); 1000 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 1001 EXPECT_EQ(0U, GestureEventQueueSize()); 1002 1003 // GFS is added to the queue if another event is pending 1004 SimulateGestureScrollUpdateEvent(8, -7, 0); 1005 SimulateGestureFlingStartEvent(0, -10, source_device); 1006 EXPECT_EQ(2U, GestureEventQueueSize()); 1007 EXPECT_EQ(1U, GetAndResetSentGestureEventCount()); 1008 WebGestureEvent merged_event = GestureEventLastQueueEvent(); 1009 EXPECT_EQ(WebInputEvent::GestureFlingStart, merged_event.type); 1010 EXPECT_TRUE(FlingInProgress()); 1011 EXPECT_EQ(2U, GestureEventQueueSize()); 1012 1013 // GFS in queue means that a GFC is added to the queue 1014 SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device); 1015 merged_event =GestureEventLastQueueEvent(); 1016 EXPECT_EQ(WebInputEvent::GestureFlingCancel, merged_event.type); 1017 EXPECT_FALSE(FlingInProgress()); 1018 EXPECT_EQ(3U, GestureEventQueueSize()); 1019 1020 // Adding a second GFC is dropped. 1021 SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device); 1022 EXPECT_FALSE(FlingInProgress()); 1023 EXPECT_EQ(3U, GestureEventQueueSize()); 1024 1025 // Adding another GFS will add it to the queue. 1026 SimulateGestureFlingStartEvent(0, -10, source_device); 1027 merged_event = GestureEventLastQueueEvent(); 1028 EXPECT_EQ(WebInputEvent::GestureFlingStart, merged_event.type); 1029 EXPECT_TRUE(FlingInProgress()); 1030 EXPECT_EQ(4U, GestureEventQueueSize()); 1031 1032 // GFS in queue means that a GFC is added to the queue 1033 SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device); 1034 merged_event = GestureEventLastQueueEvent(); 1035 EXPECT_EQ(WebInputEvent::GestureFlingCancel, merged_event.type); 1036 EXPECT_FALSE(FlingInProgress()); 1037 EXPECT_EQ(5U, GestureEventQueueSize()); 1038 1039 // Adding another GFC with a GFC already there is dropped. 1040 SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device); 1041 merged_event = GestureEventLastQueueEvent(); 1042 EXPECT_EQ(WebInputEvent::GestureFlingCancel, merged_event.type); 1043 EXPECT_FALSE(FlingInProgress()); 1044 EXPECT_EQ(5U, GestureEventQueueSize()); 1045 } 1046 1047 INSTANTIATE_TEST_CASE_P(AllSources, 1048 GestureEventQueueWithSourceTest, 1049 testing::Values(blink::WebGestureDeviceTouchscreen, 1050 blink::WebGestureDeviceTouchpad)); 1051 #endif // GTEST_HAS_PARAM_TEST 1052 1053 // Test that a GestureScrollEnd | GestureFlingStart are deferred during the 1054 // debounce interval, that Scrolls are not and that the deferred events are 1055 // sent after that timer fires. 1056 TEST_F(GestureEventQueueTest, DebounceDefersFollowingGestureEvents) { 1057 SetUpForDebounce(3); 1058 1059 SimulateGestureEvent(WebInputEvent::GestureScrollUpdate, 1060 blink::WebGestureDeviceTouchscreen); 1061 EXPECT_EQ(1U, GetAndResetSentGestureEventCount()); 1062 EXPECT_EQ(1U, GestureEventQueueSize()); 1063 EXPECT_EQ(0U, GestureEventDebouncingQueueSize()); 1064 EXPECT_TRUE(ScrollingInProgress()); 1065 1066 SimulateGestureEvent(WebInputEvent::GestureScrollUpdate, 1067 blink::WebGestureDeviceTouchscreen); 1068 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 1069 EXPECT_EQ(2U, GestureEventQueueSize()); 1070 EXPECT_EQ(0U, GestureEventDebouncingQueueSize()); 1071 EXPECT_TRUE(ScrollingInProgress()); 1072 1073 SimulateGestureEvent(WebInputEvent::GestureScrollEnd, 1074 blink::WebGestureDeviceTouchscreen); 1075 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 1076 EXPECT_EQ(2U, GestureEventQueueSize()); 1077 EXPECT_EQ(1U, GestureEventDebouncingQueueSize()); 1078 1079 SimulateGestureFlingStartEvent(0, 10, blink::WebGestureDeviceTouchscreen); 1080 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 1081 EXPECT_EQ(2U, GestureEventQueueSize()); 1082 EXPECT_EQ(2U, GestureEventDebouncingQueueSize()); 1083 1084 SimulateGestureEvent(WebInputEvent::GestureTapDown, 1085 blink::WebGestureDeviceTouchscreen); 1086 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 1087 EXPECT_EQ(2U, GestureEventQueueSize()); 1088 EXPECT_EQ(3U, GestureEventDebouncingQueueSize()); 1089 1090 base::MessageLoop::current()->PostDelayedTask( 1091 FROM_HERE, 1092 base::MessageLoop::QuitClosure(), 1093 TimeDelta::FromMilliseconds(5)); 1094 base::MessageLoop::current()->Run(); 1095 1096 // The deferred events are correctly queued in coalescing queue. 1097 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 1098 EXPECT_EQ(5U, GestureEventQueueSize()); 1099 EXPECT_EQ(0U, GestureEventDebouncingQueueSize()); 1100 EXPECT_FALSE(ScrollingInProgress()); 1101 1102 // Verify that the coalescing queue contains the correct events. 1103 WebInputEvent::Type expected[] = { 1104 WebInputEvent::GestureScrollUpdate, 1105 WebInputEvent::GestureScrollUpdate, 1106 WebInputEvent::GestureScrollEnd, 1107 WebInputEvent::GestureFlingStart}; 1108 1109 for (unsigned i = 0; i < sizeof(expected) / sizeof(WebInputEvent::Type); 1110 i++) { 1111 WebGestureEvent merged_event = GestureEventQueueEventAt(i); 1112 EXPECT_EQ(expected[i], merged_event.type); 1113 } 1114 } 1115 1116 // Test that non-scroll events are deferred while scrolling during the debounce 1117 // interval and are discarded if a GestureScrollUpdate event arrives before the 1118 // interval end. 1119 TEST_F(GestureEventQueueTest, DebounceDropsDeferredEvents) { 1120 SetUpForDebounce(3); 1121 1122 EXPECT_FALSE(ScrollingInProgress()); 1123 1124 SimulateGestureEvent(WebInputEvent::GestureScrollUpdate, 1125 blink::WebGestureDeviceTouchscreen); 1126 EXPECT_EQ(1U, GetAndResetSentGestureEventCount()); 1127 EXPECT_EQ(1U, GestureEventQueueSize()); 1128 EXPECT_EQ(0U, GestureEventDebouncingQueueSize()); 1129 EXPECT_TRUE(ScrollingInProgress()); 1130 1131 // This event should get discarded. 1132 SimulateGestureEvent(WebInputEvent::GestureScrollEnd, 1133 blink::WebGestureDeviceTouchscreen); 1134 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 1135 EXPECT_EQ(1U, GestureEventQueueSize()); 1136 EXPECT_EQ(1U, GestureEventDebouncingQueueSize()); 1137 1138 SimulateGestureEvent(WebInputEvent::GestureScrollUpdate, 1139 blink::WebGestureDeviceTouchscreen); 1140 EXPECT_EQ(0U, GetAndResetSentGestureEventCount()); 1141 EXPECT_EQ(2U, GestureEventQueueSize()); 1142 EXPECT_EQ(0U, GestureEventDebouncingQueueSize()); 1143 EXPECT_TRUE(ScrollingInProgress()); 1144 1145 // Verify that the coalescing queue contains the correct events. 1146 WebInputEvent::Type expected[] = { 1147 WebInputEvent::GestureScrollUpdate, 1148 WebInputEvent::GestureScrollUpdate}; 1149 1150 for (unsigned i = 0; i < sizeof(expected) / sizeof(WebInputEvent::Type); 1151 i++) { 1152 WebGestureEvent merged_event = GestureEventQueueEventAt(i); 1153 EXPECT_EQ(expected[i], merged_event.type); 1154 } 1155 } 1156 1157 } // namespace content 1158