1 // Copyright 2013 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 "base/basictypes.h" 6 #include "base/memory/scoped_ptr.h" 7 #include "base/strings/utf_string_conversions.h" 8 #include "content/browser/renderer_host/input/gesture_event_filter.h" 9 #include "content/browser/renderer_host/input/immediate_input_router.h" 10 #include "content/browser/renderer_host/input/input_router_client.h" 11 #include "content/common/content_constants_internal.h" 12 #include "content/common/edit_command.h" 13 #include "content/common/input_messages.h" 14 #include "content/common/view_messages.h" 15 #include "content/public/test/mock_render_process_host.h" 16 #include "content/public/test/test_browser_context.h" 17 #include "testing/gtest/include/gtest/gtest.h" 18 #include "ui/base/keycodes/keyboard_codes.h" 19 20 #if defined(OS_WIN) || defined(USE_AURA) 21 #include "content/browser/renderer_host/ui_events_helper.h" 22 #include "ui/base/events/event.h" 23 #endif 24 25 using base::TimeDelta; 26 using WebKit::WebGestureEvent; 27 using WebKit::WebInputEvent; 28 using WebKit::WebMouseEvent; 29 using WebKit::WebMouseWheelEvent; 30 using WebKit::WebTouchEvent; 31 using WebKit::WebTouchPoint; 32 33 namespace content { 34 35 namespace { 36 37 const WebInputEvent* GetInputEventFromMessage(const IPC::Message& message) { 38 PickleIterator iter(message); 39 const char* data; 40 int data_length; 41 if (!message.ReadData(&iter, &data, &data_length)) 42 return NULL; 43 return reinterpret_cast<const WebInputEvent*>(data); 44 } 45 46 bool GetIsShortcutFromHandleInputEventMessage(const IPC::Message* msg) { 47 InputMsg_HandleInputEvent::Schema::Param param; 48 InputMsg_HandleInputEvent::Read(msg, ¶m); 49 return param.c; 50 } 51 52 template<typename MSG_T, typename ARG_T1> 53 void ExpectIPCMessageWithArg1(const IPC::Message* msg, const ARG_T1& arg1) { 54 ASSERT_EQ(MSG_T::ID, msg->type()); 55 typename MSG_T::Schema::Param param; 56 ASSERT_TRUE(MSG_T::Read(msg, ¶m)); 57 EXPECT_EQ(arg1, param.a); 58 } 59 60 template<typename MSG_T, typename ARG_T1, typename ARG_T2> 61 void ExpectIPCMessageWithArg2(const IPC::Message* msg, 62 const ARG_T1& arg1, 63 const ARG_T2& arg2) { 64 ASSERT_EQ(MSG_T::ID, msg->type()); 65 typename MSG_T::Schema::Param param; 66 ASSERT_TRUE(MSG_T::Read(msg, ¶m)); 67 EXPECT_EQ(arg1, param.a); 68 EXPECT_EQ(arg2, param.b); 69 } 70 71 #if defined(OS_WIN) || defined(USE_AURA) 72 bool TouchEventsAreEquivalent(const ui::TouchEvent& first, 73 const ui::TouchEvent& second) { 74 if (first.type() != second.type()) 75 return false; 76 if (first.location() != second.location()) 77 return false; 78 if (first.touch_id() != second.touch_id()) 79 return false; 80 if (second.time_stamp().InSeconds() != first.time_stamp().InSeconds()) 81 return false; 82 return true; 83 } 84 85 bool EventListIsSubset(const ScopedVector<ui::TouchEvent>& subset, 86 const ScopedVector<ui::TouchEvent>& set) { 87 if (subset.size() > set.size()) 88 return false; 89 for (size_t i = 0; i < subset.size(); ++i) { 90 const ui::TouchEvent* first = subset[i]; 91 const ui::TouchEvent* second = set[i]; 92 bool equivalent = TouchEventsAreEquivalent(*first, *second); 93 if (!equivalent) 94 return false; 95 } 96 97 return true; 98 } 99 #endif // defined(OS_WIN) || defined(USE_AURA) 100 101 } // namespace 102 103 class MockInputRouterClient : public InputRouterClient { 104 public: 105 MockInputRouterClient() 106 : input_router_(NULL), 107 in_flight_event_count_(0), 108 has_touch_handler_(false), 109 ack_count_(0), 110 unexpected_event_ack_called_(false), 111 ack_state_(INPUT_EVENT_ACK_STATE_UNKNOWN), 112 filter_state_(INPUT_EVENT_ACK_STATE_NOT_CONSUMED), 113 is_shortcut_(false), 114 allow_send_key_event_(true), 115 send_called_(false), 116 send_immediately_called_(false) { 117 } 118 virtual ~MockInputRouterClient() { 119 } 120 121 // InputRouterClient 122 virtual InputEventAckState FilterInputEvent( 123 const WebInputEvent& input_event, 124 const ui::LatencyInfo& latency_info) OVERRIDE { 125 return filter_state_; 126 } 127 128 // Called each time a WebInputEvent IPC is sent. 129 virtual void IncrementInFlightEventCount() OVERRIDE { 130 ++in_flight_event_count_; 131 } 132 133 // Called each time a WebInputEvent ACK IPC is received. 134 virtual void DecrementInFlightEventCount() OVERRIDE { 135 --in_flight_event_count_; 136 } 137 138 // Called when the renderer notifies that it has touch event handlers. 139 virtual void OnHasTouchEventHandlers(bool has_handlers) OVERRIDE { 140 has_touch_handler_ = has_handlers; 141 } 142 143 virtual bool OnSendKeyboardEvent( 144 const NativeWebKeyboardEvent& key_event, 145 const ui::LatencyInfo& latency_info, 146 bool* is_shortcut) OVERRIDE { 147 send_called_ = true; 148 sent_key_event_ = key_event; 149 *is_shortcut = is_shortcut_; 150 151 return allow_send_key_event_; 152 } 153 154 virtual bool OnSendWheelEvent( 155 const MouseWheelEventWithLatencyInfo& wheel_event) OVERRIDE { 156 send_called_ = true; 157 sent_wheel_event_ = wheel_event; 158 159 return true; 160 } 161 162 virtual bool OnSendMouseEvent( 163 const MouseEventWithLatencyInfo& mouse_event) OVERRIDE { 164 send_called_ = true; 165 sent_mouse_event_ = mouse_event; 166 167 return true; 168 } 169 170 virtual bool OnSendTouchEvent( 171 const TouchEventWithLatencyInfo& touch_event) OVERRIDE { 172 send_called_ = true; 173 sent_touch_event_ = touch_event; 174 175 return true; 176 } 177 178 virtual bool OnSendGestureEvent( 179 const GestureEventWithLatencyInfo& gesture_event) OVERRIDE { 180 send_called_ = true; 181 sent_gesture_event_ = gesture_event; 182 183 return input_router_->ShouldForwardGestureEvent(gesture_event); 184 } 185 186 virtual bool OnSendMouseEventImmediately( 187 const MouseEventWithLatencyInfo& mouse_event) OVERRIDE { 188 send_immediately_called_ = true; 189 immediately_sent_mouse_event_ = mouse_event; 190 191 return true; 192 } 193 194 virtual bool OnSendTouchEventImmediately( 195 const TouchEventWithLatencyInfo& touch_event) OVERRIDE { 196 send_immediately_called_ = true; 197 immediately_sent_touch_event_ = touch_event; 198 199 return true; 200 } 201 202 virtual bool OnSendGestureEventImmediately( 203 const GestureEventWithLatencyInfo& gesture_event) OVERRIDE { 204 send_immediately_called_ = true; 205 immediately_sent_gesture_event_ = gesture_event; 206 207 return true; 208 } 209 210 // Called upon event ack receipt from the renderer. 211 virtual void OnKeyboardEventAck(const NativeWebKeyboardEvent& event, 212 InputEventAckState ack_result) OVERRIDE { 213 VLOG(1) << __FUNCTION__ << " called!"; 214 acked_key_event_ = event; 215 RecordAckCalled(ack_result); 216 } 217 virtual void OnWheelEventAck(const WebMouseWheelEvent& event, 218 InputEventAckState ack_result) OVERRIDE { 219 VLOG(1) << __FUNCTION__ << " called!"; 220 acked_wheel_event_ = event; 221 RecordAckCalled(ack_result); 222 } 223 virtual void OnTouchEventAck(const TouchEventWithLatencyInfo& event, 224 InputEventAckState ack_result) OVERRIDE { 225 VLOG(1) << __FUNCTION__ << " called!"; 226 acked_touch_event_ = event; 227 RecordAckCalled(ack_result); 228 } 229 virtual void OnGestureEventAck(const WebGestureEvent& event, 230 InputEventAckState ack_result) OVERRIDE { 231 VLOG(1) << __FUNCTION__ << " called!"; 232 RecordAckCalled(ack_result); 233 } 234 virtual void OnUnexpectedEventAck(bool bad_message) OVERRIDE { 235 VLOG(1) << __FUNCTION__ << " called!"; 236 unexpected_event_ack_called_ = true; 237 } 238 239 void ExpectSendCalled(bool called) { 240 EXPECT_EQ(called, send_called_); 241 send_called_ = false; 242 } 243 void ExpectSendImmediatelyCalled(bool called) { 244 EXPECT_EQ(called, send_immediately_called_); 245 send_immediately_called_ = false; 246 } 247 void ExpectAckCalled(int times) { 248 EXPECT_EQ(times, ack_count_); 249 ack_count_ = 0; 250 } 251 252 void set_input_router(InputRouter* input_router) { 253 input_router_ = input_router; 254 } 255 bool has_touch_handler() const { return has_touch_handler_; } 256 InputEventAckState ack_state() const { return ack_state_; } 257 void set_filter_state(InputEventAckState filter_state) { 258 filter_state_ = filter_state; 259 } 260 bool unexpected_event_ack_called() const { 261 return unexpected_event_ack_called_; 262 } 263 const NativeWebKeyboardEvent& acked_keyboard_event() { 264 return acked_key_event_; 265 } 266 const WebMouseWheelEvent& acked_wheel_event() { 267 return acked_wheel_event_; 268 } 269 const TouchEventWithLatencyInfo& acked_touch_event() { 270 return acked_touch_event_; 271 } 272 void set_is_shortcut(bool is_shortcut) { 273 is_shortcut_ = is_shortcut; 274 } 275 void set_allow_send_key_event(bool allow) { 276 allow_send_key_event_ = allow; 277 } 278 const NativeWebKeyboardEvent& sent_key_event() { 279 return sent_key_event_; 280 } 281 const MouseWheelEventWithLatencyInfo& sent_wheel_event() { 282 return sent_wheel_event_; 283 } 284 const MouseEventWithLatencyInfo& sent_mouse_event() { 285 return sent_mouse_event_; 286 } 287 const GestureEventWithLatencyInfo& sent_gesture_event() { 288 return sent_gesture_event_; 289 } 290 const MouseEventWithLatencyInfo& immediately_sent_mouse_event() { 291 return immediately_sent_mouse_event_; 292 } 293 const TouchEventWithLatencyInfo& immediately_sent_touch_event() { 294 return immediately_sent_touch_event_; 295 } 296 const GestureEventWithLatencyInfo& immediately_sent_gesture_event() { 297 return immediately_sent_gesture_event_; 298 } 299 300 private: 301 void RecordAckCalled(InputEventAckState ack_result) { 302 ++ack_count_; 303 ack_state_ = ack_result; 304 } 305 306 InputRouter* input_router_; 307 int in_flight_event_count_; 308 bool has_touch_handler_; 309 310 int ack_count_; 311 bool unexpected_event_ack_called_; 312 InputEventAckState ack_state_; 313 InputEventAckState filter_state_; 314 NativeWebKeyboardEvent acked_key_event_; 315 WebMouseWheelEvent acked_wheel_event_; 316 TouchEventWithLatencyInfo acked_touch_event_; 317 318 bool is_shortcut_; 319 bool allow_send_key_event_; 320 bool send_called_; 321 NativeWebKeyboardEvent sent_key_event_; 322 MouseWheelEventWithLatencyInfo sent_wheel_event_; 323 MouseEventWithLatencyInfo sent_mouse_event_; 324 TouchEventWithLatencyInfo sent_touch_event_; 325 GestureEventWithLatencyInfo sent_gesture_event_; 326 327 bool send_immediately_called_; 328 MouseEventWithLatencyInfo immediately_sent_mouse_event_; 329 TouchEventWithLatencyInfo immediately_sent_touch_event_; 330 GestureEventWithLatencyInfo immediately_sent_gesture_event_; 331 }; 332 333 class ImmediateInputRouterTest : public testing::Test { 334 public: 335 ImmediateInputRouterTest() { 336 } 337 virtual ~ImmediateInputRouterTest() { 338 } 339 340 protected: 341 // testing::Test 342 virtual void SetUp() { 343 browser_context_.reset(new TestBrowserContext()); 344 process_.reset(new MockRenderProcessHost(browser_context_.get())); 345 client_.reset(new MockInputRouterClient()); 346 input_router_.reset(new ImmediateInputRouter( 347 process_.get(), 348 client_.get(), 349 MSG_ROUTING_NONE)); 350 client_->set_input_router(input_router_.get()); 351 } 352 virtual void TearDown() { 353 // Process all pending tasks to avoid leaks. 354 base::MessageLoop::current()->RunUntilIdle(); 355 356 input_router_.reset(); 357 client_.reset(); 358 process_.reset(); 359 browser_context_.reset(); 360 } 361 362 void SendInputEventACK(WebInputEvent::Type type, 363 InputEventAckState ack_result) { 364 scoped_ptr<IPC::Message> response( 365 new InputHostMsg_HandleInputEvent_ACK(0, type, ack_result, 366 ui::LatencyInfo())); 367 input_router_->OnMessageReceived(*response); 368 } 369 370 void SimulateKeyboardEvent(WebInputEvent::Type type) { 371 NativeWebKeyboardEvent key_event; 372 key_event.type = type; 373 key_event.windowsKeyCode = ui::VKEY_L; // non-null made up value. 374 input_router_->SendKeyboardEvent(key_event, ui::LatencyInfo()); 375 client_->ExpectSendCalled(true); 376 EXPECT_EQ(type, client_->sent_key_event().type); 377 EXPECT_EQ(key_event.windowsKeyCode, 378 client_->sent_key_event().windowsKeyCode); 379 } 380 381 void SimulateWheelEvent(float dX, float dY, int modifiers, bool precise) { 382 WebMouseWheelEvent wheel_event; 383 wheel_event.type = WebInputEvent::MouseWheel; 384 wheel_event.deltaX = dX; 385 wheel_event.deltaY = dY; 386 wheel_event.modifiers = modifiers; 387 wheel_event.hasPreciseScrollingDeltas = precise; 388 input_router_->SendWheelEvent( 389 MouseWheelEventWithLatencyInfo(wheel_event, ui::LatencyInfo())); 390 client_->ExpectSendCalled(true); 391 EXPECT_EQ(wheel_event.type, client_->sent_wheel_event().event.type); 392 EXPECT_EQ(dX, client_->sent_wheel_event().event.deltaX); 393 } 394 395 void SimulateMouseMove(int x, int y, int modifiers) { 396 WebMouseEvent mouse_event; 397 mouse_event.type = WebInputEvent::MouseMove; 398 mouse_event.x = mouse_event.windowX = x; 399 mouse_event.y = mouse_event.windowY = y; 400 mouse_event.modifiers = modifiers; 401 input_router_->SendMouseEvent( 402 MouseEventWithLatencyInfo(mouse_event, ui::LatencyInfo())); 403 client_->ExpectSendCalled(true); 404 client_->ExpectSendImmediatelyCalled(true); 405 EXPECT_EQ(mouse_event.type, client_->sent_mouse_event().event.type); 406 EXPECT_EQ(x, client_->sent_mouse_event().event.x); 407 EXPECT_EQ(mouse_event.type, 408 client_->immediately_sent_mouse_event().event.type); 409 EXPECT_EQ(x, client_->immediately_sent_mouse_event().event.x); 410 } 411 412 void SimulateWheelEventWithPhase(WebMouseWheelEvent::Phase phase) { 413 WebMouseWheelEvent wheel_event; 414 wheel_event.type = WebInputEvent::MouseWheel; 415 wheel_event.phase = phase; 416 input_router_->SendWheelEvent( 417 MouseWheelEventWithLatencyInfo(wheel_event, ui::LatencyInfo())); 418 client_->ExpectSendCalled(true); 419 EXPECT_EQ(wheel_event.type, client_->sent_wheel_event().event.type); 420 EXPECT_EQ(phase, client_->sent_wheel_event().event.phase); 421 } 422 423 // Inject provided synthetic WebGestureEvent instance. 424 void SimulateGestureEventCore(WebInputEvent::Type type, 425 WebGestureEvent::SourceDevice sourceDevice, 426 WebGestureEvent* gesture_event) { 427 gesture_event->type = type; 428 gesture_event->sourceDevice = sourceDevice; 429 GestureEventWithLatencyInfo gesture_with_latency( 430 *gesture_event, ui::LatencyInfo()); 431 input_router_->SendGestureEvent(gesture_with_latency); 432 client_->ExpectSendCalled(true); 433 EXPECT_EQ(type, client_->sent_gesture_event().event.type); 434 EXPECT_EQ(sourceDevice, client_->sent_gesture_event().event.sourceDevice); 435 } 436 437 // Inject simple synthetic WebGestureEvent instances. 438 void SimulateGestureEvent(WebInputEvent::Type type, 439 WebGestureEvent::SourceDevice sourceDevice) { 440 WebGestureEvent gesture_event; 441 SimulateGestureEventCore(type, sourceDevice, &gesture_event); 442 } 443 444 void SimulateGestureScrollUpdateEvent(float dX, float dY, int modifiers) { 445 WebGestureEvent gesture_event; 446 gesture_event.data.scrollUpdate.deltaX = dX; 447 gesture_event.data.scrollUpdate.deltaY = dY; 448 gesture_event.modifiers = modifiers; 449 SimulateGestureEventCore(WebInputEvent::GestureScrollUpdate, 450 WebGestureEvent::Touchscreen, &gesture_event); 451 } 452 453 void SimulateGesturePinchUpdateEvent(float scale, 454 float anchorX, 455 float anchorY, 456 int modifiers) { 457 WebGestureEvent gesture_event; 458 gesture_event.data.pinchUpdate.scale = scale; 459 gesture_event.x = anchorX; 460 gesture_event.y = anchorY; 461 gesture_event.modifiers = modifiers; 462 SimulateGestureEventCore(WebInputEvent::GesturePinchUpdate, 463 WebGestureEvent::Touchscreen, &gesture_event); 464 } 465 466 // Inject synthetic GestureFlingStart events. 467 void SimulateGestureFlingStartEvent( 468 float velocityX, 469 float velocityY, 470 WebGestureEvent::SourceDevice sourceDevice) { 471 WebGestureEvent gesture_event; 472 gesture_event.data.flingStart.velocityX = velocityX; 473 gesture_event.data.flingStart.velocityY = velocityY; 474 SimulateGestureEventCore(WebInputEvent::GestureFlingStart, sourceDevice, 475 &gesture_event); 476 } 477 478 // Set the timestamp for the touch-event. 479 void SetTouchTimestamp(base::TimeDelta timestamp) { 480 touch_event_.timeStampSeconds = timestamp.InSecondsF(); 481 } 482 483 // Sends a touch event (irrespective of whether the page has a touch-event 484 // handler or not). 485 void SendTouchEvent() { 486 input_router_->SendTouchEvent( 487 TouchEventWithLatencyInfo(touch_event_, ui::LatencyInfo())); 488 489 // Mark all the points as stationary. And remove the points that have been 490 // released. 491 int point = 0; 492 for (unsigned int i = 0; i < touch_event_.touchesLength; ++i) { 493 if (touch_event_.touches[i].state == WebTouchPoint::StateReleased) 494 continue; 495 496 touch_event_.touches[point] = touch_event_.touches[i]; 497 touch_event_.touches[point].state = 498 WebTouchPoint::StateStationary; 499 ++point; 500 } 501 touch_event_.touchesLength = point; 502 touch_event_.type = WebInputEvent::Undefined; 503 } 504 505 int PressTouchPoint(int x, int y) { 506 if (touch_event_.touchesLength == touch_event_.touchesLengthCap) 507 return -1; 508 WebTouchPoint& point = 509 touch_event_.touches[touch_event_.touchesLength]; 510 point.id = touch_event_.touchesLength; 511 point.position.x = point.screenPosition.x = x; 512 point.position.y = point.screenPosition.y = y; 513 point.state = WebTouchPoint::StatePressed; 514 point.radiusX = point.radiusY = 1.f; 515 ++touch_event_.touchesLength; 516 touch_event_.type = WebInputEvent::TouchStart; 517 return point.id; 518 } 519 520 void MoveTouchPoint(int index, int x, int y) { 521 CHECK(index >= 0 && index < touch_event_.touchesLengthCap); 522 WebTouchPoint& point = touch_event_.touches[index]; 523 point.position.x = point.screenPosition.x = x; 524 point.position.y = point.screenPosition.y = y; 525 touch_event_.touches[index].state = WebTouchPoint::StateMoved; 526 touch_event_.type = WebInputEvent::TouchMove; 527 } 528 529 void ReleaseTouchPoint(int index) { 530 CHECK(index >= 0 && index < touch_event_.touchesLengthCap); 531 touch_event_.touches[index].state = WebTouchPoint::StateReleased; 532 touch_event_.type = WebInputEvent::TouchEnd; 533 } 534 535 void set_debounce_interval_time_ms(int ms) { 536 input_router_->gesture_event_filter()->debounce_interval_time_ms_ = ms; 537 } 538 539 void set_maximum_tap_gap_time_ms(int delay_ms) { 540 input_router_->gesture_event_filter()->maximum_tap_gap_time_ms_ = delay_ms; 541 } 542 543 size_t TouchEventQueueSize() { 544 return touch_event_queue()->GetQueueSize(); 545 } 546 547 const WebTouchEvent& latest_event() const { 548 return touch_event_queue()->GetLatestEvent().event; 549 } 550 551 TouchEventQueue* touch_event_queue() const { 552 return input_router_->touch_event_queue(); 553 } 554 555 unsigned GestureEventLastQueueEventSize() { 556 return gesture_event_filter()->coalesced_gesture_events_.size(); 557 } 558 559 WebGestureEvent GestureEventSecondFromLastQueueEvent() { 560 return gesture_event_filter()->coalesced_gesture_events_.at( 561 GestureEventLastQueueEventSize() - 2).event; 562 } 563 564 WebGestureEvent GestureEventLastQueueEvent() { 565 return gesture_event_filter()->coalesced_gesture_events_.back().event; 566 } 567 568 unsigned GestureEventDebouncingQueueSize() { 569 return gesture_event_filter()->debouncing_deferral_queue_.size(); 570 } 571 572 WebGestureEvent GestureEventQueueEventAt(int i) { 573 return gesture_event_filter()->coalesced_gesture_events_.at(i).event; 574 } 575 576 bool shouldDeferTapDownEvents() { 577 return gesture_event_filter()->maximum_tap_gap_time_ms_ != 0; 578 } 579 580 bool ScrollingInProgress() { 581 return gesture_event_filter()->scrolling_in_progress_; 582 } 583 584 bool FlingInProgress() { 585 return gesture_event_filter()->fling_in_progress_; 586 } 587 588 bool WillIgnoreNextACK() { 589 return gesture_event_filter()->ignore_next_ack_; 590 } 591 592 GestureEventFilter* gesture_event_filter() const { 593 return input_router_->gesture_event_filter(); 594 } 595 596 scoped_ptr<MockRenderProcessHost> process_; 597 scoped_ptr<MockInputRouterClient> client_; 598 scoped_ptr<ImmediateInputRouter> input_router_; 599 600 private: 601 base::MessageLoopForUI message_loop_; 602 WebTouchEvent touch_event_; 603 604 scoped_ptr<TestBrowserContext> browser_context_; 605 }; 606 607 #if GTEST_HAS_PARAM_TEST 608 // This is for tests that are to be run for all source devices. 609 class ImmediateInputRouterWithSourceTest 610 : public ImmediateInputRouterTest, 611 public testing::WithParamInterface<WebGestureEvent::SourceDevice> { 612 }; 613 #endif // GTEST_HAS_PARAM_TEST 614 615 TEST_F(ImmediateInputRouterTest, CoalescesRangeSelection) { 616 input_router_->SendInput( 617 new InputMsg_SelectRange(0, gfx::Point(1, 2), gfx::Point(3, 4))); 618 EXPECT_EQ(1u, process_->sink().message_count()); 619 ExpectIPCMessageWithArg2<InputMsg_SelectRange>( 620 process_->sink().GetMessageAt(0), 621 gfx::Point(1, 2), 622 gfx::Point(3, 4)); 623 process_->sink().ClearMessages(); 624 625 // Send two more messages without acking. 626 input_router_->SendInput( 627 new InputMsg_SelectRange(0, gfx::Point(5, 6), gfx::Point(7, 8))); 628 EXPECT_EQ(0u, process_->sink().message_count()); 629 630 input_router_->SendInput( 631 new InputMsg_SelectRange(0, gfx::Point(9, 10), gfx::Point(11, 12))); 632 EXPECT_EQ(0u, process_->sink().message_count()); 633 634 // Now ack the first message. 635 { 636 scoped_ptr<IPC::Message> response(new ViewHostMsg_SelectRange_ACK(0)); 637 input_router_->OnMessageReceived(*response); 638 } 639 640 // Verify that the two messages are coalesced into one message. 641 EXPECT_EQ(1u, process_->sink().message_count()); 642 ExpectIPCMessageWithArg2<InputMsg_SelectRange>( 643 process_->sink().GetMessageAt(0), 644 gfx::Point(9, 10), 645 gfx::Point(11, 12)); 646 process_->sink().ClearMessages(); 647 648 // Acking the coalesced msg should not send any more msg. 649 { 650 scoped_ptr<IPC::Message> response(new ViewHostMsg_SelectRange_ACK(0)); 651 input_router_->OnMessageReceived(*response); 652 } 653 EXPECT_EQ(0u, process_->sink().message_count()); 654 } 655 656 TEST_F(ImmediateInputRouterTest, CoalescesCaretMove) { 657 input_router_->SendInput(new InputMsg_MoveCaret(0, gfx::Point(1, 2))); 658 EXPECT_EQ(1u, process_->sink().message_count()); 659 ExpectIPCMessageWithArg1<InputMsg_MoveCaret>( 660 process_->sink().GetMessageAt(0), gfx::Point(1, 2)); 661 process_->sink().ClearMessages(); 662 663 // Send two more messages without acking. 664 input_router_->SendInput(new InputMsg_MoveCaret(0, gfx::Point(5, 6))); 665 EXPECT_EQ(0u, process_->sink().message_count()); 666 667 input_router_->SendInput(new InputMsg_MoveCaret(0, gfx::Point(9, 10))); 668 EXPECT_EQ(0u, process_->sink().message_count()); 669 670 // Now ack the first message. 671 { 672 scoped_ptr<IPC::Message> response(new ViewHostMsg_MoveCaret_ACK(0)); 673 input_router_->OnMessageReceived(*response); 674 } 675 676 // Verify that the two messages are coalesced into one message. 677 EXPECT_EQ(1u, process_->sink().message_count()); 678 ExpectIPCMessageWithArg1<InputMsg_MoveCaret>( 679 process_->sink().GetMessageAt(0), gfx::Point(9, 10)); 680 process_->sink().ClearMessages(); 681 682 // Acking the coalesced msg should not send any more msg. 683 { 684 scoped_ptr<IPC::Message> response(new ViewHostMsg_MoveCaret_ACK(0)); 685 input_router_->OnMessageReceived(*response); 686 } 687 EXPECT_EQ(0u, process_->sink().message_count()); 688 } 689 690 TEST_F(ImmediateInputRouterTest, HandledInputEvent) { 691 client_->set_filter_state(INPUT_EVENT_ACK_STATE_CONSUMED); 692 693 // Simulate a keyboard event. 694 SimulateKeyboardEvent(WebInputEvent::RawKeyDown); 695 696 // Make sure no input event is sent to the renderer. 697 EXPECT_EQ(0u, process_->sink().message_count()); 698 699 // OnKeyboardEventAck should be triggered without actual ack. 700 client_->ExpectAckCalled(1); 701 702 // As the event was acked already, keyboard event queue should be 703 // empty. 704 ASSERT_EQ(NULL, input_router_->GetLastKeyboardEvent()); 705 } 706 707 TEST_F(ImmediateInputRouterTest, ClientCanceledKeyboardEvent) { 708 client_->set_allow_send_key_event(false); 709 710 // Simulate a keyboard event. 711 SimulateKeyboardEvent(WebInputEvent::RawKeyDown); 712 713 // Make sure no input event is sent to the renderer. 714 EXPECT_EQ(0u, process_->sink().message_count()); 715 client_->ExpectAckCalled(0); 716 } 717 718 TEST_F(ImmediateInputRouterTest, ShortcutKeyboardEvent) { 719 client_->set_is_shortcut(true); 720 SimulateKeyboardEvent(WebInputEvent::RawKeyDown); 721 EXPECT_TRUE(GetIsShortcutFromHandleInputEventMessage( 722 process_->sink().GetMessageAt(0))); 723 724 process_->sink().ClearMessages(); 725 726 client_->set_is_shortcut(false); 727 SimulateKeyboardEvent(WebInputEvent::RawKeyDown); 728 EXPECT_FALSE(GetIsShortcutFromHandleInputEventMessage( 729 process_->sink().GetMessageAt(0))); 730 } 731 732 TEST_F(ImmediateInputRouterTest, NoncorrespondingKeyEvents) { 733 SimulateKeyboardEvent(WebInputEvent::RawKeyDown); 734 735 SendInputEventACK(WebInputEvent::KeyUp, 736 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 737 EXPECT_TRUE(client_->unexpected_event_ack_called()); 738 } 739 740 // Tests ported from RenderWidgetHostTest -------------------------------------- 741 742 TEST_F(ImmediateInputRouterTest, HandleKeyEventsWeSent) { 743 // Simulate a keyboard event. 744 SimulateKeyboardEvent(WebInputEvent::RawKeyDown); 745 ASSERT_TRUE(input_router_->GetLastKeyboardEvent()); 746 EXPECT_EQ(WebInputEvent::RawKeyDown, 747 input_router_->GetLastKeyboardEvent()->type); 748 749 // Make sure we sent the input event to the renderer. 750 EXPECT_TRUE(process_->sink().GetUniqueMessageMatching( 751 InputMsg_HandleInputEvent::ID)); 752 process_->sink().ClearMessages(); 753 754 // Send the simulated response from the renderer back. 755 SendInputEventACK(WebInputEvent::RawKeyDown, 756 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 757 client_->ExpectAckCalled(1); 758 EXPECT_EQ(WebInputEvent::RawKeyDown, client_->acked_keyboard_event().type); 759 } 760 761 TEST_F(ImmediateInputRouterTest, IgnoreKeyEventsWeDidntSend) { 762 // Send a simulated, unrequested key response. We should ignore this. 763 SendInputEventACK(WebInputEvent::RawKeyDown, 764 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 765 766 client_->ExpectAckCalled(0); 767 } 768 769 TEST_F(ImmediateInputRouterTest, CoalescesWheelEvents) { 770 // Simulate wheel events. 771 SimulateWheelEvent(0, -5, 0, false); // sent directly 772 SimulateWheelEvent(0, -10, 0, false); // enqueued 773 SimulateWheelEvent(8, -6, 0, false); // coalesced into previous event 774 SimulateWheelEvent(9, -7, 1, false); // enqueued, different modifiers 775 776 // Check that only the first event was sent. 777 EXPECT_EQ(1U, process_->sink().message_count()); 778 EXPECT_TRUE(process_->sink().GetUniqueMessageMatching( 779 InputMsg_HandleInputEvent::ID)); 780 process_->sink().ClearMessages(); 781 782 // Check that the ACK sends the second message via ImmediateInputForwarder 783 SendInputEventACK(WebInputEvent::MouseWheel, 784 INPUT_EVENT_ACK_STATE_CONSUMED); 785 // The coalesced events can queue up a delayed ack 786 // so that additional input events can be processed before 787 // we turn off coalescing. 788 base::MessageLoop::current()->RunUntilIdle(); 789 client_->ExpectAckCalled(1); 790 EXPECT_EQ(1U, process_->sink().message_count()); 791 EXPECT_TRUE(process_->sink().GetUniqueMessageMatching( 792 InputMsg_HandleInputEvent::ID)); 793 process_->sink().ClearMessages(); 794 795 // One more time. 796 SendInputEventACK(WebInputEvent::MouseWheel, 797 INPUT_EVENT_ACK_STATE_CONSUMED); 798 base::MessageLoop::current()->RunUntilIdle(); 799 client_->ExpectAckCalled(1); 800 EXPECT_EQ(1U, process_->sink().message_count()); 801 EXPECT_TRUE(process_->sink().GetUniqueMessageMatching( 802 InputMsg_HandleInputEvent::ID)); 803 process_->sink().ClearMessages(); 804 805 // After the final ack, the queue should be empty. 806 SendInputEventACK(WebInputEvent::MouseWheel, 807 INPUT_EVENT_ACK_STATE_CONSUMED); 808 base::MessageLoop::current()->RunUntilIdle(); 809 client_->ExpectAckCalled(1); 810 EXPECT_EQ(0U, process_->sink().message_count()); 811 812 // FIXME(kouhei): Below is testing gesture event filter. Maybe separate test? 813 { 814 WebGestureEvent gesture_event; 815 gesture_event.type = WebInputEvent::GestureFlingStart; 816 gesture_event.sourceDevice = WebGestureEvent::Touchpad; 817 gesture_event.data.flingStart.velocityX = 0.f; 818 gesture_event.data.flingStart.velocityY = 0.f; 819 EXPECT_FALSE(input_router_->ShouldForwardGestureEvent( 820 GestureEventWithLatencyInfo(gesture_event, ui::LatencyInfo()))); 821 } 822 } 823 824 TEST_F(ImmediateInputRouterTest, 825 CoalescesWheelEventsQueuedPhaseEndIsNotDropped) { 826 // Send an initial gesture begin and ACK it. 827 SimulateGestureEvent(WebInputEvent::GestureScrollBegin, 828 WebGestureEvent::Touchpad); 829 EXPECT_EQ(1U, process_->sink().message_count()); 830 SendInputEventACK(WebInputEvent::GestureScrollBegin, 831 INPUT_EVENT_ACK_STATE_CONSUMED); 832 base::MessageLoop::current()->RunUntilIdle(); 833 834 // Send a wheel event, should get sent directly. 835 SimulateWheelEvent(0, -5, 0, false); 836 EXPECT_EQ(2U, process_->sink().message_count()); 837 838 // Send a wheel phase end event before an ACK is received for the previous 839 // wheel event, which should get queued. 840 SimulateWheelEventWithPhase(WebMouseWheelEvent::PhaseEnded); 841 EXPECT_EQ(2U, process_->sink().message_count()); 842 843 // A gesture event should now result in the queued phase ended event being 844 // transmitted before it. 845 SimulateGestureEvent(WebInputEvent::GestureScrollEnd, 846 WebGestureEvent::Touchpad); 847 ASSERT_EQ(4U, process_->sink().message_count()); 848 849 // Verify the events that were sent. 850 const WebInputEvent* input_event = 851 GetInputEventFromMessage(*process_->sink().GetMessageAt(2)); 852 ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type); 853 const WebMouseWheelEvent* wheel_event = 854 static_cast<const WebMouseWheelEvent*>(input_event); 855 ASSERT_EQ(WebMouseWheelEvent::PhaseEnded, wheel_event->phase); 856 857 input_event = GetInputEventFromMessage(*process_->sink().GetMessageAt(3)); 858 EXPECT_EQ(WebInputEvent::GestureScrollEnd, input_event->type); 859 } 860 861 TEST_F(ImmediateInputRouterTest, CoalescesScrollGestureEvents) { 862 // Turn off debounce handling for test isolation. 863 set_debounce_interval_time_ms(0); 864 865 // Test coalescing of only GestureScrollUpdate events. 866 // Simulate gesture events. 867 868 // Sent. 869 SimulateGestureEvent(WebInputEvent::GestureScrollBegin, 870 WebGestureEvent::Touchscreen); 871 872 // Enqueued. 873 SimulateGestureScrollUpdateEvent(8, -5, 0); 874 875 // Make sure that the queue contains what we think it should. 876 WebGestureEvent merged_event = GestureEventLastQueueEvent(); 877 EXPECT_EQ(2U, GestureEventLastQueueEventSize()); 878 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type); 879 880 // Coalesced. 881 SimulateGestureScrollUpdateEvent(8, -6, 0); 882 883 // Check that coalescing updated the correct values. 884 merged_event = GestureEventLastQueueEvent(); 885 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type); 886 EXPECT_EQ(0, merged_event.modifiers); 887 EXPECT_EQ(16, merged_event.data.scrollUpdate.deltaX); 888 EXPECT_EQ(-11, merged_event.data.scrollUpdate.deltaY); 889 890 // Enqueued. 891 SimulateGestureScrollUpdateEvent(8, -7, 1); 892 893 // Check that we didn't wrongly coalesce. 894 merged_event = GestureEventLastQueueEvent(); 895 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type); 896 EXPECT_EQ(1, merged_event.modifiers); 897 898 // Different. 899 SimulateGestureEvent(WebInputEvent::GestureScrollEnd, 900 WebGestureEvent::Touchscreen); 901 902 // Check that only the first event was sent. 903 EXPECT_EQ(1U, process_->sink().message_count()); 904 EXPECT_TRUE(process_->sink().GetUniqueMessageMatching( 905 InputMsg_HandleInputEvent::ID)); 906 process_->sink().ClearMessages(); 907 908 // Check that the ACK sends the second message. 909 SendInputEventACK(WebInputEvent::GestureScrollBegin, 910 INPUT_EVENT_ACK_STATE_CONSUMED); 911 base::MessageLoop::current()->RunUntilIdle(); 912 client_->ExpectAckCalled(1); 913 EXPECT_EQ(1U, process_->sink().message_count()); 914 EXPECT_TRUE(process_->sink().GetUniqueMessageMatching( 915 InputMsg_HandleInputEvent::ID)); 916 process_->sink().ClearMessages(); 917 918 // Ack for queued coalesced event. 919 SendInputEventACK(WebInputEvent::GestureScrollUpdate, 920 INPUT_EVENT_ACK_STATE_CONSUMED); 921 base::MessageLoop::current()->RunUntilIdle(); 922 client_->ExpectAckCalled(1); 923 EXPECT_EQ(1U, process_->sink().message_count()); 924 EXPECT_TRUE(process_->sink().GetUniqueMessageMatching( 925 InputMsg_HandleInputEvent::ID)); 926 process_->sink().ClearMessages(); 927 928 // Ack for queued uncoalesced event. 929 SendInputEventACK(WebInputEvent::GestureScrollUpdate, 930 INPUT_EVENT_ACK_STATE_CONSUMED); 931 base::MessageLoop::current()->RunUntilIdle(); 932 client_->ExpectAckCalled(1); 933 EXPECT_EQ(1U, process_->sink().message_count()); 934 EXPECT_TRUE(process_->sink().GetUniqueMessageMatching( 935 InputMsg_HandleInputEvent::ID)); 936 process_->sink().ClearMessages(); 937 938 // After the final ack, the queue should be empty. 939 SendInputEventACK(WebInputEvent::GestureScrollEnd, 940 INPUT_EVENT_ACK_STATE_CONSUMED); 941 base::MessageLoop::current()->RunUntilIdle(); 942 client_->ExpectAckCalled(1); 943 EXPECT_EQ(0U, process_->sink().message_count()); 944 } 945 946 TEST_F(ImmediateInputRouterTest, CoalescesScrollAndPinchEvents) { 947 // Turn off debounce handling for test isolation. 948 set_debounce_interval_time_ms(0); 949 950 // Test coalescing of only GestureScrollUpdate events. 951 // Simulate gesture events. 952 953 // Sent. 954 SimulateGestureEvent(WebInputEvent::GestureScrollBegin, 955 WebGestureEvent::Touchscreen); 956 957 // Sent. 958 SimulateGestureEvent(WebInputEvent::GesturePinchBegin, 959 WebGestureEvent::Touchscreen); 960 961 // Enqueued. 962 SimulateGestureScrollUpdateEvent(8, -4, 1); 963 964 // Make sure that the queue contains what we think it should. 965 WebGestureEvent merged_event = GestureEventLastQueueEvent(); 966 EXPECT_EQ(3U, GestureEventLastQueueEventSize()); 967 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type); 968 969 // Coalesced without changing event order. Note anchor at (60, 60). Anchoring 970 // from a poinht that is not the origin should still give us the wight scroll. 971 SimulateGesturePinchUpdateEvent(1.5, 60, 60, 1); 972 EXPECT_EQ(4U, GestureEventLastQueueEventSize()); 973 merged_event = GestureEventLastQueueEvent(); 974 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type); 975 EXPECT_EQ(1.5, merged_event.data.pinchUpdate.scale); 976 EXPECT_EQ(1, merged_event.modifiers); 977 merged_event = GestureEventSecondFromLastQueueEvent(); 978 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type); 979 EXPECT_EQ(8, merged_event.data.scrollUpdate.deltaX); 980 EXPECT_EQ(-4, merged_event.data.scrollUpdate.deltaY); 981 EXPECT_EQ(1, merged_event.modifiers); 982 983 // Enqueued. 984 SimulateGestureScrollUpdateEvent(6, -3, 1); 985 986 // Check whether coalesced correctly. 987 EXPECT_EQ(4U, GestureEventLastQueueEventSize()); 988 merged_event = GestureEventLastQueueEvent(); 989 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type); 990 EXPECT_EQ(1.5, merged_event.data.pinchUpdate.scale); 991 EXPECT_EQ(1, merged_event.modifiers); 992 merged_event = GestureEventSecondFromLastQueueEvent(); 993 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type); 994 EXPECT_EQ(12, merged_event.data.scrollUpdate.deltaX); 995 EXPECT_EQ(-6, merged_event.data.scrollUpdate.deltaY); 996 EXPECT_EQ(1, merged_event.modifiers); 997 998 // Enqueued. 999 SimulateGesturePinchUpdateEvent(2, 60, 60, 1); 1000 1001 // Check whether coalesced correctly. 1002 EXPECT_EQ(4U, GestureEventLastQueueEventSize()); 1003 merged_event = GestureEventLastQueueEvent(); 1004 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type); 1005 EXPECT_EQ(3, merged_event.data.pinchUpdate.scale); 1006 EXPECT_EQ(1, merged_event.modifiers); 1007 merged_event = GestureEventSecondFromLastQueueEvent(); 1008 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type); 1009 EXPECT_EQ(12, merged_event.data.scrollUpdate.deltaX); 1010 EXPECT_EQ(-6, merged_event.data.scrollUpdate.deltaY); 1011 EXPECT_EQ(1, merged_event.modifiers); 1012 1013 // Enqueued. 1014 SimulateGesturePinchUpdateEvent(2, 60, 60, 1); 1015 1016 // Check whether coalesced correctly. 1017 EXPECT_EQ(4U, GestureEventLastQueueEventSize()); 1018 merged_event = GestureEventLastQueueEvent(); 1019 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type); 1020 EXPECT_EQ(6, merged_event.data.pinchUpdate.scale); 1021 EXPECT_EQ(1, merged_event.modifiers); 1022 merged_event = GestureEventSecondFromLastQueueEvent(); 1023 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type); 1024 EXPECT_EQ(12, merged_event.data.scrollUpdate.deltaX); 1025 EXPECT_EQ(-6, merged_event.data.scrollUpdate.deltaY); 1026 EXPECT_EQ(1, merged_event.modifiers); 1027 1028 // Check that only the first event was sent. 1029 EXPECT_EQ(1U, process_->sink().message_count()); 1030 EXPECT_TRUE(process_->sink().GetUniqueMessageMatching( 1031 InputMsg_HandleInputEvent::ID)); 1032 process_->sink().ClearMessages(); 1033 1034 // Check that the ACK sends the second message. 1035 SendInputEventACK(WebInputEvent::GestureScrollBegin, 1036 INPUT_EVENT_ACK_STATE_CONSUMED); 1037 base::MessageLoop::current()->RunUntilIdle(); 1038 EXPECT_EQ(1U, process_->sink().message_count()); 1039 EXPECT_TRUE(process_->sink().GetUniqueMessageMatching( 1040 InputMsg_HandleInputEvent::ID)); 1041 process_->sink().ClearMessages(); 1042 1043 // Enqueued. 1044 SimulateGestureScrollUpdateEvent(6, -6, 1); 1045 1046 // Check whether coalesced correctly. 1047 EXPECT_EQ(3U, GestureEventLastQueueEventSize()); 1048 merged_event = GestureEventLastQueueEvent(); 1049 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type); 1050 EXPECT_EQ(6, merged_event.data.pinchUpdate.scale); 1051 EXPECT_EQ(1, merged_event.modifiers); 1052 merged_event = GestureEventSecondFromLastQueueEvent(); 1053 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type); 1054 EXPECT_EQ(13, merged_event.data.scrollUpdate.deltaX); 1055 EXPECT_EQ(-7, merged_event.data.scrollUpdate.deltaY); 1056 EXPECT_EQ(1, merged_event.modifiers); 1057 1058 // At this point ACKs shouldn't be getting ignored. 1059 EXPECT_FALSE(WillIgnoreNextACK()); 1060 1061 // Check that the ACK sends both scroll and pinch updates. 1062 SendInputEventACK(WebInputEvent::GesturePinchBegin, 1063 INPUT_EVENT_ACK_STATE_CONSUMED); 1064 base::MessageLoop::current()->RunUntilIdle(); 1065 EXPECT_EQ(2U, process_->sink().message_count()); 1066 EXPECT_TRUE(process_->sink().GetFirstMessageMatching( 1067 InputMsg_HandleInputEvent::ID)); 1068 EXPECT_FALSE(process_->sink().GetUniqueMessageMatching( 1069 InputMsg_HandleInputEvent::ID)); 1070 process_->sink().ClearMessages(); 1071 1072 // The next ACK should be getting ignored. 1073 EXPECT_TRUE(WillIgnoreNextACK()); 1074 1075 // Enqueued. 1076 SimulateGestureScrollUpdateEvent(1, -1, 1); 1077 1078 // Check whether coalesced correctly. 1079 EXPECT_EQ(3U, GestureEventLastQueueEventSize()); 1080 merged_event = GestureEventLastQueueEvent(); 1081 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type); 1082 EXPECT_EQ(1, merged_event.data.scrollUpdate.deltaX); 1083 EXPECT_EQ(-1, merged_event.data.scrollUpdate.deltaY); 1084 EXPECT_EQ(1, merged_event.modifiers); 1085 merged_event = GestureEventSecondFromLastQueueEvent(); 1086 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type); 1087 EXPECT_EQ(6, merged_event.data.pinchUpdate.scale); 1088 EXPECT_EQ(1, merged_event.modifiers); 1089 1090 // Enqueued. 1091 SimulateGestureScrollUpdateEvent(2, -2, 1); 1092 1093 // Coalescing scrolls should still work. 1094 EXPECT_EQ(3U, GestureEventLastQueueEventSize()); 1095 merged_event = GestureEventLastQueueEvent(); 1096 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type); 1097 EXPECT_EQ(3, merged_event.data.scrollUpdate.deltaX); 1098 EXPECT_EQ(-3, merged_event.data.scrollUpdate.deltaY); 1099 EXPECT_EQ(1, merged_event.modifiers); 1100 merged_event = GestureEventSecondFromLastQueueEvent(); 1101 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type); 1102 EXPECT_EQ(6, merged_event.data.pinchUpdate.scale); 1103 EXPECT_EQ(1, merged_event.modifiers); 1104 1105 // Enqueued. 1106 SimulateGesturePinchUpdateEvent(0.5, 60, 60, 1); 1107 1108 // Check whether coalesced correctly. 1109 EXPECT_EQ(4U, GestureEventLastQueueEventSize()); 1110 merged_event = GestureEventLastQueueEvent(); 1111 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type); 1112 EXPECT_EQ(0.5, merged_event.data.pinchUpdate.scale); 1113 EXPECT_EQ(1, merged_event.modifiers); 1114 merged_event = GestureEventSecondFromLastQueueEvent(); 1115 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type); 1116 EXPECT_EQ(3, merged_event.data.scrollUpdate.deltaX); 1117 EXPECT_EQ(-3, merged_event.data.scrollUpdate.deltaY); 1118 EXPECT_EQ(1, merged_event.modifiers); 1119 1120 // Check that the ACK gets ignored. 1121 SendInputEventACK(WebInputEvent::GestureScrollUpdate, 1122 INPUT_EVENT_ACK_STATE_CONSUMED); 1123 base::MessageLoop::current()->RunUntilIdle(); 1124 EXPECT_EQ(0U, process_->sink().message_count()); 1125 // The flag should have been flipped back to false. 1126 EXPECT_FALSE(WillIgnoreNextACK()); 1127 1128 // Enqueued. 1129 SimulateGestureScrollUpdateEvent(2, -2, 2); 1130 1131 // Shouldn't coalesce with different modifiers. 1132 EXPECT_EQ(4U, GestureEventLastQueueEventSize()); 1133 merged_event = GestureEventLastQueueEvent(); 1134 EXPECT_EQ(WebInputEvent::GestureScrollUpdate, merged_event.type); 1135 EXPECT_EQ(2, merged_event.data.scrollUpdate.deltaX); 1136 EXPECT_EQ(-2, merged_event.data.scrollUpdate.deltaY); 1137 EXPECT_EQ(2, merged_event.modifiers); 1138 merged_event = GestureEventSecondFromLastQueueEvent(); 1139 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, merged_event.type); 1140 EXPECT_EQ(0.5, merged_event.data.pinchUpdate.scale); 1141 EXPECT_EQ(1, merged_event.modifiers); 1142 1143 // Check that the ACK sends the next scroll pinch pair. 1144 SendInputEventACK(WebInputEvent::GesturePinchUpdate, 1145 INPUT_EVENT_ACK_STATE_CONSUMED); 1146 base::MessageLoop::current()->RunUntilIdle(); 1147 EXPECT_EQ(2U, process_->sink().message_count()); 1148 EXPECT_TRUE(process_->sink().GetFirstMessageMatching( 1149 InputMsg_HandleInputEvent::ID)); 1150 EXPECT_FALSE(process_->sink().GetUniqueMessageMatching( 1151 InputMsg_HandleInputEvent::ID)); 1152 process_->sink().ClearMessages(); 1153 1154 // Check that the ACK sends the second message. 1155 SendInputEventACK(WebInputEvent::GestureScrollUpdate, 1156 INPUT_EVENT_ACK_STATE_CONSUMED); 1157 base::MessageLoop::current()->RunUntilIdle(); 1158 EXPECT_EQ(0U, process_->sink().message_count()); 1159 1160 // Check that the ACK sends the second message. 1161 SendInputEventACK(WebInputEvent::GesturePinchUpdate, 1162 INPUT_EVENT_ACK_STATE_CONSUMED); 1163 base::MessageLoop::current()->RunUntilIdle(); 1164 EXPECT_EQ(1U, process_->sink().message_count()); 1165 EXPECT_TRUE(process_->sink().GetUniqueMessageMatching( 1166 InputMsg_HandleInputEvent::ID)); 1167 process_->sink().ClearMessages(); 1168 1169 // Check that the queue is empty after ACK and no messages get sent. 1170 SendInputEventACK(WebInputEvent::GestureScrollUpdate, 1171 INPUT_EVENT_ACK_STATE_CONSUMED); 1172 base::MessageLoop::current()->RunUntilIdle(); 1173 EXPECT_EQ(0U, process_->sink().message_count()); 1174 EXPECT_EQ(0U, GestureEventLastQueueEventSize()); 1175 } 1176 1177 #if GTEST_HAS_PARAM_TEST 1178 TEST_P(ImmediateInputRouterWithSourceTest, GestureFlingCancelsFiltered) { 1179 WebGestureEvent::SourceDevice source_device = GetParam(); 1180 1181 // Turn off debounce handling for test isolation. 1182 set_debounce_interval_time_ms(0); 1183 // GFC without previous GFS is dropped. 1184 SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device); 1185 EXPECT_EQ(0U, process_->sink().message_count()); 1186 EXPECT_EQ(0U, GestureEventLastQueueEventSize()); 1187 1188 // GFC after previous GFS is dispatched and acked. 1189 process_->sink().ClearMessages(); 1190 SimulateGestureFlingStartEvent(0, -10, source_device); 1191 EXPECT_TRUE(FlingInProgress()); 1192 SendInputEventACK(WebInputEvent::GestureFlingStart, 1193 INPUT_EVENT_ACK_STATE_CONSUMED); 1194 base::MessageLoop::current()->RunUntilIdle(); 1195 client_->ExpectAckCalled(1); 1196 SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device); 1197 EXPECT_FALSE(FlingInProgress()); 1198 EXPECT_EQ(2U, process_->sink().message_count()); 1199 SendInputEventACK(WebInputEvent::GestureFlingCancel, 1200 INPUT_EVENT_ACK_STATE_CONSUMED); 1201 base::MessageLoop::current()->RunUntilIdle(); 1202 client_->ExpectAckCalled(1); 1203 EXPECT_EQ(0U, GestureEventLastQueueEventSize()); 1204 1205 // GFC before previous GFS is acked. 1206 process_->sink().ClearMessages(); 1207 SimulateGestureFlingStartEvent(0, -10, source_device); 1208 EXPECT_TRUE(FlingInProgress()); 1209 SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device); 1210 EXPECT_FALSE(FlingInProgress()); 1211 EXPECT_EQ(1U, process_->sink().message_count()); 1212 EXPECT_EQ(2U, GestureEventLastQueueEventSize()); 1213 1214 // Advance state realistically. 1215 SendInputEventACK(WebInputEvent::GestureFlingStart, 1216 INPUT_EVENT_ACK_STATE_CONSUMED); 1217 base::MessageLoop::current()->RunUntilIdle(); 1218 SendInputEventACK(WebInputEvent::GestureFlingCancel, 1219 INPUT_EVENT_ACK_STATE_CONSUMED); 1220 base::MessageLoop::current()->RunUntilIdle(); 1221 client_->ExpectAckCalled(2); 1222 EXPECT_EQ(0U, GestureEventLastQueueEventSize()); 1223 1224 // GFS is added to the queue if another event is pending 1225 process_->sink().ClearMessages(); 1226 SimulateGestureScrollUpdateEvent(8, -7, 0); 1227 SimulateGestureFlingStartEvent(0, -10, source_device); 1228 EXPECT_EQ(2U, GestureEventLastQueueEventSize()); 1229 EXPECT_EQ(1U, process_->sink().message_count()); 1230 WebGestureEvent merged_event = GestureEventLastQueueEvent(); 1231 EXPECT_EQ(WebInputEvent::GestureFlingStart, merged_event.type); 1232 EXPECT_TRUE(FlingInProgress()); 1233 EXPECT_EQ(2U, GestureEventLastQueueEventSize()); 1234 1235 // GFS in queue means that a GFC is added to the queue 1236 SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device); 1237 merged_event =GestureEventLastQueueEvent(); 1238 EXPECT_EQ(WebInputEvent::GestureFlingCancel, merged_event.type); 1239 EXPECT_FALSE(FlingInProgress()); 1240 EXPECT_EQ(3U, GestureEventLastQueueEventSize()); 1241 1242 // Adding a second GFC is dropped. 1243 SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device); 1244 EXPECT_FALSE(FlingInProgress()); 1245 EXPECT_EQ(3U, GestureEventLastQueueEventSize()); 1246 1247 // Adding another GFS will add it to the queue. 1248 SimulateGestureFlingStartEvent(0, -10, source_device); 1249 merged_event = GestureEventLastQueueEvent(); 1250 EXPECT_EQ(WebInputEvent::GestureFlingStart, merged_event.type); 1251 EXPECT_TRUE(FlingInProgress()); 1252 EXPECT_EQ(4U, GestureEventLastQueueEventSize()); 1253 1254 // GFS in queue means that a GFC is added to the queue 1255 SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device); 1256 merged_event = GestureEventLastQueueEvent(); 1257 EXPECT_EQ(WebInputEvent::GestureFlingCancel, merged_event.type); 1258 EXPECT_FALSE(FlingInProgress()); 1259 EXPECT_EQ(5U, GestureEventLastQueueEventSize()); 1260 1261 // Adding another GFC with a GFC already there is dropped. 1262 SimulateGestureEvent(WebInputEvent::GestureFlingCancel, source_device); 1263 merged_event = GestureEventLastQueueEvent(); 1264 EXPECT_EQ(WebInputEvent::GestureFlingCancel, merged_event.type); 1265 EXPECT_FALSE(FlingInProgress()); 1266 EXPECT_EQ(5U, GestureEventLastQueueEventSize()); 1267 } 1268 1269 INSTANTIATE_TEST_CASE_P(AllSources, 1270 ImmediateInputRouterWithSourceTest, 1271 testing::Values(WebGestureEvent::Touchscreen, 1272 WebGestureEvent::Touchpad)); 1273 #endif // GTEST_HAS_PARAM_TEST 1274 1275 // Test that GestureTapDown events are deferred. 1276 TEST_F(ImmediateInputRouterTest, DeferredGestureTapDown) { 1277 // Set some sort of short deferral timeout 1278 set_maximum_tap_gap_time_ms(5); 1279 1280 SimulateGestureEvent(WebInputEvent::GestureTapDown, 1281 WebGestureEvent::Touchscreen); 1282 EXPECT_EQ(0U, process_->sink().message_count()); 1283 EXPECT_EQ(0U, GestureEventLastQueueEventSize()); 1284 1285 // Wait long enough for first timeout and see if it fired. 1286 base::MessageLoop::current()->PostDelayedTask( 1287 FROM_HERE, 1288 base::MessageLoop::QuitClosure(), 1289 TimeDelta::FromMilliseconds(10)); 1290 base::MessageLoop::current()->Run(); 1291 1292 EXPECT_EQ(1U, process_->sink().message_count()); 1293 EXPECT_EQ(1U, GestureEventLastQueueEventSize()); 1294 EXPECT_EQ(WebInputEvent::GestureTapDown, 1295 GestureEventLastQueueEvent().type); 1296 } 1297 1298 // Test that GestureTapDown events are sent immediately on GestureTap. 1299 TEST_F(ImmediateInputRouterTest, DeferredGestureTapDownSentOnTap) { 1300 // Set some sort of short deferral timeout 1301 set_maximum_tap_gap_time_ms(5); 1302 1303 SimulateGestureEvent(WebInputEvent::GestureTapDown, 1304 WebGestureEvent::Touchscreen); 1305 EXPECT_EQ(0U, process_->sink().message_count()); 1306 EXPECT_EQ(0U, GestureEventLastQueueEventSize()); 1307 1308 SimulateGestureEvent(WebInputEvent::GestureTap, 1309 WebGestureEvent::Touchscreen); 1310 EXPECT_EQ(1U, process_->sink().message_count()); 1311 EXPECT_EQ(2U, GestureEventLastQueueEventSize()); 1312 EXPECT_EQ(WebInputEvent::GestureTap, 1313 GestureEventLastQueueEvent().type); 1314 1315 base::MessageLoop::current()->PostDelayedTask( 1316 FROM_HERE, 1317 base::MessageLoop::QuitClosure(), 1318 TimeDelta::FromMilliseconds(10)); 1319 base::MessageLoop::current()->Run(); 1320 1321 EXPECT_EQ(WebInputEvent::GestureTapDown, 1322 client_->immediately_sent_gesture_event().event.type); 1323 1324 // If the deferral timer incorrectly fired, it sent an extra message. 1325 EXPECT_EQ(1U, process_->sink().message_count()); 1326 } 1327 1328 // Test that only a single GestureTapDown event is sent when tap occurs after 1329 // the timeout. 1330 TEST_F(ImmediateInputRouterTest, DeferredGestureTapDownOnlyOnce) { 1331 // Set some sort of short deferral timeout 1332 set_maximum_tap_gap_time_ms(5); 1333 1334 SimulateGestureEvent(WebInputEvent::GestureTapDown, 1335 WebGestureEvent::Touchscreen); 1336 EXPECT_EQ(0U, process_->sink().message_count()); 1337 EXPECT_EQ(0U, GestureEventLastQueueEventSize()); 1338 1339 // Wait long enough for the timeout and verify it fired. 1340 base::MessageLoop::current()->PostDelayedTask( 1341 FROM_HERE, 1342 base::MessageLoop::QuitClosure(), 1343 TimeDelta::FromMilliseconds(10)); 1344 base::MessageLoop::current()->Run(); 1345 1346 EXPECT_EQ(1U, process_->sink().message_count()); 1347 EXPECT_EQ(1U, GestureEventLastQueueEventSize()); 1348 EXPECT_EQ(WebInputEvent::GestureTapDown, 1349 GestureEventLastQueueEvent().type); 1350 1351 // Now send the tap gesture and verify we didn't get an extra TapDown. 1352 SimulateGestureEvent(WebInputEvent::GestureTap, 1353 WebGestureEvent::Touchscreen); 1354 EXPECT_EQ(1U, process_->sink().message_count()); 1355 EXPECT_EQ(2U, GestureEventLastQueueEventSize()); 1356 EXPECT_EQ(WebInputEvent::GestureTap, 1357 GestureEventLastQueueEvent().type); 1358 } 1359 1360 // Test that scroll events during the deferral interval drop the GestureTapDown. 1361 TEST_F(ImmediateInputRouterTest, DeferredGestureTapDownAnulledOnScroll) { 1362 // Set some sort of short deferral timeout 1363 set_maximum_tap_gap_time_ms(5); 1364 1365 SimulateGestureEvent(WebInputEvent::GestureTapDown, 1366 WebGestureEvent::Touchscreen); 1367 EXPECT_EQ(0U, process_->sink().message_count()); 1368 EXPECT_EQ(0U, GestureEventLastQueueEventSize()); 1369 1370 SimulateGestureEvent(WebInputEvent::GestureScrollBegin, 1371 WebGestureEvent::Touchscreen); 1372 EXPECT_EQ(1U, process_->sink().message_count()); 1373 EXPECT_EQ(1U, GestureEventLastQueueEventSize()); 1374 EXPECT_EQ(WebInputEvent::GestureScrollBegin, 1375 GestureEventLastQueueEvent().type); 1376 1377 base::MessageLoop::current()->PostDelayedTask( 1378 FROM_HERE, 1379 base::MessageLoop::QuitClosure(), 1380 TimeDelta::FromMilliseconds(10)); 1381 base::MessageLoop::current()->Run(); 1382 1383 // If the deferral timer incorrectly fired, it will send an extra message. 1384 EXPECT_EQ(1U, process_->sink().message_count()); 1385 } 1386 1387 // Test that a tap cancel event during the deferral interval drops the 1388 // GestureTapDown. 1389 TEST_F(ImmediateInputRouterTest, DeferredGestureTapDownAnulledOnTapCancel) { 1390 // Set some sort of short deferral timeout 1391 set_maximum_tap_gap_time_ms(5); 1392 1393 SimulateGestureEvent(WebInputEvent::GestureTapDown, 1394 WebGestureEvent::Touchscreen); 1395 EXPECT_EQ(0U, process_->sink().message_count()); 1396 EXPECT_EQ(0U, GestureEventLastQueueEventSize()); 1397 1398 SimulateGestureEvent(WebInputEvent::GestureTapCancel, 1399 WebGestureEvent::Touchscreen); 1400 EXPECT_EQ(0U, process_->sink().message_count()); 1401 EXPECT_EQ(0U, GestureEventLastQueueEventSize()); 1402 1403 base::MessageLoop::current()->PostDelayedTask( 1404 FROM_HERE, 1405 base::MessageLoop::QuitClosure(), 1406 TimeDelta::FromMilliseconds(10)); 1407 base::MessageLoop::current()->Run(); 1408 1409 // If the deferral timer incorrectly fired, it will send an extra message. 1410 EXPECT_EQ(0U, process_->sink().message_count()); 1411 } 1412 1413 // Test that if a GestureTapDown gets sent, any corresponding GestureTapCancel 1414 // is also sent. 1415 TEST_F(ImmediateInputRouterTest, DeferredGestureTapDownTapCancel) { 1416 // Set some sort of short deferral timeout 1417 set_maximum_tap_gap_time_ms(5); 1418 1419 SimulateGestureEvent(WebInputEvent::GestureTapDown, 1420 WebGestureEvent::Touchscreen); 1421 EXPECT_EQ(0U, process_->sink().message_count()); 1422 EXPECT_EQ(0U, GestureEventLastQueueEventSize()); 1423 1424 base::MessageLoop::current()->PostDelayedTask( 1425 FROM_HERE, 1426 base::MessageLoop::QuitClosure(), 1427 TimeDelta::FromMilliseconds(10)); 1428 base::MessageLoop::current()->Run(); 1429 1430 EXPECT_EQ(1U, process_->sink().message_count()); 1431 EXPECT_EQ(1U, GestureEventLastQueueEventSize()); 1432 1433 SimulateGestureEvent(WebInputEvent::GestureTapCancel, 1434 WebGestureEvent::Touchscreen); 1435 EXPECT_EQ(1U, process_->sink().message_count()); 1436 EXPECT_EQ(2U, GestureEventLastQueueEventSize()); 1437 } 1438 1439 // Test that a GestureScrollEnd | GestureFlingStart are deferred during the 1440 // debounce interval, that Scrolls are not and that the deferred events are 1441 // sent after that timer fires. 1442 TEST_F(ImmediateInputRouterTest, DebounceDefersFollowingGestureEvents) { 1443 set_debounce_interval_time_ms(3); 1444 1445 SimulateGestureEvent(WebInputEvent::GestureScrollUpdate, 1446 WebGestureEvent::Touchscreen); 1447 EXPECT_EQ(1U, process_->sink().message_count()); 1448 EXPECT_EQ(1U, GestureEventLastQueueEventSize()); 1449 EXPECT_EQ(0U, GestureEventDebouncingQueueSize()); 1450 EXPECT_TRUE(ScrollingInProgress()); 1451 1452 SimulateGestureEvent(WebInputEvent::GestureScrollUpdate, 1453 WebGestureEvent::Touchscreen); 1454 EXPECT_EQ(1U, process_->sink().message_count()); 1455 EXPECT_EQ(2U, GestureEventLastQueueEventSize()); 1456 EXPECT_EQ(0U, GestureEventDebouncingQueueSize()); 1457 EXPECT_TRUE(ScrollingInProgress()); 1458 1459 SimulateGestureEvent(WebInputEvent::GestureScrollEnd, 1460 WebGestureEvent::Touchscreen); 1461 EXPECT_EQ(1U, process_->sink().message_count()); 1462 EXPECT_EQ(2U, GestureEventLastQueueEventSize()); 1463 EXPECT_EQ(1U, GestureEventDebouncingQueueSize()); 1464 1465 SimulateGestureFlingStartEvent(0, 10, WebGestureEvent::Touchscreen); 1466 EXPECT_EQ(1U, process_->sink().message_count()); 1467 EXPECT_EQ(2U, GestureEventLastQueueEventSize()); 1468 EXPECT_EQ(2U, GestureEventDebouncingQueueSize()); 1469 1470 SimulateGestureEvent(WebInputEvent::GestureTapDown, 1471 WebGestureEvent::Touchscreen); 1472 EXPECT_EQ(1U, process_->sink().message_count()); 1473 EXPECT_EQ(2U, GestureEventLastQueueEventSize()); 1474 EXPECT_EQ(3U, GestureEventDebouncingQueueSize()); 1475 1476 base::MessageLoop::current()->PostDelayedTask( 1477 FROM_HERE, 1478 base::MessageLoop::QuitClosure(), 1479 TimeDelta::FromMilliseconds(5)); 1480 base::MessageLoop::current()->Run(); 1481 1482 // The deferred events are correctly queued in coalescing queue. 1483 EXPECT_EQ(1U, process_->sink().message_count()); 1484 if (shouldDeferTapDownEvents()) 1485 // NOTE: The TapDown is still deferred hence not queued. 1486 EXPECT_EQ(4U, GestureEventLastQueueEventSize()); 1487 else 1488 EXPECT_EQ(5U, GestureEventLastQueueEventSize()); 1489 EXPECT_EQ(0U, GestureEventDebouncingQueueSize()); 1490 EXPECT_FALSE(ScrollingInProgress()); 1491 1492 // Verify that the coalescing queue contains the correct events. 1493 WebInputEvent::Type expected[] = { 1494 WebInputEvent::GestureScrollUpdate, 1495 WebInputEvent::GestureScrollUpdate, 1496 WebInputEvent::GestureScrollEnd, 1497 WebInputEvent::GestureFlingStart}; 1498 1499 for (unsigned i = 0; i < sizeof(expected) / sizeof(WebInputEvent::Type); 1500 i++) { 1501 WebGestureEvent merged_event = GestureEventQueueEventAt(i); 1502 EXPECT_EQ(expected[i], merged_event.type); 1503 } 1504 } 1505 1506 // Test that non-scroll events are deferred while scrolling during the debounce 1507 // interval and are discarded if a GestureScrollUpdate event arrives before the 1508 // interval end. 1509 TEST_F(ImmediateInputRouterTest, DebounceDropsDeferredEvents) { 1510 set_debounce_interval_time_ms(3); 1511 EXPECT_FALSE(ScrollingInProgress()); 1512 1513 SimulateGestureEvent(WebInputEvent::GestureScrollUpdate, 1514 WebGestureEvent::Touchscreen); 1515 EXPECT_EQ(1U, process_->sink().message_count()); 1516 EXPECT_EQ(1U, GestureEventLastQueueEventSize()); 1517 EXPECT_EQ(0U, GestureEventDebouncingQueueSize()); 1518 EXPECT_TRUE(ScrollingInProgress()); 1519 1520 // This event should get discarded. 1521 SimulateGestureEvent(WebInputEvent::GestureScrollEnd, 1522 WebGestureEvent::Touchscreen); 1523 EXPECT_EQ(1U, process_->sink().message_count()); 1524 EXPECT_EQ(1U, GestureEventLastQueueEventSize()); 1525 EXPECT_EQ(1U, GestureEventDebouncingQueueSize()); 1526 1527 SimulateGestureEvent(WebInputEvent::GestureScrollUpdate, 1528 WebGestureEvent::Touchscreen); 1529 EXPECT_EQ(1U, process_->sink().message_count()); 1530 EXPECT_EQ(2U, GestureEventLastQueueEventSize()); 1531 EXPECT_EQ(0U, GestureEventDebouncingQueueSize()); 1532 EXPECT_TRUE(ScrollingInProgress()); 1533 1534 // Verify that the coalescing queue contains the correct events. 1535 WebInputEvent::Type expected[] = { 1536 WebInputEvent::GestureScrollUpdate, 1537 WebInputEvent::GestureScrollUpdate}; 1538 1539 for (unsigned i = 0; i < sizeof(expected) / sizeof(WebInputEvent::Type); 1540 i++) { 1541 WebGestureEvent merged_event = GestureEventQueueEventAt(i); 1542 EXPECT_EQ(expected[i], merged_event.type); 1543 } 1544 } 1545 1546 // Tests that touch-events are queued properly. 1547 TEST_F(ImmediateInputRouterTest, TouchEventQueue) { 1548 PressTouchPoint(1, 1); 1549 SendTouchEvent(); 1550 client_->ExpectSendImmediatelyCalled(true); 1551 EXPECT_EQ(1U, process_->sink().message_count()); 1552 process_->sink().ClearMessages(); 1553 1554 // The second touch should not be sent since one is already in queue. 1555 MoveTouchPoint(0, 5, 5); 1556 SendTouchEvent(); 1557 client_->ExpectSendImmediatelyCalled(false); 1558 EXPECT_EQ(0U, process_->sink().message_count()); 1559 1560 EXPECT_EQ(2U, TouchEventQueueSize()); 1561 1562 // Receive an ACK for the first touch-event. 1563 SendInputEventACK(WebInputEvent::TouchStart, 1564 INPUT_EVENT_ACK_STATE_CONSUMED); 1565 EXPECT_EQ(1U, TouchEventQueueSize()); 1566 client_->ExpectAckCalled(1); 1567 EXPECT_EQ(WebInputEvent::TouchStart, 1568 client_->acked_touch_event().event.type); 1569 EXPECT_EQ(1U, process_->sink().message_count()); 1570 process_->sink().ClearMessages(); 1571 1572 SendInputEventACK(WebInputEvent::TouchMove, 1573 INPUT_EVENT_ACK_STATE_CONSUMED); 1574 EXPECT_EQ(0U, TouchEventQueueSize()); 1575 client_->ExpectAckCalled(1); 1576 EXPECT_EQ(WebInputEvent::TouchMove, 1577 client_->acked_touch_event().event.type); 1578 EXPECT_EQ(0U, process_->sink().message_count()); 1579 } 1580 1581 // Tests that the touch-queue is emptied if a page stops listening for touch 1582 // events. 1583 TEST_F(ImmediateInputRouterTest, TouchEventQueueFlush) { 1584 input_router_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, true)); 1585 EXPECT_TRUE(client_->has_touch_handler()); 1586 EXPECT_EQ(0U, process_->sink().message_count()); 1587 EXPECT_EQ(0U, TouchEventQueueSize()); 1588 1589 EXPECT_EQ(0U, TouchEventQueueSize()); 1590 EXPECT_TRUE(input_router_->ShouldForwardTouchEvent()); 1591 1592 // Send a touch-press event. 1593 PressTouchPoint(1, 1); 1594 SendTouchEvent(); 1595 EXPECT_EQ(1U, process_->sink().message_count()); 1596 process_->sink().ClearMessages(); 1597 1598 ReleaseTouchPoint(0); 1599 SendTouchEvent(); 1600 1601 for (int i = 5; i < 15; ++i) { 1602 PressTouchPoint(1, 1); 1603 SendTouchEvent(); 1604 MoveTouchPoint(0, i, i); 1605 SendTouchEvent(); 1606 ReleaseTouchPoint(0); 1607 SendTouchEvent(); 1608 } 1609 EXPECT_EQ(0U, process_->sink().message_count()); 1610 EXPECT_EQ(32U, TouchEventQueueSize()); 1611 1612 // Receive an ACK for the first touch-event. One of the queued touch-event 1613 // should be forwarded. 1614 SendInputEventACK(WebInputEvent::TouchStart, 1615 INPUT_EVENT_ACK_STATE_CONSUMED); 1616 EXPECT_EQ(31U, TouchEventQueueSize()); 1617 EXPECT_EQ(WebInputEvent::TouchStart, 1618 client_->acked_touch_event().event.type); 1619 client_->ExpectAckCalled(1); 1620 EXPECT_EQ(1U, process_->sink().message_count()); 1621 process_->sink().ClearMessages(); 1622 1623 // The page stops listening for touch-events. The touch-event queue should now 1624 // be emptied, but none of the queued touch-events should be sent to the 1625 // renderer. 1626 input_router_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, false)); 1627 EXPECT_FALSE(client_->has_touch_handler()); 1628 EXPECT_EQ(0U, process_->sink().message_count()); 1629 EXPECT_EQ(0U, TouchEventQueueSize()); 1630 EXPECT_FALSE(input_router_->ShouldForwardTouchEvent()); 1631 } 1632 1633 // Tests that touch-events are coalesced properly in the queue. 1634 TEST_F(ImmediateInputRouterTest, TouchEventQueueCoalesce) { 1635 input_router_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, true)); 1636 EXPECT_EQ(0U, process_->sink().message_count()); 1637 EXPECT_EQ(0U, TouchEventQueueSize()); 1638 EXPECT_TRUE(input_router_->ShouldForwardTouchEvent()); 1639 1640 // Send a touch-press event. 1641 PressTouchPoint(1, 1); 1642 SendTouchEvent(); 1643 client_->ExpectSendImmediatelyCalled(true); 1644 EXPECT_EQ(1U, process_->sink().message_count()); 1645 process_->sink().ClearMessages(); 1646 1647 // Send a few touch-move events, followed by a touch-release event. All the 1648 // touch-move events should be coalesced into a single event. 1649 for (int i = 5; i < 15; ++i) { 1650 MoveTouchPoint(0, i, i); 1651 SendTouchEvent(); 1652 } 1653 client_->ExpectSendImmediatelyCalled(false); 1654 ReleaseTouchPoint(0); 1655 SendTouchEvent(); 1656 EXPECT_EQ(0U, process_->sink().message_count()); 1657 EXPECT_EQ(3U, TouchEventQueueSize()); 1658 client_->ExpectSendImmediatelyCalled(false); 1659 1660 // ACK the press. 1661 SendInputEventACK(WebInputEvent::TouchStart, 1662 INPUT_EVENT_ACK_STATE_CONSUMED); 1663 EXPECT_EQ(1U, process_->sink().message_count()); 1664 EXPECT_EQ(2U, TouchEventQueueSize()); 1665 EXPECT_EQ(WebInputEvent::TouchStart, 1666 client_->acked_touch_event().event.type); 1667 client_->ExpectAckCalled(1); 1668 process_->sink().ClearMessages(); 1669 1670 // Coalesced touch-move events should be sent. 1671 client_->ExpectSendImmediatelyCalled(true); 1672 EXPECT_EQ(WebInputEvent::TouchMove, 1673 client_->immediately_sent_touch_event().event.type); 1674 1675 // ACK the moves. 1676 SendInputEventACK(WebInputEvent::TouchMove, 1677 INPUT_EVENT_ACK_STATE_CONSUMED); 1678 EXPECT_EQ(1U, process_->sink().message_count()); 1679 EXPECT_EQ(1U, TouchEventQueueSize()); 1680 EXPECT_EQ(WebInputEvent::TouchMove, 1681 client_->acked_touch_event().event.type); 1682 client_->ExpectAckCalled(10); 1683 process_->sink().ClearMessages(); 1684 1685 // ACK the release. 1686 SendInputEventACK(WebInputEvent::TouchEnd, 1687 INPUT_EVENT_ACK_STATE_CONSUMED); 1688 EXPECT_EQ(0U, process_->sink().message_count()); 1689 EXPECT_EQ(0U, TouchEventQueueSize()); 1690 EXPECT_EQ(WebInputEvent::TouchEnd, 1691 client_->acked_touch_event().event.type); 1692 client_->ExpectAckCalled(1); 1693 } 1694 1695 // Tests that an event that has already been sent but hasn't been ack'ed yet 1696 // doesn't get coalesced with newer events. 1697 TEST_F(ImmediateInputRouterTest, SentTouchEventDoesNotCoalesce) { 1698 input_router_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, true)); 1699 EXPECT_EQ(0U, process_->sink().message_count()); 1700 EXPECT_EQ(0U, TouchEventQueueSize()); 1701 EXPECT_TRUE(input_router_->ShouldForwardTouchEvent()); 1702 1703 // Send a touch-press event. 1704 PressTouchPoint(1, 1); 1705 SendTouchEvent(); 1706 EXPECT_EQ(1U, process_->sink().message_count()); 1707 process_->sink().ClearMessages(); 1708 1709 // Send a few touch-move events, followed by a touch-release event. All the 1710 // touch-move events should be coalesced into a single event. 1711 for (int i = 5; i < 15; ++i) { 1712 MoveTouchPoint(0, i, i); 1713 SendTouchEvent(); 1714 } 1715 EXPECT_EQ(0U, process_->sink().message_count()); 1716 EXPECT_EQ(2U, TouchEventQueueSize()); 1717 1718 SendInputEventACK(WebInputEvent::TouchStart, 1719 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 1720 EXPECT_EQ(1U, process_->sink().message_count()); 1721 EXPECT_EQ(1U, TouchEventQueueSize()); 1722 process_->sink().ClearMessages(); 1723 1724 // The coalesced touch-move event has been sent to the renderer. Any new 1725 // touch-move event should not be coalesced with the sent event. 1726 MoveTouchPoint(0, 5, 5); 1727 SendTouchEvent(); 1728 EXPECT_EQ(2U, TouchEventQueueSize()); 1729 1730 MoveTouchPoint(0, 7, 7); 1731 SendTouchEvent(); 1732 EXPECT_EQ(2U, TouchEventQueueSize()); 1733 } 1734 1735 // Tests that coalescing works correctly for multi-touch events. 1736 TEST_F(ImmediateInputRouterTest, TouchEventQueueMultiTouch) { 1737 input_router_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, true)); 1738 EXPECT_EQ(0U, process_->sink().message_count()); 1739 EXPECT_EQ(0U, TouchEventQueueSize()); 1740 EXPECT_TRUE(input_router_->ShouldForwardTouchEvent()); 1741 1742 // Press the first finger. 1743 PressTouchPoint(1, 1); 1744 SendTouchEvent(); 1745 EXPECT_EQ(1U, process_->sink().message_count()); 1746 process_->sink().ClearMessages(); 1747 1748 // Move the finger. 1749 MoveTouchPoint(0, 5, 5); 1750 SendTouchEvent(); 1751 EXPECT_EQ(2U, TouchEventQueueSize()); 1752 1753 // Now press a second finger. 1754 PressTouchPoint(2, 2); 1755 SendTouchEvent(); 1756 EXPECT_EQ(3U, TouchEventQueueSize()); 1757 1758 // Move both fingers. 1759 MoveTouchPoint(0, 10, 10); 1760 MoveTouchPoint(1, 20, 20); 1761 SendTouchEvent(); 1762 EXPECT_EQ(4U, TouchEventQueueSize()); 1763 1764 // Move only one finger now. 1765 MoveTouchPoint(0, 15, 15); 1766 SendTouchEvent(); 1767 EXPECT_EQ(4U, TouchEventQueueSize()); 1768 1769 // Move the other finger. 1770 MoveTouchPoint(1, 25, 25); 1771 SendTouchEvent(); 1772 EXPECT_EQ(4U, TouchEventQueueSize()); 1773 1774 // Make sure both fingers are marked as having been moved in the coalesced 1775 // event. 1776 const WebTouchEvent& event = latest_event(); 1777 EXPECT_EQ(WebTouchPoint::StateMoved, event.touches[0].state); 1778 EXPECT_EQ(WebTouchPoint::StateMoved, event.touches[1].state); 1779 } 1780 1781 // Tests that if a touch-event queue is destroyed in response to a touch-event 1782 // in the renderer, then there is no crash when the ACK for that touch-event 1783 // comes back. 1784 TEST_F(ImmediateInputRouterTest, TouchEventAckAfterQueueFlushed) { 1785 // First, install a touch-event handler and send some touch-events to the 1786 // renderer. 1787 input_router_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, true)); 1788 EXPECT_EQ(0U, process_->sink().message_count()); 1789 EXPECT_EQ(0U, TouchEventQueueSize()); 1790 EXPECT_TRUE(input_router_->ShouldForwardTouchEvent()); 1791 1792 PressTouchPoint(1, 1); 1793 SendTouchEvent(); 1794 EXPECT_EQ(1U, process_->sink().message_count()); 1795 EXPECT_EQ(1U, TouchEventQueueSize()); 1796 process_->sink().ClearMessages(); 1797 1798 MoveTouchPoint(0, 10, 10); 1799 SendTouchEvent(); 1800 EXPECT_EQ(0U, process_->sink().message_count()); 1801 EXPECT_EQ(2U, TouchEventQueueSize()); 1802 1803 // Receive an ACK for the press. This should cause the queued touch-move to 1804 // be sent to the renderer. 1805 SendInputEventACK(WebInputEvent::TouchStart, 1806 INPUT_EVENT_ACK_STATE_CONSUMED); 1807 EXPECT_EQ(1U, process_->sink().message_count()); 1808 EXPECT_EQ(1U, TouchEventQueueSize()); 1809 process_->sink().ClearMessages(); 1810 1811 // Uninstall the touch-event handler. This will cause the queue to be flushed. 1812 input_router_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, false)); 1813 EXPECT_EQ(0U, process_->sink().message_count()); 1814 EXPECT_EQ(0U, TouchEventQueueSize()); 1815 1816 // Now receive an ACK for the move. 1817 SendInputEventACK(WebInputEvent::TouchMove, 1818 INPUT_EVENT_ACK_STATE_CONSUMED); 1819 EXPECT_EQ(0U, process_->sink().message_count()); 1820 EXPECT_EQ(0U, TouchEventQueueSize()); 1821 } 1822 1823 // Tests that touch-move events are not sent to the renderer if the preceding 1824 // touch-press event did not have a consumer (and consequently, did not hit the 1825 // main thread in the renderer). Also tests that all queued/coalesced touch 1826 // events are flushed immediately when the ACK for the touch-press comes back 1827 // with NO_CONSUMER status. 1828 TEST_F(ImmediateInputRouterTest, TouchEventQueueNoConsumer) { 1829 // The first touch-press should reach the renderer. 1830 PressTouchPoint(1, 1); 1831 SendTouchEvent(); 1832 EXPECT_EQ(1U, process_->sink().message_count()); 1833 process_->sink().ClearMessages(); 1834 1835 // The second touch should not be sent since one is already in queue. 1836 MoveTouchPoint(0, 5, 5); 1837 SendTouchEvent(); 1838 EXPECT_EQ(0U, process_->sink().message_count()); 1839 EXPECT_EQ(2U, TouchEventQueueSize()); 1840 1841 // Receive an ACK for the first touch-event. This should release the queued 1842 // touch-event, but it should not be sent to the renderer. 1843 SendInputEventACK(WebInputEvent::TouchStart, 1844 INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS); 1845 EXPECT_EQ(0U, TouchEventQueueSize()); 1846 EXPECT_EQ(WebInputEvent::TouchMove, 1847 client_->acked_touch_event().event.type); 1848 client_->ExpectAckCalled(2); 1849 EXPECT_EQ(0U, process_->sink().message_count()); 1850 process_->sink().ClearMessages(); 1851 1852 // Send a release event. This should not reach the renderer. 1853 ReleaseTouchPoint(0); 1854 SendTouchEvent(); 1855 EXPECT_EQ(0U, process_->sink().message_count()); 1856 EXPECT_EQ(WebInputEvent::TouchEnd, 1857 client_->acked_touch_event().event.type); 1858 client_->ExpectAckCalled(1); 1859 1860 // Send a press-event, followed by move and release events, and another press 1861 // event, before the ACK for the first press event comes back. All of the 1862 // events should be queued first. After the NO_CONSUMER ack for the first 1863 // touch-press, all events upto the second touch-press should be flushed. 1864 PressTouchPoint(10, 10); 1865 SendTouchEvent(); 1866 EXPECT_EQ(1U, process_->sink().message_count()); 1867 process_->sink().ClearMessages(); 1868 1869 MoveTouchPoint(0, 5, 5); 1870 SendTouchEvent(); 1871 MoveTouchPoint(0, 6, 5); 1872 SendTouchEvent(); 1873 ReleaseTouchPoint(0); 1874 SendTouchEvent(); 1875 1876 PressTouchPoint(6, 5); 1877 SendTouchEvent(); 1878 EXPECT_EQ(0U, process_->sink().message_count()); 1879 // The queue should hold the first sent touch-press event, the coalesced 1880 // touch-move event, the touch-end event and the second touch-press event. 1881 EXPECT_EQ(4U, TouchEventQueueSize()); 1882 1883 SendInputEventACK(WebInputEvent::TouchStart, 1884 INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS); 1885 EXPECT_EQ(1U, process_->sink().message_count()); 1886 EXPECT_EQ(WebInputEvent::TouchEnd, client_->acked_touch_event().event.type); 1887 client_->ExpectAckCalled(4); 1888 EXPECT_EQ(1U, TouchEventQueueSize()); 1889 process_->sink().ClearMessages(); 1890 1891 // ACK the second press event as NO_CONSUMER too. 1892 SendInputEventACK(WebInputEvent::TouchStart, 1893 INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS); 1894 EXPECT_EQ(0U, process_->sink().message_count()); 1895 EXPECT_EQ(WebInputEvent::TouchStart, client_->acked_touch_event().event.type); 1896 client_->ExpectAckCalled(1); 1897 EXPECT_EQ(0U, TouchEventQueueSize()); 1898 1899 // Send a second press event. Even though the first touch had NO_CONSUMER, 1900 // this press event should reach the renderer. 1901 PressTouchPoint(1, 1); 1902 SendTouchEvent(); 1903 EXPECT_EQ(1U, process_->sink().message_count()); 1904 EXPECT_EQ(1U, TouchEventQueueSize()); 1905 } 1906 1907 TEST_F(ImmediateInputRouterTest, TouchEventQueueConsumerIgnoreMultiFinger) { 1908 // Press two touch points and move them around a bit. The renderer consumes 1909 // the events for the first touch point, but returns NO_CONSUMER_EXISTS for 1910 // the second touch point. 1911 1912 PressTouchPoint(1, 1); 1913 SendTouchEvent(); 1914 EXPECT_EQ(1U, process_->sink().message_count()); 1915 process_->sink().ClearMessages(); 1916 1917 MoveTouchPoint(0, 5, 5); 1918 SendTouchEvent(); 1919 1920 PressTouchPoint(10, 10); 1921 SendTouchEvent(); 1922 1923 MoveTouchPoint(0, 2, 2); 1924 SendTouchEvent(); 1925 1926 MoveTouchPoint(1, 4, 10); 1927 SendTouchEvent(); 1928 1929 MoveTouchPoint(0, 10, 10); 1930 MoveTouchPoint(1, 20, 20); 1931 SendTouchEvent(); 1932 1933 // Since the first touch-press is still pending ACK, no other event should 1934 // have been sent to the renderer. 1935 EXPECT_EQ(0U, process_->sink().message_count()); 1936 // The queue includes the two presses, the first touch-move of the first 1937 // point, and a coalesced touch-move of both points. 1938 EXPECT_EQ(4U, TouchEventQueueSize()); 1939 1940 // ACK the first press as CONSUMED. This should cause the first touch-move of 1941 // the first touch-point to be dispatched. 1942 SendInputEventACK(WebInputEvent::TouchStart, 1943 INPUT_EVENT_ACK_STATE_CONSUMED); 1944 EXPECT_EQ(1U, process_->sink().message_count()); 1945 process_->sink().ClearMessages(); 1946 EXPECT_EQ(3U, TouchEventQueueSize()); 1947 1948 // ACK the first move as CONSUMED. 1949 SendInputEventACK(WebInputEvent::TouchMove, 1950 INPUT_EVENT_ACK_STATE_CONSUMED); 1951 EXPECT_EQ(1U, process_->sink().message_count()); 1952 process_->sink().ClearMessages(); 1953 EXPECT_EQ(2U, TouchEventQueueSize()); 1954 1955 // ACK the second press as NO_CONSUMER_EXISTS. This will dequeue the coalesced 1956 // touch-move event (which contains both touch points). Although the second 1957 // touch-point does not need to be sent to the renderer, the first touch-point 1958 // did move, and so the coalesced touch-event will be sent to the renderer. 1959 SendInputEventACK(WebInputEvent::TouchStart, 1960 INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS); 1961 EXPECT_EQ(1U, process_->sink().message_count()); 1962 process_->sink().ClearMessages(); 1963 EXPECT_EQ(1U, TouchEventQueueSize()); 1964 1965 // ACK the coalesced move as NOT_CONSUMED. 1966 SendInputEventACK(WebInputEvent::TouchMove, 1967 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 1968 EXPECT_EQ(0U, process_->sink().message_count()); 1969 EXPECT_EQ(0U, TouchEventQueueSize()); 1970 1971 // Move just the second touch point. Because the first touch point did not 1972 // move, this event should not reach the renderer. 1973 MoveTouchPoint(1, 30, 30); 1974 SendTouchEvent(); 1975 EXPECT_EQ(0U, process_->sink().message_count()); 1976 EXPECT_EQ(0U, TouchEventQueueSize()); 1977 1978 // Move just the first touch point. This should reach the renderer. 1979 MoveTouchPoint(0, 10, 10); 1980 SendTouchEvent(); 1981 EXPECT_EQ(1U, process_->sink().message_count()); 1982 EXPECT_EQ(1U, TouchEventQueueSize()); 1983 process_->sink().ClearMessages(); 1984 1985 // Move both fingers. This event should reach the renderer (after the ACK of 1986 // the previous move event is received), because the first touch point did 1987 // move. 1988 MoveTouchPoint(0, 15, 15); 1989 MoveTouchPoint(1, 25, 25); 1990 SendTouchEvent(); 1991 EXPECT_EQ(0U, process_->sink().message_count()); 1992 1993 SendInputEventACK(WebInputEvent::TouchMove, 1994 INPUT_EVENT_ACK_STATE_CONSUMED); 1995 EXPECT_EQ(1U, process_->sink().message_count()); 1996 EXPECT_EQ(1U, TouchEventQueueSize()); 1997 process_->sink().ClearMessages(); 1998 1999 SendInputEventACK(WebInputEvent::TouchMove, 2000 INPUT_EVENT_ACK_STATE_CONSUMED); 2001 EXPECT_EQ(0U, process_->sink().message_count()); 2002 EXPECT_EQ(0U, TouchEventQueueSize()); 2003 2004 // Release the first finger. Then move the second finger around some, then 2005 // press another finger. Once the release event is ACKed, the move events of 2006 // the second finger should be immediately released to the view, and the 2007 // touch-press event should be dispatched to the renderer. 2008 ReleaseTouchPoint(0); 2009 SendTouchEvent(); 2010 EXPECT_EQ(1U, process_->sink().message_count()); 2011 EXPECT_EQ(1U, TouchEventQueueSize()); 2012 process_->sink().ClearMessages(); 2013 2014 MoveTouchPoint(1, 40, 40); 2015 SendTouchEvent(); 2016 2017 MoveTouchPoint(1, 50, 50); 2018 SendTouchEvent(); 2019 2020 PressTouchPoint(1, 1); 2021 SendTouchEvent(); 2022 2023 MoveTouchPoint(1, 30, 30); 2024 SendTouchEvent(); 2025 EXPECT_EQ(0U, process_->sink().message_count()); 2026 EXPECT_EQ(4U, TouchEventQueueSize()); 2027 2028 SendInputEventACK(WebInputEvent::TouchEnd, 2029 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 2030 EXPECT_EQ(1U, process_->sink().message_count()); 2031 EXPECT_EQ(2U, TouchEventQueueSize()); 2032 EXPECT_EQ(WebInputEvent::TouchMove, 2033 client_->acked_touch_event().event.type); 2034 process_->sink().ClearMessages(); 2035 2036 // ACK the press with NO_CONSUMED_EXISTS. This should release the queued 2037 // touch-move events to the view. 2038 SendInputEventACK(WebInputEvent::TouchStart, 2039 INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS); 2040 EXPECT_EQ(0U, process_->sink().message_count()); 2041 EXPECT_EQ(0U, TouchEventQueueSize()); 2042 EXPECT_EQ(WebInputEvent::TouchMove, 2043 client_->acked_touch_event().event.type); 2044 2045 ReleaseTouchPoint(2); 2046 ReleaseTouchPoint(1); 2047 EXPECT_EQ(0U, process_->sink().message_count()); 2048 EXPECT_EQ(0U, TouchEventQueueSize()); 2049 } 2050 2051 #if defined(OS_WIN) || defined(USE_AURA) 2052 // Tests that the acked events have correct state. (ui::Events are used only on 2053 // windows and aura) 2054 TEST_F(ImmediateInputRouterTest, AckedTouchEventState) { 2055 input_router_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, true)); 2056 EXPECT_EQ(0U, process_->sink().message_count()); 2057 EXPECT_EQ(0U, TouchEventQueueSize()); 2058 EXPECT_TRUE(input_router_->ShouldForwardTouchEvent()); 2059 2060 // Send a bunch of events, and make sure the ACKed events are correct. 2061 ScopedVector<ui::TouchEvent> expected_events; 2062 2063 // Use a custom timestamp for all the events to test that the acked events 2064 // have the same timestamp; 2065 base::TimeDelta timestamp = base::Time::NowFromSystemTime() - base::Time(); 2066 timestamp -= base::TimeDelta::FromSeconds(600); 2067 2068 // Press the first finger. 2069 PressTouchPoint(1, 1); 2070 SetTouchTimestamp(timestamp); 2071 SendTouchEvent(); 2072 EXPECT_EQ(1U, process_->sink().message_count()); 2073 process_->sink().ClearMessages(); 2074 expected_events.push_back(new ui::TouchEvent(ui::ET_TOUCH_PRESSED, 2075 gfx::Point(1, 1), 0, timestamp)); 2076 2077 // Move the finger. 2078 timestamp += base::TimeDelta::FromSeconds(10); 2079 MoveTouchPoint(0, 5, 5); 2080 SetTouchTimestamp(timestamp); 2081 SendTouchEvent(); 2082 EXPECT_EQ(2U, TouchEventQueueSize()); 2083 expected_events.push_back(new ui::TouchEvent(ui::ET_TOUCH_MOVED, 2084 gfx::Point(5, 5), 0, timestamp)); 2085 2086 // Now press a second finger. 2087 timestamp += base::TimeDelta::FromSeconds(10); 2088 PressTouchPoint(2, 2); 2089 SetTouchTimestamp(timestamp); 2090 SendTouchEvent(); 2091 EXPECT_EQ(3U, TouchEventQueueSize()); 2092 expected_events.push_back(new ui::TouchEvent(ui::ET_TOUCH_PRESSED, 2093 gfx::Point(2, 2), 1, timestamp)); 2094 2095 // Move both fingers. 2096 timestamp += base::TimeDelta::FromSeconds(10); 2097 MoveTouchPoint(0, 10, 10); 2098 MoveTouchPoint(1, 20, 20); 2099 SetTouchTimestamp(timestamp); 2100 SendTouchEvent(); 2101 EXPECT_EQ(4U, TouchEventQueueSize()); 2102 expected_events.push_back(new ui::TouchEvent(ui::ET_TOUCH_MOVED, 2103 gfx::Point(10, 10), 0, timestamp)); 2104 expected_events.push_back(new ui::TouchEvent(ui::ET_TOUCH_MOVED, 2105 gfx::Point(20, 20), 1, timestamp)); 2106 2107 // Receive the ACKs and make sure the generated events from the acked events 2108 // are correct. 2109 WebInputEvent::Type acks[] = { WebInputEvent::TouchStart, 2110 WebInputEvent::TouchMove, 2111 WebInputEvent::TouchStart, 2112 WebInputEvent::TouchMove }; 2113 2114 TouchEventCoordinateSystem coordinate_system = LOCAL_COORDINATES; 2115 #if !defined(OS_WIN) 2116 coordinate_system = SCREEN_COORDINATES; 2117 #endif 2118 for (size_t i = 0; i < arraysize(acks); ++i) { 2119 SendInputEventACK(acks[i], 2120 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 2121 EXPECT_EQ(acks[i], client_->acked_touch_event().event.type); 2122 ScopedVector<ui::TouchEvent> acked; 2123 2124 MakeUITouchEventsFromWebTouchEvents( 2125 client_->acked_touch_event(), &acked, coordinate_system); 2126 bool success = EventListIsSubset(acked, expected_events); 2127 EXPECT_TRUE(success) << "Failed on step: " << i; 2128 if (!success) 2129 break; 2130 expected_events.erase(expected_events.begin(), 2131 expected_events.begin() + acked.size()); 2132 } 2133 2134 EXPECT_EQ(0U, expected_events.size()); 2135 } 2136 #endif // defined(OS_WIN) || defined(USE_AURA) 2137 2138 TEST_F(ImmediateInputRouterTest, UnhandledWheelEvent) { 2139 // Simulate wheel events. 2140 SimulateWheelEvent(0, -5, 0, false); // sent directly 2141 SimulateWheelEvent(0, -10, 0, false); // enqueued 2142 2143 // Check that only the first event was sent. 2144 EXPECT_EQ(1U, process_->sink().message_count()); 2145 EXPECT_TRUE(process_->sink().GetUniqueMessageMatching( 2146 InputMsg_HandleInputEvent::ID)); 2147 process_->sink().ClearMessages(); 2148 2149 // Indicate that the wheel event was unhandled. 2150 SendInputEventACK(WebInputEvent::MouseWheel, 2151 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 2152 2153 // Check that the correct unhandled wheel event was received. 2154 client_->ExpectAckCalled(1); 2155 EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, client_->ack_state()); 2156 EXPECT_EQ(client_->acked_wheel_event().deltaY, -5); 2157 2158 // Check that the second event was sent. 2159 EXPECT_EQ(1U, process_->sink().message_count()); 2160 EXPECT_TRUE(process_->sink().GetUniqueMessageMatching( 2161 InputMsg_HandleInputEvent::ID)); 2162 process_->sink().ClearMessages(); 2163 2164 // Check that the correct unhandled wheel event was received. 2165 EXPECT_EQ(client_->acked_wheel_event().deltaY, -5); 2166 } 2167 2168 } // namespace content 2169