OLD | NEW |
---|---|
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "content/browser/renderer_host/input/mouse_wheel_event_queue.h" | 5 #include "content/browser/renderer_host/input/mouse_wheel_event_queue.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
9 #include <memory> | 9 #include <memory> |
10 #include <utility> | 10 #include <utility> |
(...skipping 225 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
236 float y, | 236 float y, |
237 float global_x, | 237 float global_x, |
238 float global_y, | 238 float global_y, |
239 float dX, | 239 float dX, |
240 float dY, | 240 float dY, |
241 int modifiers, | 241 int modifiers, |
242 bool high_precision) { | 242 bool high_precision) { |
243 SendMouseWheel(x, y, global_x, global_y, dX, dY, modifiers, high_precision, | 243 SendMouseWheel(x, y, global_x, global_y, dX, dY, modifiers, high_precision, |
244 WebInputEvent::kRailsModeFree); | 244 WebInputEvent::kRailsModeFree); |
245 } | 245 } |
246 void SendMouseWheelWithPhase(float x, | |
247 float y, | |
248 float global_x, | |
249 float global_y, | |
250 float dX, | |
251 float dY, | |
252 int modifiers, | |
253 bool high_precision, | |
254 blink::WebMouseWheelEvent::Phase phase, | |
255 blink::WebMouseWheelEvent::Phase momentum_phase, | |
256 WebInputEvent::RailsMode rails_mode) { | |
257 WebMouseWheelEvent event = SyntheticWebMouseWheelEventBuilder::Build( | |
258 x, y, global_x, global_y, dX, dY, modifiers, high_precision); | |
259 event.phase = phase; | |
260 event.momentum_phase = momentum_phase; | |
261 event.rails_mode = rails_mode; | |
262 queue_->QueueEvent(MouseWheelEventWithLatencyInfo(event)); | |
263 } | |
246 void SendMouseWheelWithPhase( | 264 void SendMouseWheelWithPhase( |
247 float x, | 265 float x, |
248 float y, | 266 float y, |
249 float global_x, | 267 float global_x, |
250 float global_y, | 268 float global_y, |
251 float dX, | 269 float dX, |
252 float dY, | 270 float dY, |
253 int modifiers, | 271 int modifiers, |
254 bool high_precision, | 272 bool high_precision, |
255 blink::WebMouseWheelEvent::Phase phase, | 273 blink::WebMouseWheelEvent::Phase phase, |
256 blink::WebMouseWheelEvent::Phase momentum_phase) { | 274 blink::WebMouseWheelEvent::Phase momentum_phase) { |
257 WebMouseWheelEvent event = SyntheticWebMouseWheelEventBuilder::Build( | 275 SendMouseWheelWithPhase(x, y, global_x, global_y, dX, dY, modifiers, |
258 x, y, global_x, global_y, dX, dY, modifiers, high_precision); | 276 high_precision, phase, momentum_phase, |
259 event.phase = phase; | 277 WebInputEvent::kRailsModeFree); |
260 event.momentum_phase = momentum_phase; | |
261 queue_->QueueEvent(MouseWheelEventWithLatencyInfo(event)); | |
262 } | 278 } |
263 | 279 |
264 void SendGestureEvent(WebInputEvent::Type type) { | 280 void SendGestureEvent(WebInputEvent::Type type) { |
265 WebGestureEvent event(type, WebInputEvent::kNoModifiers, | 281 WebGestureEvent event(type, WebInputEvent::kNoModifiers, |
266 ui::EventTimeStampToSeconds(ui::EventTimeForNow())); | 282 ui::EventTimeStampToSeconds(ui::EventTimeForNow())); |
267 event.source_device = blink::kWebGestureDeviceTouchscreen; | 283 event.source_device = blink::kWebGestureDeviceTouchscreen; |
268 queue_->OnGestureScrollEvent( | 284 queue_->OnGestureScrollEvent( |
269 GestureEventWithLatencyInfo(event, ui::LatencyInfo())); | 285 GestureEventWithLatencyInfo(event, ui::LatencyInfo())); |
270 } | 286 } |
271 | 287 |
272 static void RunTasksAndWait(base::TimeDelta delay) { | 288 static void RunTasksAndWait(base::TimeDelta delay) { |
273 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | 289 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( |
274 FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(), delay); | 290 FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(), delay); |
275 base::RunLoop().Run(); | 291 base::RunLoop().Run(); |
276 } | 292 } |
277 | 293 |
278 void GestureSendingTest(bool high_precision) { | 294 void GestureSendingTest(bool high_precision) { |
279 const WebGestureEvent::ScrollUnits scroll_units = | 295 const WebGestureEvent::ScrollUnits scroll_units = |
280 high_precision ? WebGestureEvent::kPrecisePixels | 296 high_precision ? WebGestureEvent::kPrecisePixels |
281 : WebGestureEvent::kPixels; | 297 : WebGestureEvent::kPixels; |
282 SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, | 298 if (scroll_latching_enabled_) { |
283 kWheelScrollGlobalY, 1, 1, 0, high_precision); | 299 SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, |
300 kWheelScrollGlobalY, 1, 1, 0, high_precision, | |
301 WebMouseWheelEvent::kPhaseBegan, | |
302 WebMouseWheelEvent::kPhaseNone); | |
303 } else { | |
304 SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, | |
305 kWheelScrollGlobalY, 1, 1, 0, high_precision); | |
306 } | |
284 EXPECT_EQ(0U, queued_event_count()); | 307 EXPECT_EQ(0U, queued_event_count()); |
285 EXPECT_TRUE(event_in_flight()); | 308 EXPECT_TRUE(event_in_flight()); |
286 EXPECT_EQ(1U, GetAndResetSentEventCount()); | 309 EXPECT_EQ(1U, GetAndResetSentEventCount()); |
287 | 310 |
288 // The second mouse wheel should not be sent since one is already in | 311 // The second mouse wheel should not be sent since one is already in |
289 // queue. | 312 // queue. |
290 SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, | 313 if (scroll_latching_enabled_) { |
291 kWheelScrollGlobalY, 5, 5, 0, high_precision); | 314 SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, |
315 kWheelScrollGlobalY, 5, 5, 0, high_precision, | |
316 WebMouseWheelEvent::kPhaseChanged, | |
317 WebMouseWheelEvent::kPhaseNone); | |
318 } else { | |
319 SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, | |
320 kWheelScrollGlobalY, 5, 5, 0, high_precision); | |
tdresser
2017/05/18 13:49:05
Would it make sense to have a method along the lin
sahel
2017/05/18 18:15:14
Done.
| |
321 } | |
292 EXPECT_EQ(1U, queued_event_count()); | 322 EXPECT_EQ(1U, queued_event_count()); |
293 EXPECT_TRUE(event_in_flight()); | 323 EXPECT_TRUE(event_in_flight()); |
294 EXPECT_EQ(0U, GetAndResetSentEventCount()); | 324 EXPECT_EQ(0U, GetAndResetSentEventCount()); |
295 | 325 |
296 // Receive an ACK for the mouse wheel event and release the next | 326 // Receive an ACK for the mouse wheel event and release the next |
297 // mouse wheel event. | 327 // mouse wheel event. |
298 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 328 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
299 EXPECT_EQ(0U, queued_event_count()); | 329 EXPECT_EQ(0U, queued_event_count()); |
300 EXPECT_TRUE(event_in_flight()); | 330 EXPECT_TRUE(event_in_flight()); |
301 EXPECT_EQ(WebInputEvent::kMouseWheel, acked_event().GetType()); | 331 EXPECT_EQ(WebInputEvent::kMouseWheel, acked_event().GetType()); |
302 EXPECT_EQ(1U, GetAndResetAckedEventCount()); | 332 EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
303 if (scroll_latching_enabled_) { | 333 if (scroll_latching_enabled_) { |
304 EXPECT_EQ(3U, all_sent_events().size()); | 334 EXPECT_EQ(3U, all_sent_events().size()); |
305 EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); | 335 EXPECT_GESTURE_SCROLL_BEGIN_WITH_PHASE(sent_gesture_event(0)); |
306 EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1)); | 336 EXPECT_GESTURE_SCROLL_UPDATE_WITH_PHASE(sent_gesture_event(1)); |
307 EXPECT_MOUSE_WHEEL(sent_input_event(2)); | 337 EXPECT_MOUSE_WHEEL(sent_input_event(2)); |
308 EXPECT_EQ(3U, GetAndResetSentEventCount()); | 338 EXPECT_EQ(3U, GetAndResetSentEventCount()); |
309 | |
310 RunTasksAndWait(DefaultScrollEndTimeoutDelay() * 2); | |
311 EXPECT_EQ(1U, all_sent_events().size()); | |
312 EXPECT_GESTURE_SCROLL_END(sent_gesture_event(0)); | |
313 } else { | 339 } else { |
314 EXPECT_EQ(4U, all_sent_events().size()); | 340 EXPECT_EQ(4U, all_sent_events().size()); |
315 EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); | 341 EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); |
316 EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1)); | 342 EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1)); |
317 EXPECT_GESTURE_SCROLL_END(sent_gesture_event(2)); | 343 EXPECT_GESTURE_SCROLL_END(sent_gesture_event(2)); |
318 EXPECT_MOUSE_WHEEL(sent_input_event(3)); | 344 EXPECT_MOUSE_WHEEL(sent_input_event(3)); |
319 EXPECT_EQ(4U, GetAndResetSentEventCount()); | 345 EXPECT_EQ(4U, GetAndResetSentEventCount()); |
320 } | 346 } |
321 } | 347 } |
322 | 348 |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
355 EXPECT_GESTURE_SCROLL_UPDATE_WITH_PHASE(sent_gesture_event(0)); | 381 EXPECT_GESTURE_SCROLL_UPDATE_WITH_PHASE(sent_gesture_event(0)); |
356 EXPECT_EQ(1U, GetAndResetSentEventCount()); | 382 EXPECT_EQ(1U, GetAndResetSentEventCount()); |
357 } else { | 383 } else { |
358 EXPECT_EQ(3U, all_sent_events().size()); | 384 EXPECT_EQ(3U, all_sent_events().size()); |
359 EXPECT_SYNTHETIC_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); | 385 EXPECT_SYNTHETIC_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); |
360 EXPECT_GESTURE_SCROLL_UPDATE_WITH_PHASE(sent_gesture_event(1)); | 386 EXPECT_GESTURE_SCROLL_UPDATE_WITH_PHASE(sent_gesture_event(1)); |
361 EXPECT_SYNTHETIC_GESTURE_SCROLL_END(sent_gesture_event(2)); | 387 EXPECT_SYNTHETIC_GESTURE_SCROLL_END(sent_gesture_event(2)); |
362 EXPECT_EQ(3U, GetAndResetSentEventCount()); | 388 EXPECT_EQ(3U, GetAndResetSentEventCount()); |
363 } | 389 } |
364 | 390 |
365 SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, | 391 // When wheel scroll latching is enabled no wheel event with phase = |
366 kWheelScrollGlobalY, 0, 0, 0, high_precision, | 392 // |kPhaseEnded| will be sent before a wheel event with momentum_phase = |
367 WebMouseWheelEvent::kPhaseEnded, | 393 // |kPhaseBegan|. |
368 WebMouseWheelEvent::kPhaseNone); | 394 if (!scroll_latching_enabled_) { |
369 EXPECT_EQ(1U, GetAndResetSentEventCount()); | 395 SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, |
370 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 396 kWheelScrollGlobalY, 0, 0, 0, high_precision, |
371 if (scroll_latching_enabled_) { | 397 WebMouseWheelEvent::kPhaseEnded, |
372 // ScrollEnd is not sent right away, a timer starts instead, | 398 WebMouseWheelEvent::kPhaseNone); |
373 // to see if a wheel event with momentumPhase arrives or not. | 399 EXPECT_EQ(1U, GetAndResetSentEventCount()); |
374 EXPECT_EQ(0U, all_sent_events().size()); | 400 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
375 EXPECT_EQ(0U, GetAndResetSentEventCount()); | |
376 } else { | |
377 EXPECT_EQ(2U, all_sent_events().size()); | 401 EXPECT_EQ(2U, all_sent_events().size()); |
378 EXPECT_SYNTHETIC_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); | 402 EXPECT_SYNTHETIC_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); |
379 EXPECT_GESTURE_SCROLL_END_WITH_PHASE(sent_gesture_event(1)); | 403 EXPECT_GESTURE_SCROLL_END_WITH_PHASE(sent_gesture_event(1)); |
380 EXPECT_EQ(2U, GetAndResetSentEventCount()); | 404 EXPECT_EQ(2U, GetAndResetSentEventCount()); |
405 | |
406 // Send a double phase end; OSX does it consistently. | |
407 SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, | |
408 kWheelScrollGlobalY, 0, 0, 0, high_precision, | |
409 WebMouseWheelEvent::kPhaseEnded, | |
410 WebMouseWheelEvent::kPhaseNone); | |
411 EXPECT_EQ(1U, GetAndResetSentEventCount()); | |
412 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
413 EXPECT_EQ(0U, all_sent_events().size()); | |
414 EXPECT_EQ(0U, GetAndResetSentEventCount()); | |
381 } | 415 } |
382 | 416 |
383 // Send a double phase end; OSX does it consistently. | |
384 SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, | |
385 kWheelScrollGlobalY, 0, 0, 0, high_precision, | |
386 WebMouseWheelEvent::kPhaseEnded, | |
387 WebMouseWheelEvent::kPhaseNone); | |
388 EXPECT_EQ(1U, GetAndResetSentEventCount()); | |
389 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
390 EXPECT_EQ(0U, all_sent_events().size()); | |
391 EXPECT_EQ(0U, GetAndResetSentEventCount()); | |
392 | |
393 SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, | 417 SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, |
394 kWheelScrollGlobalY, 5, 5, 0, high_precision, | 418 kWheelScrollGlobalY, 5, 5, 0, high_precision, |
395 WebMouseWheelEvent::kPhaseNone, | 419 WebMouseWheelEvent::kPhaseNone, |
396 WebMouseWheelEvent::kPhaseBegan); | 420 WebMouseWheelEvent::kPhaseBegan); |
397 EXPECT_EQ(1U, GetAndResetSentEventCount()); | 421 EXPECT_EQ(1U, GetAndResetSentEventCount()); |
398 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 422 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
399 if (scroll_latching_enabled_) { | 423 if (scroll_latching_enabled_) { |
400 // A fling has started, no ScrollEnd/ScrollBegin is sent. | 424 // A fling has started, no ScrollEnd/ScrollBegin is sent. |
401 EXPECT_EQ(1U, all_sent_events().size()); | 425 EXPECT_EQ(1U, all_sent_events().size()); |
402 EXPECT_INERTIAL_GESTURE_SCROLL_UPDATE(sent_gesture_event(0)); | 426 EXPECT_INERTIAL_GESTURE_SCROLL_UPDATE(sent_gesture_event(0)); |
(...skipping 98 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
501 PhaseGestureSendingTest(false); | 525 PhaseGestureSendingTest(false); |
502 } | 526 } |
503 | 527 |
504 TEST_P(MouseWheelEventQueueTest, | 528 TEST_P(MouseWheelEventQueueTest, |
505 GestureSendingWithPhaseInformationPrecisePixels) { | 529 GestureSendingWithPhaseInformationPrecisePixels) { |
506 PhaseGestureSendingTest(true); | 530 PhaseGestureSendingTest(true); |
507 } | 531 } |
508 | 532 |
509 TEST_P(MouseWheelEventQueueTest, GestureSendingInterrupted) { | 533 TEST_P(MouseWheelEventQueueTest, GestureSendingInterrupted) { |
510 const WebGestureEvent::ScrollUnits scroll_units = WebGestureEvent::kPixels; | 534 const WebGestureEvent::ScrollUnits scroll_units = WebGestureEvent::kPixels; |
511 | 535 if (scroll_latching_enabled_) { |
512 SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, | 536 SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, |
513 kWheelScrollGlobalY, 1, 1, 0, false); | 537 kWheelScrollGlobalY, 1, 1, 0, false, |
538 WebMouseWheelEvent::kPhaseBegan, | |
539 WebMouseWheelEvent::kPhaseNone); | |
540 } else { | |
541 SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, | |
542 kWheelScrollGlobalY, 1, 1, 0, false); | |
543 } | |
514 EXPECT_EQ(0U, queued_event_count()); | 544 EXPECT_EQ(0U, queued_event_count()); |
515 EXPECT_TRUE(event_in_flight()); | 545 EXPECT_TRUE(event_in_flight()); |
516 EXPECT_EQ(1U, GetAndResetSentEventCount()); | 546 EXPECT_EQ(1U, GetAndResetSentEventCount()); |
517 | 547 |
518 // Receive an ACK for the mouse wheel event. | 548 // Receive an ACK for the mouse wheel event. |
519 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 549 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
520 EXPECT_EQ(0U, queued_event_count()); | 550 EXPECT_EQ(0U, queued_event_count()); |
521 EXPECT_FALSE(event_in_flight()); | 551 EXPECT_FALSE(event_in_flight()); |
522 EXPECT_EQ(WebInputEvent::kMouseWheel, acked_event().GetType()); | 552 EXPECT_EQ(WebInputEvent::kMouseWheel, acked_event().GetType()); |
523 EXPECT_EQ(1U, GetAndResetAckedEventCount()); | 553 EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
524 if (scroll_latching_enabled_) { | 554 if (scroll_latching_enabled_) { |
525 EXPECT_EQ(2U, all_sent_events().size()); | 555 EXPECT_EQ(2U, all_sent_events().size()); |
526 EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); | 556 EXPECT_GESTURE_SCROLL_BEGIN_WITH_PHASE(sent_gesture_event(0)); |
527 EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1)); | 557 EXPECT_GESTURE_SCROLL_UPDATE_WITH_PHASE(sent_gesture_event(1)); |
528 EXPECT_EQ(2U, GetAndResetSentEventCount()); | 558 EXPECT_EQ(2U, GetAndResetSentEventCount()); |
529 } else { | 559 } else { |
530 EXPECT_EQ(3U, all_sent_events().size()); | 560 EXPECT_EQ(3U, all_sent_events().size()); |
531 EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); | 561 EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); |
532 EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1)); | 562 EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1)); |
533 EXPECT_GESTURE_SCROLL_END(sent_gesture_event(2)); | 563 EXPECT_GESTURE_SCROLL_END(sent_gesture_event(2)); |
534 EXPECT_EQ(3U, GetAndResetSentEventCount()); | 564 EXPECT_EQ(3U, GetAndResetSentEventCount()); |
535 } | 565 } |
536 | 566 |
567 // When wheel scroll latching is enabled and a touch based GSB arrives in the | |
568 // middle of wheel scrolling sequence, a synthetic wheel event with zero | |
569 // deltas and phase = |kPhaseEnded| will be sent. | |
570 if (scroll_latching_enabled_) { | |
571 SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, | |
572 kWheelScrollGlobalY, 0, 0, 0, false, | |
573 WebMouseWheelEvent::kPhaseEnded, | |
574 WebMouseWheelEvent::kPhaseNone); | |
575 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | |
576 EXPECT_EQ(1U, GetAndResetAckedEventCount()); | |
577 } | |
537 // Ensure that a gesture scroll begin terminates the current scroll event. | 578 // Ensure that a gesture scroll begin terminates the current scroll event. |
538 SendGestureEvent(WebInputEvent::kGestureScrollBegin); | 579 SendGestureEvent(WebInputEvent::kGestureScrollBegin); |
580 | |
539 if (scroll_latching_enabled_) { | 581 if (scroll_latching_enabled_) { |
540 EXPECT_EQ(1U, all_sent_events().size()); | 582 EXPECT_EQ(2U, all_sent_events().size()); |
541 EXPECT_GESTURE_SCROLL_END(sent_gesture_event(0)); | 583 EXPECT_GESTURE_SCROLL_END_WITH_PHASE(sent_gesture_event(1)); |
542 EXPECT_EQ(1U, GetAndResetSentEventCount()); | 584 EXPECT_EQ(2U, GetAndResetSentEventCount()); |
543 } else { | 585 } else { |
544 // ScrollEnd has already been sent. | 586 // ScrollEnd has already been sent. |
545 EXPECT_EQ(0U, all_sent_events().size()); | 587 EXPECT_EQ(0U, all_sent_events().size()); |
546 } | 588 } |
547 | 589 |
548 SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, | 590 if (scroll_latching_enabled_) { |
549 kWheelScrollGlobalY, 1, 1, 0, false); | 591 SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, |
592 kWheelScrollGlobalY, 1, 1, 0, false, | |
593 WebMouseWheelEvent::kPhaseBegan, | |
594 WebMouseWheelEvent::kPhaseNone); | |
595 } else { | |
596 SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, | |
597 kWheelScrollGlobalY, 1, 1, 0, false); | |
598 } | |
550 EXPECT_EQ(0U, queued_event_count()); | 599 EXPECT_EQ(0U, queued_event_count()); |
551 EXPECT_TRUE(event_in_flight()); | 600 EXPECT_TRUE(event_in_flight()); |
552 EXPECT_EQ(1U, GetAndResetSentEventCount()); | 601 EXPECT_EQ(1U, GetAndResetSentEventCount()); |
553 | 602 |
554 // New mouse wheel events won't cause gestures because a scroll | 603 // New mouse wheel events won't cause gestures because a scroll |
555 // is already in progress by another device. | 604 // is already in progress by another device. |
556 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 605 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
557 EXPECT_EQ(0U, queued_event_count()); | 606 EXPECT_EQ(0U, queued_event_count()); |
558 EXPECT_FALSE(event_in_flight()); | 607 EXPECT_FALSE(event_in_flight()); |
559 EXPECT_EQ(WebInputEvent::kMouseWheel, acked_event().GetType()); | 608 EXPECT_EQ(WebInputEvent::kMouseWheel, acked_event().GetType()); |
560 EXPECT_EQ(1U, GetAndResetAckedEventCount()); | 609 EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
561 EXPECT_EQ(0U, all_sent_events().size()); | 610 EXPECT_EQ(0U, all_sent_events().size()); |
562 | 611 |
563 SendGestureEvent(WebInputEvent::kGestureScrollEnd); | 612 SendGestureEvent(WebInputEvent::kGestureScrollEnd); |
564 EXPECT_EQ(0U, all_sent_events().size()); | 613 EXPECT_EQ(0U, all_sent_events().size()); |
565 | 614 |
566 SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, | 615 if (scroll_latching_enabled_) { |
567 kWheelScrollGlobalY, 1, 1, 0, false); | 616 SendMouseWheelWithPhase(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, |
617 kWheelScrollGlobalY, 1, 1, 0, false, | |
618 WebMouseWheelEvent::kPhaseBegan, | |
619 WebMouseWheelEvent::kPhaseNone); | |
620 } else { | |
621 SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, | |
622 kWheelScrollGlobalY, 1, 1, 0, false); | |
623 } | |
568 EXPECT_EQ(0U, queued_event_count()); | 624 EXPECT_EQ(0U, queued_event_count()); |
569 EXPECT_TRUE(event_in_flight()); | 625 EXPECT_TRUE(event_in_flight()); |
570 EXPECT_EQ(1U, GetAndResetSentEventCount()); | 626 EXPECT_EQ(1U, GetAndResetSentEventCount()); |
571 | 627 |
572 // Receive an ACK for the mouse wheel event. | 628 // Receive an ACK for the mouse wheel event. |
573 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 629 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
574 EXPECT_EQ(0U, queued_event_count()); | 630 EXPECT_EQ(0U, queued_event_count()); |
575 EXPECT_FALSE(event_in_flight()); | 631 EXPECT_FALSE(event_in_flight()); |
576 EXPECT_EQ(WebInputEvent::kMouseWheel, acked_event().GetType()); | 632 EXPECT_EQ(WebInputEvent::kMouseWheel, acked_event().GetType()); |
577 EXPECT_EQ(1U, GetAndResetAckedEventCount()); | 633 EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
578 if (scroll_latching_enabled_) { | 634 if (scroll_latching_enabled_) { |
579 EXPECT_EQ(2U, all_sent_events().size()); | 635 EXPECT_EQ(2U, all_sent_events().size()); |
580 EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); | 636 EXPECT_GESTURE_SCROLL_BEGIN_WITH_PHASE(sent_gesture_event(0)); |
581 EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1)); | 637 EXPECT_GESTURE_SCROLL_UPDATE_WITH_PHASE(sent_gesture_event(1)); |
582 EXPECT_EQ(2U, GetAndResetSentEventCount()); | 638 EXPECT_EQ(2U, GetAndResetSentEventCount()); |
583 } else { | 639 } else { |
584 EXPECT_EQ(3U, all_sent_events().size()); | 640 EXPECT_EQ(3U, all_sent_events().size()); |
585 EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); | 641 EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); |
586 EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1)); | 642 EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1)); |
587 EXPECT_GESTURE_SCROLL_END(sent_gesture_event(2)); | 643 EXPECT_GESTURE_SCROLL_END(sent_gesture_event(2)); |
588 EXPECT_EQ(3U, GetAndResetSentEventCount()); | 644 EXPECT_EQ(3U, GetAndResetSentEventCount()); |
589 } | 645 } |
590 } | 646 } |
591 | 647 |
592 TEST_P(MouseWheelEventQueueTest, GestureRailScrolling) { | 648 TEST_P(MouseWheelEventQueueTest, GestureRailScrolling) { |
593 const WebGestureEvent::ScrollUnits scroll_units = WebGestureEvent::kPixels; | 649 const WebGestureEvent::ScrollUnits scroll_units = WebGestureEvent::kPixels; |
594 | 650 |
595 SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, | 651 if (scroll_latching_enabled_) { |
596 kWheelScrollGlobalY, 1, 1, 0, false, | 652 SendMouseWheelWithPhase( |
597 WebInputEvent::kRailsModeHorizontal); | 653 kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, kWheelScrollGlobalY, |
654 1, 1, 0, false, WebMouseWheelEvent::kPhaseBegan, | |
655 WebMouseWheelEvent::kPhaseNone, WebInputEvent::kRailsModeHorizontal); | |
656 } else { | |
657 SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, | |
658 kWheelScrollGlobalY, 1, 1, 0, false, | |
659 WebInputEvent::kRailsModeHorizontal); | |
660 } | |
598 EXPECT_EQ(0U, queued_event_count()); | 661 EXPECT_EQ(0U, queued_event_count()); |
599 EXPECT_TRUE(event_in_flight()); | 662 EXPECT_TRUE(event_in_flight()); |
600 EXPECT_EQ(1U, GetAndResetSentEventCount()); | 663 EXPECT_EQ(1U, GetAndResetSentEventCount()); |
601 | 664 |
602 // Receive an ACK for the mouse wheel event. | 665 // Receive an ACK for the mouse wheel event. |
603 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 666 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
604 EXPECT_EQ(0U, queued_event_count()); | 667 EXPECT_EQ(0U, queued_event_count()); |
605 EXPECT_FALSE(event_in_flight()); | 668 EXPECT_FALSE(event_in_flight()); |
606 EXPECT_EQ(WebInputEvent::kMouseWheel, acked_event().GetType()); | 669 EXPECT_EQ(WebInputEvent::kMouseWheel, acked_event().GetType()); |
607 EXPECT_EQ(1U, GetAndResetAckedEventCount()); | 670 EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
608 if (scroll_latching_enabled_) { | 671 if (scroll_latching_enabled_) { |
609 EXPECT_EQ(2U, all_sent_events().size()); | 672 EXPECT_EQ(2U, all_sent_events().size()); |
610 EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); | 673 EXPECT_GESTURE_SCROLL_BEGIN_WITH_PHASE(sent_gesture_event(0)); |
611 EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1)); | 674 EXPECT_GESTURE_SCROLL_UPDATE_WITH_PHASE(sent_gesture_event(1)); |
612 EXPECT_EQ(1U, sent_gesture_event(1)->data.scroll_update.delta_x); | 675 EXPECT_EQ(1U, sent_gesture_event(1)->data.scroll_update.delta_x); |
613 EXPECT_EQ(0U, sent_gesture_event(1)->data.scroll_update.delta_y); | 676 EXPECT_EQ(0U, sent_gesture_event(1)->data.scroll_update.delta_y); |
614 EXPECT_EQ(2U, GetAndResetSentEventCount()); | 677 EXPECT_EQ(2U, GetAndResetSentEventCount()); |
615 RunTasksAndWait(DefaultScrollEndTimeoutDelay() * 2); | |
616 EXPECT_EQ(1U, all_sent_events().size()); | |
617 EXPECT_GESTURE_SCROLL_END(sent_gesture_event(0)); | |
618 EXPECT_EQ(1U, GetAndResetSentEventCount()); | |
619 } else { | 678 } else { |
620 EXPECT_EQ(3U, all_sent_events().size()); | 679 EXPECT_EQ(3U, all_sent_events().size()); |
621 EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); | 680 EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); |
622 EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1)); | 681 EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1)); |
623 EXPECT_GESTURE_SCROLL_END(sent_gesture_event(2)); | 682 EXPECT_GESTURE_SCROLL_END(sent_gesture_event(2)); |
624 EXPECT_EQ(1U, sent_gesture_event(1)->data.scroll_update.delta_x); | 683 EXPECT_EQ(1U, sent_gesture_event(1)->data.scroll_update.delta_x); |
625 EXPECT_EQ(0U, sent_gesture_event(1)->data.scroll_update.delta_y); | 684 EXPECT_EQ(0U, sent_gesture_event(1)->data.scroll_update.delta_y); |
626 EXPECT_EQ(3U, GetAndResetSentEventCount()); | 685 EXPECT_EQ(3U, GetAndResetSentEventCount()); |
627 } | 686 } |
628 | 687 if (scroll_latching_enabled_) { |
629 SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, | 688 SendMouseWheelWithPhase( |
630 kWheelScrollGlobalY, 1, 1, 0, false, | 689 kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, kWheelScrollGlobalY, |
631 WebInputEvent::kRailsModeVertical); | 690 1, 1, 0, false, WebMouseWheelEvent::kPhaseChanged, |
691 WebMouseWheelEvent::kPhaseNone, WebInputEvent::kRailsModeVertical); | |
692 } else { | |
693 SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, | |
694 kWheelScrollGlobalY, 1, 1, 0, false, | |
695 WebInputEvent::kRailsModeVertical); | |
696 } | |
632 EXPECT_EQ(0U, queued_event_count()); | 697 EXPECT_EQ(0U, queued_event_count()); |
633 EXPECT_TRUE(event_in_flight()); | 698 EXPECT_TRUE(event_in_flight()); |
634 EXPECT_EQ(1U, GetAndResetSentEventCount()); | 699 EXPECT_EQ(1U, GetAndResetSentEventCount()); |
635 | 700 |
636 // Receive an ACK for the mouse wheel event. | 701 // Receive an ACK for the mouse wheel event. |
637 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 702 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
638 EXPECT_EQ(0U, queued_event_count()); | 703 EXPECT_EQ(0U, queued_event_count()); |
639 EXPECT_FALSE(event_in_flight()); | 704 EXPECT_FALSE(event_in_flight()); |
640 EXPECT_EQ(WebInputEvent::kMouseWheel, acked_event().GetType()); | 705 EXPECT_EQ(WebInputEvent::kMouseWheel, acked_event().GetType()); |
641 EXPECT_EQ(1U, GetAndResetAckedEventCount()); | 706 EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
707 size_t scroll_update_index = 0; | |
642 if (scroll_latching_enabled_) { | 708 if (scroll_latching_enabled_) { |
643 EXPECT_EQ(2U, all_sent_events().size()); | 709 EXPECT_EQ(1U, all_sent_events().size()); |
644 EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); | 710 EXPECT_GESTURE_SCROLL_UPDATE_WITH_PHASE(sent_gesture_event(0)); |
645 EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1)); | |
646 } else { | 711 } else { |
647 EXPECT_EQ(3U, all_sent_events().size()); | 712 EXPECT_EQ(3U, all_sent_events().size()); |
648 EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); | 713 EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); |
649 EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1)); | 714 EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1)); |
650 EXPECT_GESTURE_SCROLL_END(sent_gesture_event(2)); | 715 EXPECT_GESTURE_SCROLL_END(sent_gesture_event(2)); |
716 scroll_update_index = 1; | |
651 } | 717 } |
652 EXPECT_EQ(0U, sent_gesture_event(1)->data.scroll_update.delta_x); | 718 EXPECT_EQ( |
653 EXPECT_EQ(1U, sent_gesture_event(1)->data.scroll_update.delta_y); | 719 0U, sent_gesture_event(scroll_update_index)->data.scroll_update.delta_x); |
720 EXPECT_EQ( | |
721 1U, sent_gesture_event(scroll_update_index)->data.scroll_update.delta_y); | |
654 if (scroll_latching_enabled_) | 722 if (scroll_latching_enabled_) |
655 EXPECT_EQ(2U, GetAndResetSentEventCount()); | 723 EXPECT_EQ(1U, GetAndResetSentEventCount()); |
656 else | 724 else |
657 EXPECT_EQ(3U, GetAndResetSentEventCount()); | 725 EXPECT_EQ(3U, GetAndResetSentEventCount()); |
658 } | 726 } |
659 | 727 |
660 TEST_P(MouseWheelEventQueueTest, WheelScrollLatching) { | 728 TEST_P(MouseWheelEventQueueTest, WheelScrollLatching) { |
661 if (!scroll_latching_enabled_) | 729 if (!scroll_latching_enabled_) |
662 return; | 730 return; |
663 | 731 |
664 const WebGestureEvent::ScrollUnits scroll_units = WebGestureEvent::kPixels; | 732 const WebGestureEvent::ScrollUnits scroll_units = WebGestureEvent::kPixels; |
665 SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, | 733 SendMouseWheelWithPhase( |
666 kWheelScrollGlobalY, 1, 1, 0, false, | 734 kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, kWheelScrollGlobalY, 1, |
667 WebInputEvent::kRailsModeVertical); | 735 1, 0, false, WebMouseWheelEvent::kPhaseBegan, |
736 WebMouseWheelEvent::kPhaseNone, WebInputEvent::kRailsModeVertical); | |
668 EXPECT_EQ(0U, queued_event_count()); | 737 EXPECT_EQ(0U, queued_event_count()); |
669 EXPECT_TRUE(event_in_flight()); | 738 EXPECT_TRUE(event_in_flight()); |
670 EXPECT_EQ(1U, GetAndResetSentEventCount()); | 739 EXPECT_EQ(1U, GetAndResetSentEventCount()); |
671 | 740 |
672 // Receive an ACK for the mouse wheel event. | 741 // Receive an ACK for the mouse wheel event. |
673 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 742 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
674 EXPECT_EQ(0U, queued_event_count()); | 743 EXPECT_EQ(0U, queued_event_count()); |
675 EXPECT_FALSE(event_in_flight()); | 744 EXPECT_FALSE(event_in_flight()); |
676 EXPECT_EQ(WebInputEvent::kMouseWheel, acked_event().GetType()); | 745 EXPECT_EQ(WebInputEvent::kMouseWheel, acked_event().GetType()); |
677 EXPECT_EQ(1U, GetAndResetAckedEventCount()); | 746 EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
678 EXPECT_EQ(2U, all_sent_events().size()); | 747 EXPECT_EQ(2U, all_sent_events().size()); |
679 EXPECT_GESTURE_SCROLL_BEGIN(sent_gesture_event(0)); | 748 EXPECT_GESTURE_SCROLL_BEGIN_WITH_PHASE(sent_gesture_event(0)); |
680 EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(1)); | 749 EXPECT_GESTURE_SCROLL_UPDATE_WITH_PHASE(sent_gesture_event(1)); |
681 EXPECT_EQ(0U, sent_gesture_event(1)->data.scroll_update.delta_x); | 750 EXPECT_EQ(0U, sent_gesture_event(1)->data.scroll_update.delta_x); |
682 EXPECT_EQ(1U, sent_gesture_event(1)->data.scroll_update.delta_y); | 751 EXPECT_EQ(1U, sent_gesture_event(1)->data.scroll_update.delta_y); |
683 EXPECT_EQ(2U, GetAndResetSentEventCount()); | 752 EXPECT_EQ(2U, GetAndResetSentEventCount()); |
684 | 753 |
685 RunTasksAndWait(DefaultScrollEndTimeoutDelay() / 2); | 754 SendMouseWheelWithPhase( |
686 EXPECT_EQ(0U, GetAndResetSentEventCount()); | 755 kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, kWheelScrollGlobalY, 1, |
687 SendMouseWheel(kWheelScrollX, kWheelScrollY, kWheelScrollGlobalX, | 756 1, 0, false, WebMouseWheelEvent::kPhaseChanged, |
688 kWheelScrollGlobalY, 1, 1, 0, false, | 757 WebMouseWheelEvent::kPhaseNone, WebInputEvent::kRailsModeVertical); |
689 WebInputEvent::kRailsModeVertical); | |
690 EXPECT_EQ(0U, queued_event_count()); | 758 EXPECT_EQ(0U, queued_event_count()); |
691 EXPECT_TRUE(event_in_flight()); | 759 EXPECT_TRUE(event_in_flight()); |
692 EXPECT_EQ(1U, GetAndResetSentEventCount()); | 760 EXPECT_EQ(1U, GetAndResetSentEventCount()); |
693 | 761 |
694 // Receive an ACK for the mouse wheel event. | 762 // Receive an ACK for the mouse wheel event. |
695 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); | 763 SendMouseWheelEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED); |
696 EXPECT_EQ(0U, queued_event_count()); | 764 EXPECT_EQ(0U, queued_event_count()); |
697 EXPECT_FALSE(event_in_flight()); | 765 EXPECT_FALSE(event_in_flight()); |
698 EXPECT_EQ(WebInputEvent::kMouseWheel, acked_event().GetType()); | 766 EXPECT_EQ(WebInputEvent::kMouseWheel, acked_event().GetType()); |
699 EXPECT_EQ(1U, GetAndResetAckedEventCount()); | 767 EXPECT_EQ(1U, GetAndResetAckedEventCount()); |
700 | 768 |
701 // Scroll latching: no new scroll begin expected. | 769 // Scroll latching: no new scroll begin expected. |
702 EXPECT_EQ(1U, all_sent_events().size()); | 770 EXPECT_EQ(1U, all_sent_events().size()); |
703 EXPECT_GESTURE_SCROLL_UPDATE(sent_gesture_event(0)); | 771 EXPECT_GESTURE_SCROLL_UPDATE_WITH_PHASE(sent_gesture_event(0)); |
704 EXPECT_EQ(0U, sent_gesture_event(0)->data.scroll_update.delta_x); | 772 EXPECT_EQ(0U, sent_gesture_event(0)->data.scroll_update.delta_x); |
705 EXPECT_EQ(1U, sent_gesture_event(0)->data.scroll_update.delta_y); | 773 EXPECT_EQ(1U, sent_gesture_event(0)->data.scroll_update.delta_y); |
706 EXPECT_EQ(1U, GetAndResetSentEventCount()); | 774 EXPECT_EQ(1U, GetAndResetSentEventCount()); |
707 } | 775 } |
708 | 776 |
709 INSTANTIATE_TEST_CASE_P(MouseWheelEventQueueTests, | 777 INSTANTIATE_TEST_CASE_P(MouseWheelEventQueueTests, |
710 MouseWheelEventQueueTest, | 778 MouseWheelEventQueueTest, |
711 testing::Bool()); | 779 testing::Bool()); |
712 | 780 |
713 } // namespace content | 781 } // namespace content |
OLD | NEW |