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 <math.h> 6 7#include "base/basictypes.h" 8#include "base/command_line.h" 9#include "base/memory/scoped_ptr.h" 10#include "base/strings/utf_string_conversions.h" 11#include "content/browser/renderer_host/input/gesture_event_queue.h" 12#include "content/browser/renderer_host/input/input_router_client.h" 13#include "content/browser/renderer_host/input/input_router_impl.h" 14#include "content/browser/renderer_host/input/mock_input_ack_handler.h" 15#include "content/browser/renderer_host/input/mock_input_router_client.h" 16#include "content/common/content_constants_internal.h" 17#include "content/common/edit_command.h" 18#include "content/common/input/synthetic_web_input_event_builders.h" 19#include "content/common/input/touch_action.h" 20#include "content/common/input/web_input_event_traits.h" 21#include "content/common/input_messages.h" 22#include "content/common/view_messages.h" 23#include "content/public/common/content_switches.h" 24#include "content/public/test/mock_render_process_host.h" 25#include "content/public/test/test_browser_context.h" 26#include "testing/gtest/include/gtest/gtest.h" 27#include "ui/events/keycodes/keyboard_codes.h" 28 29#if defined(USE_AURA) 30#include "content/browser/renderer_host/ui_events_helper.h" 31#include "ui/events/event.h" 32#endif 33 34using base::TimeDelta; 35using blink::WebGestureDevice; 36using blink::WebGestureEvent; 37using blink::WebKeyboardEvent; 38using blink::WebInputEvent; 39using blink::WebMouseEvent; 40using blink::WebMouseWheelEvent; 41using blink::WebTouchEvent; 42using blink::WebTouchPoint; 43 44namespace content { 45 46namespace { 47 48const WebInputEvent* GetInputEventFromMessage(const IPC::Message& message) { 49 PickleIterator iter(message); 50 const char* data; 51 int data_length; 52 if (!message.ReadData(&iter, &data, &data_length)) 53 return NULL; 54 return reinterpret_cast<const WebInputEvent*>(data); 55} 56 57WebInputEvent& GetEventWithType(WebInputEvent::Type type) { 58 WebInputEvent* event = NULL; 59 if (WebInputEvent::isMouseEventType(type)) { 60 static WebMouseEvent mouse; 61 event = &mouse; 62 } else if (WebInputEvent::isTouchEventType(type)) { 63 static WebTouchEvent touch; 64 event = &touch; 65 } else if (WebInputEvent::isKeyboardEventType(type)) { 66 static WebKeyboardEvent key; 67 event = &key; 68 } else if (WebInputEvent::isGestureEventType(type)) { 69 static WebGestureEvent gesture; 70 event = &gesture; 71 } else if (type == WebInputEvent::MouseWheel) { 72 static WebMouseWheelEvent wheel; 73 event = &wheel; 74 } 75 CHECK(event); 76 event->type = type; 77 return *event; 78} 79 80bool GetIsShortcutFromHandleInputEventMessage(const IPC::Message* msg) { 81 InputMsg_HandleInputEvent::Schema::Param param; 82 InputMsg_HandleInputEvent::Read(msg, ¶m); 83 return param.c; 84} 85 86template<typename MSG_T, typename ARG_T1> 87void ExpectIPCMessageWithArg1(const IPC::Message* msg, const ARG_T1& arg1) { 88 ASSERT_EQ(MSG_T::ID, msg->type()); 89 typename MSG_T::Schema::Param param; 90 ASSERT_TRUE(MSG_T::Read(msg, ¶m)); 91 EXPECT_EQ(arg1, param.a); 92} 93 94template<typename MSG_T, typename ARG_T1, typename ARG_T2> 95void ExpectIPCMessageWithArg2(const IPC::Message* msg, 96 const ARG_T1& arg1, 97 const ARG_T2& arg2) { 98 ASSERT_EQ(MSG_T::ID, msg->type()); 99 typename MSG_T::Schema::Param param; 100 ASSERT_TRUE(MSG_T::Read(msg, ¶m)); 101 EXPECT_EQ(arg1, param.a); 102 EXPECT_EQ(arg2, param.b); 103} 104 105#if defined(USE_AURA) 106bool TouchEventsAreEquivalent(const ui::TouchEvent& first, 107 const ui::TouchEvent& second) { 108 if (first.type() != second.type()) 109 return false; 110 if (first.location() != second.location()) 111 return false; 112 if (first.touch_id() != second.touch_id()) 113 return false; 114 if (second.time_stamp().InSeconds() != first.time_stamp().InSeconds()) 115 return false; 116 return true; 117} 118 119bool EventListIsSubset(const ScopedVector<ui::TouchEvent>& subset, 120 const ScopedVector<ui::TouchEvent>& set) { 121 if (subset.size() > set.size()) 122 return false; 123 for (size_t i = 0; i < subset.size(); ++i) { 124 const ui::TouchEvent* first = subset[i]; 125 const ui::TouchEvent* second = set[i]; 126 bool equivalent = TouchEventsAreEquivalent(*first, *second); 127 if (!equivalent) 128 return false; 129 } 130 131 return true; 132} 133#endif // defined(USE_AURA) 134 135// Expected function used for converting pinch scales to deltaY values. 136float PinchScaleToWheelDelta(float scale) { 137 return 100.0 * log(scale); 138} 139 140} // namespace 141 142class InputRouterImplTest : public testing::Test { 143 public: 144 InputRouterImplTest() {} 145 virtual ~InputRouterImplTest() {} 146 147 protected: 148 // testing::Test 149 virtual void SetUp() OVERRIDE { 150 browser_context_.reset(new TestBrowserContext()); 151 process_.reset(new MockRenderProcessHost(browser_context_.get())); 152 client_.reset(new MockInputRouterClient()); 153 ack_handler_.reset(new MockInputAckHandler()); 154 base::CommandLine* command_line = base::CommandLine::ForCurrentProcess(); 155 command_line->AppendSwitch(switches::kValidateInputEventStream); 156 input_router_.reset(new InputRouterImpl(process_.get(), 157 client_.get(), 158 ack_handler_.get(), 159 MSG_ROUTING_NONE, 160 config_)); 161 client_->set_input_router(input_router()); 162 ack_handler_->set_input_router(input_router()); 163 } 164 165 virtual void TearDown() OVERRIDE { 166 // Process all pending tasks to avoid leaks. 167 base::MessageLoop::current()->RunUntilIdle(); 168 169 input_router_.reset(); 170 client_.reset(); 171 process_.reset(); 172 browser_context_.reset(); 173 } 174 175 void SetUpForTouchAckTimeoutTest(int timeout_ms) { 176 config_.touch_config.touch_ack_timeout_delay = 177 base::TimeDelta::FromMilliseconds(timeout_ms); 178 config_.touch_config.touch_ack_timeout_supported = true; 179 TearDown(); 180 SetUp(); 181 } 182 183 void SimulateKeyboardEvent(WebInputEvent::Type type, bool is_shortcut) { 184 WebKeyboardEvent event = SyntheticWebKeyboardEventBuilder::Build(type); 185 NativeWebKeyboardEvent native_event; 186 memcpy(&native_event, &event, sizeof(event)); 187 input_router_->SendKeyboardEvent( 188 native_event, 189 ui::LatencyInfo(), 190 is_shortcut); 191 } 192 193 void SimulateWheelEvent(float dX, float dY, int modifiers, bool precise) { 194 input_router_->SendWheelEvent(MouseWheelEventWithLatencyInfo( 195 SyntheticWebMouseWheelEventBuilder::Build(dX, dY, modifiers, precise), 196 ui::LatencyInfo())); 197 } 198 199 void SimulateMouseEvent(WebInputEvent::Type type, int x, int y) { 200 input_router_->SendMouseEvent(MouseEventWithLatencyInfo( 201 SyntheticWebMouseEventBuilder::Build(type, x, y, 0), 202 ui::LatencyInfo())); 203 } 204 205 void SimulateWheelEventWithPhase(WebMouseWheelEvent::Phase phase) { 206 input_router_->SendWheelEvent(MouseWheelEventWithLatencyInfo( 207 SyntheticWebMouseWheelEventBuilder::Build(phase), ui::LatencyInfo())); 208 } 209 210 void SimulateGestureEvent(const WebGestureEvent& gesture) { 211 input_router_->SendGestureEvent( 212 GestureEventWithLatencyInfo(gesture, ui::LatencyInfo())); 213 } 214 215 void SimulateGestureEvent(WebInputEvent::Type type, 216 WebGestureDevice sourceDevice) { 217 SimulateGestureEvent( 218 SyntheticWebGestureEventBuilder::Build(type, sourceDevice)); 219 } 220 221 void SimulateGestureScrollUpdateEvent(float dX, float dY, int modifiers) { 222 SimulateGestureEvent( 223 SyntheticWebGestureEventBuilder::BuildScrollUpdate(dX, dY, modifiers)); 224 } 225 226 void SimulateGesturePinchUpdateEvent(float scale, 227 float anchorX, 228 float anchorY, 229 int modifiers, 230 WebGestureDevice sourceDevice) { 231 SimulateGestureEvent(SyntheticWebGestureEventBuilder::BuildPinchUpdate( 232 scale, anchorX, anchorY, modifiers, sourceDevice)); 233 } 234 235 void SimulateGestureFlingStartEvent(float velocityX, 236 float velocityY, 237 WebGestureDevice sourceDevice) { 238 SimulateGestureEvent( 239 SyntheticWebGestureEventBuilder::BuildFling(velocityX, 240 velocityY, 241 sourceDevice)); 242 } 243 244 void SetTouchTimestamp(base::TimeDelta timestamp) { 245 touch_event_.SetTimestamp(timestamp); 246 } 247 248 void SendTouchEvent() { 249 input_router_->SendTouchEvent( 250 TouchEventWithLatencyInfo(touch_event_, ui::LatencyInfo())); 251 touch_event_.ResetPoints(); 252 } 253 254 int PressTouchPoint(int x, int y) { 255 return touch_event_.PressPoint(x, y); 256 } 257 258 void MoveTouchPoint(int index, int x, int y) { 259 touch_event_.MovePoint(index, x, y); 260 } 261 262 void ReleaseTouchPoint(int index) { 263 touch_event_.ReleasePoint(index); 264 } 265 266 void CancelTouchPoint(int index) { 267 touch_event_.CancelPoint(index); 268 } 269 270 void SendInputEventACK(blink::WebInputEvent::Type type, 271 InputEventAckState ack_result) { 272 InputHostMsg_HandleInputEvent_ACK_Params ack; 273 ack.type = type; 274 ack.state = ack_result; 275 input_router_->OnMessageReceived(InputHostMsg_HandleInputEvent_ACK(0, ack)); 276 } 277 278 InputRouterImpl* input_router() const { 279 return input_router_.get(); 280 } 281 282 bool TouchEventQueueEmpty() const { 283 return input_router()->touch_event_queue_.empty(); 284 } 285 286 bool TouchEventTimeoutEnabled() const { 287 return input_router()->touch_event_queue_.IsAckTimeoutEnabled(); 288 } 289 290 void Flush() const { 291 return input_router_->Flush(); 292 } 293 294 size_t GetAndResetDidFlushCount() { 295 return client_->GetAndResetDidFlushCount(); 296 } 297 298 bool HasPendingEvents() const { 299 return input_router_->HasPendingEvents(); 300 } 301 302 void OnHasTouchEventHandlers(bool has_handlers) { 303 input_router_->OnMessageReceived( 304 ViewHostMsg_HasTouchEventHandlers(0, has_handlers)); 305 } 306 307 void OnSetTouchAction(content::TouchAction touch_action) { 308 input_router_->OnMessageReceived( 309 InputHostMsg_SetTouchAction(0, touch_action)); 310 } 311 312 size_t GetSentMessageCountAndResetSink() { 313 size_t count = process_->sink().message_count(); 314 process_->sink().ClearMessages(); 315 return count; 316 } 317 318 static void RunTasksAndWait(base::TimeDelta delay) { 319 base::MessageLoop::current()->PostDelayedTask( 320 FROM_HERE, base::MessageLoop::QuitClosure(), delay); 321 base::MessageLoop::current()->Run(); 322 } 323 324 InputRouterImpl::Config config_; 325 scoped_ptr<MockRenderProcessHost> process_; 326 scoped_ptr<MockInputRouterClient> client_; 327 scoped_ptr<MockInputAckHandler> ack_handler_; 328 scoped_ptr<InputRouterImpl> input_router_; 329 330 private: 331 base::MessageLoopForUI message_loop_; 332 SyntheticWebTouchEvent touch_event_; 333 334 scoped_ptr<TestBrowserContext> browser_context_; 335}; 336 337TEST_F(InputRouterImplTest, CoalescesRangeSelection) { 338 input_router_->SendInput(scoped_ptr<IPC::Message>( 339 new InputMsg_SelectRange(0, gfx::Point(1, 2), gfx::Point(3, 4)))); 340 ExpectIPCMessageWithArg2<InputMsg_SelectRange>( 341 process_->sink().GetMessageAt(0), 342 gfx::Point(1, 2), 343 gfx::Point(3, 4)); 344 EXPECT_EQ(1u, GetSentMessageCountAndResetSink()); 345 346 // Send two more messages without acking. 347 input_router_->SendInput(scoped_ptr<IPC::Message>( 348 new InputMsg_SelectRange(0, gfx::Point(5, 6), gfx::Point(7, 8)))); 349 EXPECT_EQ(0u, GetSentMessageCountAndResetSink()); 350 351 input_router_->SendInput(scoped_ptr<IPC::Message>( 352 new InputMsg_SelectRange(0, gfx::Point(9, 10), gfx::Point(11, 12)))); 353 EXPECT_EQ(0u, GetSentMessageCountAndResetSink()); 354 355 // Now ack the first message. 356 { 357 scoped_ptr<IPC::Message> response(new ViewHostMsg_SelectRange_ACK(0)); 358 input_router_->OnMessageReceived(*response); 359 } 360 361 // Verify that the two messages are coalesced into one message. 362 ExpectIPCMessageWithArg2<InputMsg_SelectRange>( 363 process_->sink().GetMessageAt(0), 364 gfx::Point(9, 10), 365 gfx::Point(11, 12)); 366 EXPECT_EQ(1u, GetSentMessageCountAndResetSink()); 367 368 // Acking the coalesced msg should not send any more msg. 369 { 370 scoped_ptr<IPC::Message> response(new ViewHostMsg_SelectRange_ACK(0)); 371 input_router_->OnMessageReceived(*response); 372 } 373 EXPECT_EQ(0u, GetSentMessageCountAndResetSink()); 374} 375 376TEST_F(InputRouterImplTest, CoalescesCaretMove) { 377 input_router_->SendInput( 378 scoped_ptr<IPC::Message>(new InputMsg_MoveCaret(0, gfx::Point(1, 2)))); 379 ExpectIPCMessageWithArg1<InputMsg_MoveCaret>( 380 process_->sink().GetMessageAt(0), gfx::Point(1, 2)); 381 EXPECT_EQ(1u, GetSentMessageCountAndResetSink()); 382 383 // Send two more messages without acking. 384 input_router_->SendInput( 385 scoped_ptr<IPC::Message>(new InputMsg_MoveCaret(0, gfx::Point(5, 6)))); 386 EXPECT_EQ(0u, GetSentMessageCountAndResetSink()); 387 388 input_router_->SendInput( 389 scoped_ptr<IPC::Message>(new InputMsg_MoveCaret(0, gfx::Point(9, 10)))); 390 EXPECT_EQ(0u, GetSentMessageCountAndResetSink()); 391 392 // Now ack the first message. 393 { 394 scoped_ptr<IPC::Message> response(new ViewHostMsg_MoveCaret_ACK(0)); 395 input_router_->OnMessageReceived(*response); 396 } 397 398 // Verify that the two messages are coalesced into one message. 399 ExpectIPCMessageWithArg1<InputMsg_MoveCaret>( 400 process_->sink().GetMessageAt(0), gfx::Point(9, 10)); 401 EXPECT_EQ(1u, GetSentMessageCountAndResetSink()); 402 403 // Acking the coalesced msg should not send any more msg. 404 { 405 scoped_ptr<IPC::Message> response(new ViewHostMsg_MoveCaret_ACK(0)); 406 input_router_->OnMessageReceived(*response); 407 } 408 EXPECT_EQ(0u, GetSentMessageCountAndResetSink()); 409} 410 411TEST_F(InputRouterImplTest, HandledInputEvent) { 412 client_->set_filter_state(INPUT_EVENT_ACK_STATE_CONSUMED); 413 414 // Simulate a keyboard event. 415 SimulateKeyboardEvent(WebInputEvent::RawKeyDown, false); 416 417 // Make sure no input event is sent to the renderer. 418 EXPECT_EQ(0u, GetSentMessageCountAndResetSink()); 419 420 // OnKeyboardEventAck should be triggered without actual ack. 421 EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount()); 422 423 // As the event was acked already, keyboard event queue should be 424 // empty. 425 ASSERT_EQ(NULL, input_router_->GetLastKeyboardEvent()); 426} 427 428TEST_F(InputRouterImplTest, ClientCanceledKeyboardEvent) { 429 client_->set_filter_state(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS); 430 431 // Simulate a keyboard event that has no consumer. 432 SimulateKeyboardEvent(WebInputEvent::RawKeyDown, false); 433 434 // Make sure no input event is sent to the renderer. 435 EXPECT_EQ(0u, GetSentMessageCountAndResetSink()); 436 EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount()); 437 438 439 // Simulate a keyboard event that should be dropped. 440 client_->set_filter_state(INPUT_EVENT_ACK_STATE_UNKNOWN); 441 SimulateKeyboardEvent(WebInputEvent::RawKeyDown, false); 442 443 // Make sure no input event is sent to the renderer, and no ack is sent. 444 EXPECT_EQ(0u, GetSentMessageCountAndResetSink()); 445 EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount()); 446} 447 448TEST_F(InputRouterImplTest, ShortcutKeyboardEvent) { 449 SimulateKeyboardEvent(WebInputEvent::RawKeyDown, true); 450 EXPECT_TRUE(GetIsShortcutFromHandleInputEventMessage( 451 process_->sink().GetMessageAt(0))); 452 453 process_->sink().ClearMessages(); 454 455 SimulateKeyboardEvent(WebInputEvent::RawKeyDown, false); 456 EXPECT_FALSE(GetIsShortcutFromHandleInputEventMessage( 457 process_->sink().GetMessageAt(0))); 458} 459 460TEST_F(InputRouterImplTest, NoncorrespondingKeyEvents) { 461 SimulateKeyboardEvent(WebInputEvent::RawKeyDown, false); 462 463 SendInputEventACK(WebInputEvent::KeyUp, 464 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 465 EXPECT_TRUE(ack_handler_->unexpected_event_ack_called()); 466} 467 468// Tests ported from RenderWidgetHostTest -------------------------------------- 469 470TEST_F(InputRouterImplTest, HandleKeyEventsWeSent) { 471 // Simulate a keyboard event. 472 SimulateKeyboardEvent(WebInputEvent::RawKeyDown, false); 473 ASSERT_TRUE(input_router_->GetLastKeyboardEvent()); 474 EXPECT_EQ(WebInputEvent::RawKeyDown, 475 input_router_->GetLastKeyboardEvent()->type); 476 477 // Make sure we sent the input event to the renderer. 478 EXPECT_TRUE(process_->sink().GetUniqueMessageMatching( 479 InputMsg_HandleInputEvent::ID)); 480 process_->sink().ClearMessages(); 481 482 // Send the simulated response from the renderer back. 483 SendInputEventACK(WebInputEvent::RawKeyDown, 484 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 485 EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount()); 486 EXPECT_EQ(WebInputEvent::RawKeyDown, 487 ack_handler_->acked_keyboard_event().type); 488} 489 490TEST_F(InputRouterImplTest, IgnoreKeyEventsWeDidntSend) { 491 // Send a simulated, unrequested key response. We should ignore this. 492 SendInputEventACK(WebInputEvent::RawKeyDown, 493 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 494 495 EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount()); 496} 497 498TEST_F(InputRouterImplTest, CoalescesWheelEvents) { 499 // Simulate wheel events. 500 SimulateWheelEvent(0, -5, 0, false); // sent directly 501 SimulateWheelEvent(0, -10, 0, false); // enqueued 502 SimulateWheelEvent(8, -6, 0, false); // coalesced into previous event 503 SimulateWheelEvent(9, -7, 1, false); // enqueued, different modifiers 504 SimulateWheelEvent(0, -10, 0, false); // enqueued, different modifiers 505 // Explicitly verify that PhaseEnd isn't coalesced to avoid bugs like 506 // https://crbug.com/154740. 507 SimulateWheelEventWithPhase(WebMouseWheelEvent::PhaseEnded); // enqueued 508 509 // Check that only the first event was sent. 510 EXPECT_TRUE(process_->sink().GetUniqueMessageMatching( 511 InputMsg_HandleInputEvent::ID)); 512 const WebInputEvent* input_event = 513 GetInputEventFromMessage(*process_->sink().GetMessageAt(0)); 514 ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type); 515 const WebMouseWheelEvent* wheel_event = 516 static_cast<const WebMouseWheelEvent*>(input_event); 517 EXPECT_EQ(0, wheel_event->deltaX); 518 EXPECT_EQ(-5, wheel_event->deltaY); 519 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 520 521 // Check that the ACK sends the second message immediately. 522 SendInputEventACK(WebInputEvent::MouseWheel, 523 INPUT_EVENT_ACK_STATE_CONSUMED); 524 // The coalesced events can queue up a delayed ack 525 // so that additional input events can be processed before 526 // we turn off coalescing. 527 base::MessageLoop::current()->RunUntilIdle(); 528 EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount()); 529 EXPECT_TRUE(process_->sink().GetUniqueMessageMatching( 530 InputMsg_HandleInputEvent::ID)); 531 input_event = GetInputEventFromMessage(*process_->sink().GetMessageAt(0)); 532 ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type); 533 wheel_event = static_cast<const WebMouseWheelEvent*>(input_event); 534 EXPECT_EQ(8, wheel_event->deltaX); 535 EXPECT_EQ(-10 + -6, wheel_event->deltaY); // coalesced 536 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 537 538 // Ack the second event (which had the third coalesced into it). 539 SendInputEventACK(WebInputEvent::MouseWheel, 540 INPUT_EVENT_ACK_STATE_CONSUMED); 541 base::MessageLoop::current()->RunUntilIdle(); 542 EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount()); 543 EXPECT_TRUE(process_->sink().GetUniqueMessageMatching( 544 InputMsg_HandleInputEvent::ID)); 545 input_event = GetInputEventFromMessage(*process_->sink().GetMessageAt(0)); 546 ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type); 547 wheel_event = static_cast<const WebMouseWheelEvent*>(input_event); 548 EXPECT_EQ(9, wheel_event->deltaX); 549 EXPECT_EQ(-7, wheel_event->deltaY); 550 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 551 552 // Ack the fourth event. 553 SendInputEventACK(WebInputEvent::MouseWheel, 554 INPUT_EVENT_ACK_STATE_CONSUMED); 555 base::MessageLoop::current()->RunUntilIdle(); 556 EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount()); 557 EXPECT_TRUE( 558 process_->sink().GetUniqueMessageMatching(InputMsg_HandleInputEvent::ID)); 559 input_event = GetInputEventFromMessage(*process_->sink().GetMessageAt(0)); 560 ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type); 561 wheel_event = static_cast<const WebMouseWheelEvent*>(input_event); 562 EXPECT_EQ(0, wheel_event->deltaX); 563 EXPECT_EQ(-10, wheel_event->deltaY); 564 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 565 566 // Ack the fifth event. 567 SendInputEventACK(WebInputEvent::MouseWheel, INPUT_EVENT_ACK_STATE_CONSUMED); 568 base::MessageLoop::current()->RunUntilIdle(); 569 EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount()); 570 EXPECT_TRUE( 571 process_->sink().GetUniqueMessageMatching(InputMsg_HandleInputEvent::ID)); 572 input_event = GetInputEventFromMessage(*process_->sink().GetMessageAt(0)); 573 ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type); 574 wheel_event = static_cast<const WebMouseWheelEvent*>(input_event); 575 EXPECT_EQ(0, wheel_event->deltaX); 576 EXPECT_EQ(0, wheel_event->deltaY); 577 EXPECT_EQ(WebMouseWheelEvent::PhaseEnded, wheel_event->phase); 578 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 579 580 // After the final ack, the queue should be empty. 581 SendInputEventACK(WebInputEvent::MouseWheel, INPUT_EVENT_ACK_STATE_CONSUMED); 582 base::MessageLoop::current()->RunUntilIdle(); 583 EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount()); 584 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 585} 586 587// Tests that touch-events are queued properly. 588TEST_F(InputRouterImplTest, TouchEventQueue) { 589 OnHasTouchEventHandlers(true); 590 591 PressTouchPoint(1, 1); 592 SendTouchEvent(); 593 EXPECT_TRUE(client_->GetAndResetFilterEventCalled()); 594 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 595 EXPECT_FALSE(TouchEventQueueEmpty()); 596 597 // The second touch should not be sent since one is already in queue. 598 MoveTouchPoint(0, 5, 5); 599 SendTouchEvent(); 600 EXPECT_FALSE(client_->GetAndResetFilterEventCalled()); 601 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 602 EXPECT_FALSE(TouchEventQueueEmpty()); 603 604 // Receive an ACK for the first touch-event. 605 SendInputEventACK(WebInputEvent::TouchStart, 606 INPUT_EVENT_ACK_STATE_CONSUMED); 607 EXPECT_FALSE(TouchEventQueueEmpty()); 608 EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount()); 609 EXPECT_EQ(WebInputEvent::TouchStart, 610 ack_handler_->acked_touch_event().event.type); 611 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 612 613 SendInputEventACK(WebInputEvent::TouchMove, 614 INPUT_EVENT_ACK_STATE_CONSUMED); 615 EXPECT_TRUE(TouchEventQueueEmpty()); 616 EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount()); 617 EXPECT_EQ(WebInputEvent::TouchMove, 618 ack_handler_->acked_touch_event().event.type); 619 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 620} 621 622// Tests that the touch-queue is emptied after a page stops listening for touch 623// events and the outstanding ack is received. 624TEST_F(InputRouterImplTest, TouchEventQueueFlush) { 625 OnHasTouchEventHandlers(true); 626 EXPECT_TRUE(client_->has_touch_handler()); 627 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 628 EXPECT_TRUE(TouchEventQueueEmpty()); 629 630 EXPECT_TRUE(input_router_->ShouldForwardTouchEvent()); 631 632 // Send a touch-press event. 633 PressTouchPoint(1, 1); 634 SendTouchEvent(); 635 MoveTouchPoint(0, 2, 2); 636 MoveTouchPoint(0, 3, 3); 637 EXPECT_FALSE(TouchEventQueueEmpty()); 638 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 639 640 // The page stops listening for touch-events. Note that flushing is deferred 641 // until the outstanding ack is received. 642 OnHasTouchEventHandlers(false); 643 EXPECT_FALSE(client_->has_touch_handler()); 644 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 645 EXPECT_FALSE(TouchEventQueueEmpty()); 646 EXPECT_TRUE(input_router_->ShouldForwardTouchEvent()); 647 648 // After the ack, the touch-event queue should be empty, and none of the 649 // flushed touch-events should have been sent to the renderer. 650 SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED); 651 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 652 EXPECT_TRUE(TouchEventQueueEmpty()); 653 EXPECT_FALSE(input_router_->ShouldForwardTouchEvent()); 654} 655 656#if defined(USE_AURA) 657// Tests that the acked events have correct state. (ui::Events are used only on 658// windows and aura) 659TEST_F(InputRouterImplTest, AckedTouchEventState) { 660 input_router_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, true)); 661 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 662 EXPECT_TRUE(TouchEventQueueEmpty()); 663 EXPECT_TRUE(input_router_->ShouldForwardTouchEvent()); 664 665 // Send a bunch of events, and make sure the ACKed events are correct. 666 ScopedVector<ui::TouchEvent> expected_events; 667 668 // Use a custom timestamp for all the events to test that the acked events 669 // have the same timestamp; 670 base::TimeDelta timestamp = base::Time::NowFromSystemTime() - base::Time(); 671 timestamp -= base::TimeDelta::FromSeconds(600); 672 673 // Press the first finger. 674 PressTouchPoint(1, 1); 675 SetTouchTimestamp(timestamp); 676 SendTouchEvent(); 677 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 678 expected_events.push_back(new ui::TouchEvent(ui::ET_TOUCH_PRESSED, 679 gfx::Point(1, 1), 0, timestamp)); 680 681 // Move the finger. 682 timestamp += base::TimeDelta::FromSeconds(10); 683 MoveTouchPoint(0, 500, 500); 684 SetTouchTimestamp(timestamp); 685 SendTouchEvent(); 686 EXPECT_FALSE(TouchEventQueueEmpty()); 687 expected_events.push_back(new ui::TouchEvent(ui::ET_TOUCH_MOVED, 688 gfx::Point(500, 500), 0, timestamp)); 689 690 // Now press a second finger. 691 timestamp += base::TimeDelta::FromSeconds(10); 692 PressTouchPoint(2, 2); 693 SetTouchTimestamp(timestamp); 694 SendTouchEvent(); 695 EXPECT_FALSE(TouchEventQueueEmpty()); 696 expected_events.push_back(new ui::TouchEvent(ui::ET_TOUCH_PRESSED, 697 gfx::Point(2, 2), 1, timestamp)); 698 699 // Move both fingers. 700 timestamp += base::TimeDelta::FromSeconds(10); 701 MoveTouchPoint(0, 10, 10); 702 MoveTouchPoint(1, 20, 20); 703 SetTouchTimestamp(timestamp); 704 SendTouchEvent(); 705 EXPECT_FALSE(TouchEventQueueEmpty()); 706 expected_events.push_back(new ui::TouchEvent(ui::ET_TOUCH_MOVED, 707 gfx::Point(10, 10), 0, timestamp)); 708 expected_events.push_back(new ui::TouchEvent(ui::ET_TOUCH_MOVED, 709 gfx::Point(20, 20), 1, timestamp)); 710 711 // Receive the ACKs and make sure the generated events from the acked events 712 // are correct. 713 WebInputEvent::Type acks[] = { WebInputEvent::TouchStart, 714 WebInputEvent::TouchMove, 715 WebInputEvent::TouchStart, 716 WebInputEvent::TouchMove }; 717 718 TouchEventCoordinateSystem coordinate_system = LOCAL_COORDINATES; 719#if !defined(OS_WIN) 720 coordinate_system = SCREEN_COORDINATES; 721#endif 722 for (size_t i = 0; i < arraysize(acks); ++i) { 723 SendInputEventACK(acks[i], 724 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 725 EXPECT_EQ(acks[i], ack_handler_->acked_touch_event().event.type); 726 ScopedVector<ui::TouchEvent> acked; 727 728 MakeUITouchEventsFromWebTouchEvents( 729 ack_handler_->acked_touch_event(), &acked, coordinate_system); 730 bool success = EventListIsSubset(acked, expected_events); 731 EXPECT_TRUE(success) << "Failed on step: " << i; 732 if (!success) 733 break; 734 expected_events.erase(expected_events.begin(), 735 expected_events.begin() + acked.size()); 736 } 737 738 EXPECT_TRUE(TouchEventQueueEmpty()); 739 EXPECT_EQ(0U, expected_events.size()); 740} 741#endif // defined(USE_AURA) 742 743TEST_F(InputRouterImplTest, UnhandledWheelEvent) { 744 // Simulate wheel events. 745 SimulateWheelEvent(0, -5, 0, false); // sent directly 746 SimulateWheelEvent(0, -10, 0, false); // enqueued 747 748 // Check that only the first event was sent. 749 EXPECT_TRUE(process_->sink().GetUniqueMessageMatching( 750 InputMsg_HandleInputEvent::ID)); 751 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 752 753 // Indicate that the wheel event was unhandled. 754 SendInputEventACK(WebInputEvent::MouseWheel, 755 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 756 757 // Check that the correct unhandled wheel event was received. 758 EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount()); 759 EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, ack_handler_->ack_state()); 760 EXPECT_EQ(ack_handler_->acked_wheel_event().deltaY, -5); 761 762 // Check that the second event was sent. 763 EXPECT_TRUE(process_->sink().GetUniqueMessageMatching( 764 InputMsg_HandleInputEvent::ID)); 765 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 766 767 // Check that the correct unhandled wheel event was received. 768 EXPECT_EQ(ack_handler_->acked_wheel_event().deltaY, -5); 769} 770 771TEST_F(InputRouterImplTest, TouchTypesIgnoringAck) { 772 OnHasTouchEventHandlers(true); 773 // Only acks for TouchCancel should always be ignored. 774 ASSERT_FALSE(WebInputEventTraits::IgnoresAckDisposition( 775 GetEventWithType(WebInputEvent::TouchStart))); 776 ASSERT_FALSE(WebInputEventTraits::IgnoresAckDisposition( 777 GetEventWithType(WebInputEvent::TouchMove))); 778 ASSERT_FALSE(WebInputEventTraits::IgnoresAckDisposition( 779 GetEventWithType(WebInputEvent::TouchEnd))); 780 781 // Precede the TouchCancel with an appropriate TouchStart; 782 PressTouchPoint(1, 1); 783 SendTouchEvent(); 784 SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED); 785 ASSERT_EQ(1U, GetSentMessageCountAndResetSink()); 786 ASSERT_EQ(1U, ack_handler_->GetAndResetAckCount()); 787 ASSERT_EQ(0, client_->in_flight_event_count()); 788 789 // The TouchCancel ack is always ignored. 790 CancelTouchPoint(0); 791 SendTouchEvent(); 792 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 793 EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount()); 794 EXPECT_EQ(0, client_->in_flight_event_count()); 795 EXPECT_FALSE(HasPendingEvents()); 796 SendInputEventACK(WebInputEvent::TouchCancel, 797 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 798 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 799 EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount()); 800 EXPECT_FALSE(HasPendingEvents()); 801} 802 803TEST_F(InputRouterImplTest, GestureTypesIgnoringAck) { 804 // We test every gesture type, ensuring that the stream of gestures is valid. 805 const int kEventTypesLength = 29; 806 WebInputEvent::Type eventTypes[kEventTypesLength] = { 807 WebInputEvent::GestureTapDown, 808 WebInputEvent::GestureShowPress, 809 WebInputEvent::GestureTapCancel, 810 WebInputEvent::GestureScrollBegin, 811 WebInputEvent::GestureFlingStart, 812 WebInputEvent::GestureFlingCancel, 813 WebInputEvent::GestureTapDown, 814 WebInputEvent::GestureTap, 815 WebInputEvent::GestureTapDown, 816 WebInputEvent::GestureLongPress, 817 WebInputEvent::GestureTapCancel, 818 WebInputEvent::GestureLongTap, 819 WebInputEvent::GestureTapDown, 820 WebInputEvent::GestureTapUnconfirmed, 821 WebInputEvent::GestureTapCancel, 822 WebInputEvent::GestureTapDown, 823 WebInputEvent::GestureDoubleTap, 824 WebInputEvent::GestureTapDown, 825 WebInputEvent::GestureTapCancel, 826 WebInputEvent::GestureTwoFingerTap, 827 WebInputEvent::GestureTapDown, 828 WebInputEvent::GestureTapCancel, 829 WebInputEvent::GestureScrollBegin, 830 WebInputEvent::GestureScrollUpdate, 831 WebInputEvent::GestureScrollUpdateWithoutPropagation, 832 WebInputEvent::GesturePinchBegin, 833 WebInputEvent::GesturePinchUpdate, 834 WebInputEvent::GesturePinchEnd, 835 WebInputEvent::GestureScrollEnd}; 836 for (int i = 0; i < kEventTypesLength; ++i) { 837 WebInputEvent::Type type = eventTypes[i]; 838 if (!WebInputEventTraits::IgnoresAckDisposition(GetEventWithType(type))) { 839 SimulateGestureEvent(type, blink::WebGestureDeviceTouchscreen); 840 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 841 EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount()); 842 EXPECT_EQ(1, client_->in_flight_event_count()); 843 EXPECT_TRUE(HasPendingEvents()); 844 845 SendInputEventACK(type, INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 846 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 847 EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount()); 848 EXPECT_EQ(0, client_->in_flight_event_count()); 849 EXPECT_FALSE(HasPendingEvents()); 850 continue; 851 } 852 853 SimulateGestureEvent(type, blink::WebGestureDeviceTouchscreen); 854 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 855 EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount()); 856 EXPECT_EQ(0, client_->in_flight_event_count()); 857 EXPECT_FALSE(HasPendingEvents()); 858 } 859} 860 861TEST_F(InputRouterImplTest, MouseTypesIgnoringAck) { 862 int start_type = static_cast<int>(WebInputEvent::MouseDown); 863 int end_type = static_cast<int>(WebInputEvent::ContextMenu); 864 ASSERT_LT(start_type, end_type); 865 for (int i = start_type; i <= end_type; ++i) { 866 WebInputEvent::Type type = static_cast<WebInputEvent::Type>(i); 867 int expected_in_flight_event_count = 868 WebInputEventTraits::IgnoresAckDisposition(GetEventWithType(type)) ? 0 869 : 1; 870 871 // Note: Mouse event acks are never forwarded to the ack handler, so the key 872 // result here is that ignored ack types don't affect the in-flight count. 873 SimulateMouseEvent(type, 0, 0); 874 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 875 EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount()); 876 EXPECT_EQ(expected_in_flight_event_count, client_->in_flight_event_count()); 877 if (expected_in_flight_event_count) { 878 SendInputEventACK(type, INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 879 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 880 EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount()); 881 EXPECT_EQ(0, client_->in_flight_event_count()); 882 } 883 } 884} 885 886// Guard against breaking changes to the list of ignored event ack types in 887// |WebInputEventTraits::IgnoresAckDisposition|. 888TEST_F(InputRouterImplTest, RequiredEventAckTypes) { 889 const WebInputEvent::Type kRequiredEventAckTypes[] = { 890 WebInputEvent::MouseMove, 891 WebInputEvent::MouseWheel, 892 WebInputEvent::RawKeyDown, 893 WebInputEvent::KeyDown, 894 WebInputEvent::KeyUp, 895 WebInputEvent::Char, 896 WebInputEvent::GestureScrollUpdate, 897 WebInputEvent::GestureFlingStart, 898 WebInputEvent::GestureFlingCancel, 899 WebInputEvent::GesturePinchUpdate, 900 WebInputEvent::TouchStart, 901 WebInputEvent::TouchMove 902 }; 903 for (size_t i = 0; i < arraysize(kRequiredEventAckTypes); ++i) { 904 const WebInputEvent::Type required_ack_type = kRequiredEventAckTypes[i]; 905 EXPECT_FALSE(WebInputEventTraits::IgnoresAckDisposition( 906 GetEventWithType(required_ack_type))); 907 } 908} 909 910// Test that GestureShowPress, GestureTapDown and GestureTapCancel events don't 911// wait for ACKs. 912TEST_F(InputRouterImplTest, GestureTypesIgnoringAckInterleaved) { 913 // Interleave a few events that do and do not ignore acks, ensuring that 914 // ack-ignoring events aren't dispatched until all prior events which observe 915 // their ack disposition have been dispatched. 916 917 SimulateGestureEvent(WebInputEvent::GestureScrollBegin, 918 blink::WebGestureDeviceTouchscreen); 919 ASSERT_EQ(1U, GetSentMessageCountAndResetSink()); 920 EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount()); 921 EXPECT_EQ(0, client_->in_flight_event_count()); 922 923 SimulateGestureEvent(WebInputEvent::GestureScrollUpdate, 924 blink::WebGestureDeviceTouchscreen); 925 ASSERT_EQ(1U, GetSentMessageCountAndResetSink()); 926 EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount()); 927 EXPECT_EQ(1, client_->in_flight_event_count()); 928 929 SimulateGestureEvent(WebInputEvent::GestureTapDown, 930 blink::WebGestureDeviceTouchscreen); 931 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 932 EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount()); 933 EXPECT_EQ(1, client_->in_flight_event_count()); 934 935 SimulateGestureEvent(WebInputEvent::GestureScrollUpdate, 936 blink::WebGestureDeviceTouchscreen); 937 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 938 EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount()); 939 940 SimulateGestureEvent(WebInputEvent::GestureShowPress, 941 blink::WebGestureDeviceTouchscreen); 942 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 943 EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount()); 944 945 SimulateGestureEvent(WebInputEvent::GestureScrollUpdate, 946 blink::WebGestureDeviceTouchscreen); 947 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 948 EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount()); 949 950 SimulateGestureEvent(WebInputEvent::GestureTapCancel, 951 blink::WebGestureDeviceTouchscreen); 952 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 953 EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount()); 954 955 // Now ack each ack-respecting event. Ack-ignoring events should not be 956 // dispatched until all prior events which observe ack disposition have been 957 // fired, at which point they should be sent immediately. They should also 958 // have no effect on the in-flight event count. 959 SendInputEventACK(WebInputEvent::GestureScrollUpdate, 960 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 961 EXPECT_EQ(2U, GetSentMessageCountAndResetSink()); 962 EXPECT_EQ(2U, ack_handler_->GetAndResetAckCount()); 963 EXPECT_EQ(1, client_->in_flight_event_count()); 964 965 SendInputEventACK(WebInputEvent::GestureScrollUpdate, 966 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 967 EXPECT_EQ(2U, GetSentMessageCountAndResetSink()); 968 EXPECT_EQ(2U, ack_handler_->GetAndResetAckCount()); 969 EXPECT_EQ(1, client_->in_flight_event_count()); 970 971 SendInputEventACK(WebInputEvent::GestureScrollUpdate, 972 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 973 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 974 EXPECT_EQ(2U, ack_handler_->GetAndResetAckCount()); 975 EXPECT_EQ(0, client_->in_flight_event_count()); 976} 977 978// Test that GestureShowPress events don't get out of order due to 979// ignoring their acks. 980TEST_F(InputRouterImplTest, GestureShowPressIsInOrder) { 981 SimulateGestureEvent(WebInputEvent::GestureScrollBegin, 982 blink::WebGestureDeviceTouchscreen); 983 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 984 EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount()); 985 986 987 // GesturePinchBegin ignores its ack. 988 SimulateGestureEvent(WebInputEvent::GesturePinchBegin, 989 blink::WebGestureDeviceTouchscreen); 990 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 991 EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount()); 992 993 // GesturePinchUpdate waits for an ack. 994 // This also verifies that GesturePinchUpdates for touchscreen are sent 995 // to the renderer (in contrast to the TrackpadPinchUpdate test). 996 SimulateGestureEvent(WebInputEvent::GesturePinchUpdate, 997 blink::WebGestureDeviceTouchscreen); 998 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 999 EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount()); 1000 1001 SimulateGestureEvent(WebInputEvent::GestureShowPress, 1002 blink::WebGestureDeviceTouchscreen); 1003 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 1004 // The ShowPress, though it ignores ack, is still stuck in the queue 1005 // behind the PinchUpdate which requires an ack. 1006 EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount()); 1007 1008 SimulateGestureEvent(WebInputEvent::GestureShowPress, 1009 blink::WebGestureDeviceTouchscreen); 1010 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 1011 // ShowPress has entered the queue. 1012 EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount()); 1013 1014 SendInputEventACK(WebInputEvent::GesturePinchUpdate, 1015 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 1016 // Now that the Tap has been ACKed, the ShowPress events should receive 1017 // synthetic acks, and fire immediately. 1018 EXPECT_EQ(2U, GetSentMessageCountAndResetSink()); 1019 EXPECT_EQ(3U, ack_handler_->GetAndResetAckCount()); 1020} 1021 1022// Test that touch ack timeout behavior is properly toggled by view update flags 1023// and allowed touch actions. 1024TEST_F(InputRouterImplTest, TouchAckTimeoutConfigured) { 1025 const int timeout_ms = 1; 1026 SetUpForTouchAckTimeoutTest(timeout_ms); 1027 ASSERT_TRUE(TouchEventTimeoutEnabled()); 1028 1029 // Verify that the touch ack timeout fires upon the delayed ack. 1030 PressTouchPoint(1, 1); 1031 SendTouchEvent(); 1032 EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount()); 1033 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 1034 RunTasksAndWait(base::TimeDelta::FromMilliseconds(timeout_ms + 1)); 1035 1036 // The timed-out event should have been ack'ed. 1037 EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount()); 1038 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 1039 1040 // Ack'ing the timed-out event should fire a TouchCancel. 1041 SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED); 1042 EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount()); 1043 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 1044 1045 // The remainder of the touch sequence should be dropped. 1046 ReleaseTouchPoint(0); 1047 SendTouchEvent(); 1048 EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount()); 1049 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 1050 ASSERT_TRUE(TouchEventTimeoutEnabled()); 1051 1052 // A fixed page scale or mobile viewport should disable the touch timeout. 1053 input_router()->OnViewUpdated(InputRouter::FIXED_PAGE_SCALE); 1054 EXPECT_FALSE(TouchEventTimeoutEnabled()); 1055 1056 input_router()->OnViewUpdated(InputRouter::VIEW_FLAGS_NONE); 1057 EXPECT_TRUE(TouchEventTimeoutEnabled()); 1058 1059 input_router()->OnViewUpdated(InputRouter::MOBILE_VIEWPORT); 1060 EXPECT_FALSE(TouchEventTimeoutEnabled()); 1061 1062 input_router()->OnViewUpdated(InputRouter::MOBILE_VIEWPORT | 1063 InputRouter::FIXED_PAGE_SCALE); 1064 EXPECT_FALSE(TouchEventTimeoutEnabled()); 1065 1066 input_router()->OnViewUpdated(InputRouter::VIEW_FLAGS_NONE); 1067 EXPECT_TRUE(TouchEventTimeoutEnabled()); 1068 1069 // TOUCH_ACTION_NONE (and no other touch-action) should disable the timeout. 1070 OnHasTouchEventHandlers(true); 1071 PressTouchPoint(1, 1); 1072 SendTouchEvent(); 1073 OnSetTouchAction(TOUCH_ACTION_PAN_Y); 1074 EXPECT_TRUE(TouchEventTimeoutEnabled()); 1075 ReleaseTouchPoint(0); 1076 SendTouchEvent(); 1077 SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED); 1078 SendInputEventACK(WebInputEvent::TouchEnd, INPUT_EVENT_ACK_STATE_CONSUMED); 1079 1080 PressTouchPoint(1, 1); 1081 SendTouchEvent(); 1082 OnSetTouchAction(TOUCH_ACTION_NONE); 1083 EXPECT_FALSE(TouchEventTimeoutEnabled()); 1084 ReleaseTouchPoint(0); 1085 SendTouchEvent(); 1086 SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED); 1087 SendInputEventACK(WebInputEvent::TouchEnd, INPUT_EVENT_ACK_STATE_CONSUMED); 1088 1089 // As the touch-action is reset by a new touch sequence, the timeout behavior 1090 // should be restored. 1091 PressTouchPoint(1, 1); 1092 SendTouchEvent(); 1093 EXPECT_TRUE(TouchEventTimeoutEnabled()); 1094} 1095 1096// Test that a touch sequenced preceded by TOUCH_ACTION_NONE is not affected by 1097// the touch timeout. 1098TEST_F(InputRouterImplTest, 1099 TouchAckTimeoutDisabledForTouchSequenceAfterTouchActionNone) { 1100 const int timeout_ms = 1; 1101 SetUpForTouchAckTimeoutTest(timeout_ms); 1102 ASSERT_TRUE(TouchEventTimeoutEnabled()); 1103 OnHasTouchEventHandlers(true); 1104 1105 // Start a touch sequence. 1106 PressTouchPoint(1, 1); 1107 SendTouchEvent(); 1108 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 1109 1110 // TOUCH_ACTION_NONE should disable the timeout. 1111 OnSetTouchAction(TOUCH_ACTION_NONE); 1112 SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED); 1113 EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount()); 1114 EXPECT_FALSE(TouchEventTimeoutEnabled()); 1115 1116 MoveTouchPoint(0, 1, 1); 1117 SendTouchEvent(); 1118 EXPECT_FALSE(TouchEventTimeoutEnabled()); 1119 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 1120 1121 // Delay the move ack. The timeout should not fire. 1122 RunTasksAndWait(base::TimeDelta::FromMilliseconds(timeout_ms + 1)); 1123 EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount()); 1124 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 1125 SendInputEventACK(WebInputEvent::TouchEnd, INPUT_EVENT_ACK_STATE_CONSUMED); 1126 EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount()); 1127 1128 // End the touch sequence. 1129 ReleaseTouchPoint(0); 1130 SendTouchEvent(); 1131 SendInputEventACK(WebInputEvent::TouchEnd, INPUT_EVENT_ACK_STATE_CONSUMED); 1132 EXPECT_FALSE(TouchEventTimeoutEnabled()); 1133 ack_handler_->GetAndResetAckCount(); 1134 GetSentMessageCountAndResetSink(); 1135 1136 // Start another touch sequence. This should restore the touch timeout. 1137 PressTouchPoint(1, 1); 1138 SendTouchEvent(); 1139 EXPECT_TRUE(TouchEventTimeoutEnabled()); 1140 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 1141 EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount()); 1142 1143 // Wait for the touch ack timeout to fire. 1144 RunTasksAndWait(base::TimeDelta::FromMilliseconds(timeout_ms + 1)); 1145 EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount()); 1146} 1147 1148// Test that TouchActionFilter::ResetTouchAction is called before the 1149// first touch event for a touch sequence reaches the renderer. 1150TEST_F(InputRouterImplTest, TouchActionResetBeforeEventReachesRenderer) { 1151 OnHasTouchEventHandlers(true); 1152 1153 // Sequence 1. 1154 PressTouchPoint(1, 1); 1155 SendTouchEvent(); 1156 OnSetTouchAction(TOUCH_ACTION_NONE); 1157 MoveTouchPoint(0, 50, 50); 1158 SendTouchEvent(); 1159 ReleaseTouchPoint(0); 1160 SendTouchEvent(); 1161 1162 // Sequence 2. 1163 PressTouchPoint(1, 1); 1164 SendTouchEvent(); 1165 MoveTouchPoint(0, 50, 50); 1166 SendTouchEvent(); 1167 ReleaseTouchPoint(0); 1168 SendTouchEvent(); 1169 1170 SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED); 1171 SendInputEventACK(WebInputEvent::TouchMove, INPUT_EVENT_ACK_STATE_CONSUMED); 1172 1173 // Ensure touch action is still none, as the next touch start hasn't been 1174 // acked yet. ScrollBegin and ScrollEnd don't require acks. 1175 EXPECT_EQ(3U, GetSentMessageCountAndResetSink()); 1176 SimulateGestureEvent(WebInputEvent::GestureScrollBegin, 1177 blink::WebGestureDeviceTouchscreen); 1178 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 1179 SimulateGestureEvent(WebInputEvent::GestureScrollEnd, 1180 blink::WebGestureDeviceTouchscreen); 1181 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 1182 1183 // This allows the next touch sequence to start. 1184 SendInputEventACK(WebInputEvent::TouchEnd, INPUT_EVENT_ACK_STATE_CONSUMED); 1185 1186 // Ensure touch action has been set to auto, as a new touch sequence has 1187 // started. 1188 SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED); 1189 SendInputEventACK(WebInputEvent::TouchMove, INPUT_EVENT_ACK_STATE_CONSUMED); 1190 EXPECT_EQ(3U, GetSentMessageCountAndResetSink()); 1191 SimulateGestureEvent(WebInputEvent::GestureScrollBegin, 1192 blink::WebGestureDeviceTouchscreen); 1193 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 1194 SimulateGestureEvent(WebInputEvent::GestureScrollEnd, 1195 blink::WebGestureDeviceTouchscreen); 1196 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 1197 SendInputEventACK(WebInputEvent::TouchEnd, INPUT_EVENT_ACK_STATE_CONSUMED); 1198} 1199 1200// Test that TouchActionFilter::ResetTouchAction is called when a new touch 1201// sequence has no consumer. 1202TEST_F(InputRouterImplTest, TouchActionResetWhenTouchHasNoConsumer) { 1203 OnHasTouchEventHandlers(true); 1204 1205 // Sequence 1. 1206 PressTouchPoint(1, 1); 1207 SendTouchEvent(); 1208 MoveTouchPoint(0, 50, 50); 1209 SendTouchEvent(); 1210 OnSetTouchAction(TOUCH_ACTION_NONE); 1211 SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED); 1212 SendInputEventACK(WebInputEvent::TouchMove, INPUT_EVENT_ACK_STATE_CONSUMED); 1213 1214 ReleaseTouchPoint(0); 1215 SendTouchEvent(); 1216 1217 // Sequence 2 1218 PressTouchPoint(1, 1); 1219 SendTouchEvent(); 1220 MoveTouchPoint(0, 50, 50); 1221 SendTouchEvent(); 1222 ReleaseTouchPoint(0); 1223 SendTouchEvent(); 1224 1225 // Ensure we have touch-action:none. ScrollBegin and ScrollEnd don't require 1226 // acks. 1227 EXPECT_EQ(3U, GetSentMessageCountAndResetSink()); 1228 SimulateGestureEvent(WebInputEvent::GestureScrollBegin, 1229 blink::WebGestureDeviceTouchscreen); 1230 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 1231 SimulateGestureEvent(WebInputEvent::GestureScrollEnd, 1232 blink::WebGestureDeviceTouchscreen); 1233 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 1234 1235 SendInputEventACK(WebInputEvent::TouchEnd, INPUT_EVENT_ACK_STATE_CONSUMED); 1236 SendInputEventACK(WebInputEvent::TouchStart, 1237 INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS); 1238 1239 // Ensure touch action has been set to auto, as the touch had no consumer. 1240 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 1241 SimulateGestureEvent(WebInputEvent::GestureScrollBegin, 1242 blink::WebGestureDeviceTouchscreen); 1243 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 1244 SimulateGestureEvent(WebInputEvent::GestureScrollEnd, 1245 blink::WebGestureDeviceTouchscreen); 1246 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 1247} 1248 1249// Test that TouchActionFilter::ResetTouchAction is called when the touch 1250// handler is removed. 1251TEST_F(InputRouterImplTest, TouchActionResetWhenTouchHandlerRemoved) { 1252 // Touch sequence with touch handler. 1253 OnHasTouchEventHandlers(true); 1254 PressTouchPoint(1, 1); 1255 SendTouchEvent(); 1256 MoveTouchPoint(0, 50, 50); 1257 SendTouchEvent(); 1258 OnSetTouchAction(TOUCH_ACTION_NONE); 1259 ReleaseTouchPoint(0); 1260 SendTouchEvent(); 1261 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 1262 1263 // Ensure we have touch-action:none, suppressing scroll events. 1264 SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED); 1265 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 1266 SendInputEventACK(WebInputEvent::TouchMove, 1267 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 1268 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 1269 SimulateGestureEvent(WebInputEvent::GestureScrollBegin, 1270 blink::WebGestureDeviceTouchscreen); 1271 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 1272 1273 SendInputEventACK(WebInputEvent::TouchEnd, 1274 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 1275 SimulateGestureEvent(WebInputEvent::GestureScrollEnd, 1276 blink::WebGestureDeviceTouchscreen); 1277 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 1278 1279 // Sequence without a touch handler. Note that in this case, the view may not 1280 // necessarily forward touches to the router (as no touch handler exists). 1281 OnHasTouchEventHandlers(false); 1282 1283 // Ensure touch action has been set to auto, as the touch handler has been 1284 // removed. 1285 SimulateGestureEvent(WebInputEvent::GestureScrollBegin, 1286 blink::WebGestureDeviceTouchscreen); 1287 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 1288 SimulateGestureEvent(WebInputEvent::GestureScrollEnd, 1289 blink::WebGestureDeviceTouchscreen); 1290 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 1291} 1292 1293// Test that the double tap gesture depends on the touch action of the first 1294// tap. 1295TEST_F(InputRouterImplTest, DoubleTapGestureDependsOnFirstTap) { 1296 OnHasTouchEventHandlers(true); 1297 1298 // Sequence 1. 1299 PressTouchPoint(1, 1); 1300 SendTouchEvent(); 1301 OnSetTouchAction(TOUCH_ACTION_NONE); 1302 SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED); 1303 1304 ReleaseTouchPoint(0); 1305 SendTouchEvent(); 1306 1307 // Sequence 2 1308 PressTouchPoint(1, 1); 1309 SendTouchEvent(); 1310 1311 // First tap. 1312 EXPECT_EQ(2U, GetSentMessageCountAndResetSink()); 1313 SimulateGestureEvent(WebInputEvent::GestureTapDown, 1314 blink::WebGestureDeviceTouchscreen); 1315 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 1316 1317 // The GestureTapUnconfirmed is converted into a tap, as the touch action is 1318 // none. 1319 SimulateGestureEvent(WebInputEvent::GestureTapUnconfirmed, 1320 blink::WebGestureDeviceTouchscreen); 1321 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 1322 // This test will become invalid if GestureTap stops requiring an ack. 1323 ASSERT_FALSE(WebInputEventTraits::IgnoresAckDisposition( 1324 GetEventWithType(WebInputEvent::GestureTap))); 1325 EXPECT_EQ(2, client_->in_flight_event_count()); 1326 SendInputEventACK(WebInputEvent::GestureTap, 1327 INPUT_EVENT_ACK_STATE_CONSUMED); 1328 EXPECT_EQ(1, client_->in_flight_event_count()); 1329 1330 // This tap gesture is dropped, since the GestureTapUnconfirmed was turned 1331 // into a tap. 1332 SimulateGestureEvent(WebInputEvent::GestureTap, 1333 blink::WebGestureDeviceTouchscreen); 1334 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 1335 1336 SendInputEventACK(WebInputEvent::TouchEnd, INPUT_EVENT_ACK_STATE_CONSUMED); 1337 SendInputEventACK(WebInputEvent::TouchStart, 1338 INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS); 1339 1340 // Second Tap. 1341 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 1342 SimulateGestureEvent(WebInputEvent::GestureTapDown, 1343 blink::WebGestureDeviceTouchscreen); 1344 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 1345 1346 // Although the touch-action is now auto, the double tap still won't be 1347 // dispatched, because the first tap occured when the touch-action was none. 1348 SimulateGestureEvent(WebInputEvent::GestureDoubleTap, 1349 blink::WebGestureDeviceTouchscreen); 1350 // This test will become invalid if GestureDoubleTap stops requiring an ack. 1351 ASSERT_FALSE(WebInputEventTraits::IgnoresAckDisposition( 1352 GetEventWithType(WebInputEvent::GestureDoubleTap))); 1353 EXPECT_EQ(1, client_->in_flight_event_count()); 1354 SendInputEventACK(WebInputEvent::GestureTap, INPUT_EVENT_ACK_STATE_CONSUMED); 1355 EXPECT_EQ(0, client_->in_flight_event_count()); 1356} 1357 1358// Test that the router will call the client's |DidFlush| after all events have 1359// been dispatched following a call to |Flush|. 1360TEST_F(InputRouterImplTest, InputFlush) { 1361 EXPECT_FALSE(HasPendingEvents()); 1362 1363 // Flushing an empty router should immediately trigger DidFlush. 1364 Flush(); 1365 EXPECT_EQ(1U, GetAndResetDidFlushCount()); 1366 EXPECT_FALSE(HasPendingEvents()); 1367 1368 // Queue a TouchStart. 1369 OnHasTouchEventHandlers(true); 1370 PressTouchPoint(1, 1); 1371 SendTouchEvent(); 1372 EXPECT_TRUE(HasPendingEvents()); 1373 1374 // DidFlush should be called only after the event is ack'ed. 1375 Flush(); 1376 EXPECT_EQ(0U, GetAndResetDidFlushCount()); 1377 SendInputEventACK(WebInputEvent::TouchStart, 1378 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 1379 EXPECT_EQ(1U, GetAndResetDidFlushCount()); 1380 1381 // Ensure different types of enqueued events will prevent the DidFlush call 1382 // until all such events have been fully dispatched. 1383 MoveTouchPoint(0, 50, 50); 1384 SendTouchEvent(); 1385 ASSERT_TRUE(HasPendingEvents()); 1386 SimulateGestureEvent(WebInputEvent::GestureScrollBegin, 1387 blink::WebGestureDeviceTouchscreen); 1388 SimulateGestureEvent(WebInputEvent::GestureScrollUpdate, 1389 blink::WebGestureDeviceTouchscreen); 1390 SimulateGestureEvent(WebInputEvent::GesturePinchBegin, 1391 blink::WebGestureDeviceTouchscreen); 1392 SimulateGestureEvent(WebInputEvent::GesturePinchUpdate, 1393 blink::WebGestureDeviceTouchscreen); 1394 Flush(); 1395 EXPECT_EQ(0U, GetAndResetDidFlushCount()); 1396 1397 // Repeated flush calls should have no effect. 1398 Flush(); 1399 EXPECT_EQ(0U, GetAndResetDidFlushCount()); 1400 1401 // There are still pending gestures. 1402 SendInputEventACK(WebInputEvent::TouchMove, 1403 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 1404 EXPECT_EQ(0U, GetAndResetDidFlushCount()); 1405 EXPECT_TRUE(HasPendingEvents()); 1406 1407 // One more gesture to go. 1408 SendInputEventACK(WebInputEvent::GestureScrollUpdate, 1409 INPUT_EVENT_ACK_STATE_CONSUMED); 1410 EXPECT_EQ(0U, GetAndResetDidFlushCount()); 1411 EXPECT_TRUE(HasPendingEvents()); 1412 1413 // The final ack'ed gesture should trigger the DidFlush. 1414 SendInputEventACK(WebInputEvent::GesturePinchUpdate, 1415 INPUT_EVENT_ACK_STATE_CONSUMED); 1416 EXPECT_EQ(1U, GetAndResetDidFlushCount()); 1417 EXPECT_FALSE(HasPendingEvents()); 1418} 1419 1420// Test that GesturePinchUpdate is handled specially for trackpad 1421TEST_F(InputRouterImplTest, TouchpadPinchUpdate) { 1422 // GesturePinchUpdate for trackpad sends synthetic wheel events. 1423 // Note that the Touchscreen case is verified as NOT doing this as 1424 // part of the ShowPressIsInOrder test. 1425 1426 SimulateGesturePinchUpdateEvent( 1427 1.5f, 20, 25, 0, blink::WebGestureDeviceTouchpad); 1428 1429 // Verify we actually sent a special wheel event to the renderer. 1430 const WebInputEvent* input_event = 1431 GetInputEventFromMessage(*process_->sink().GetMessageAt(0)); 1432 ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type); 1433 const WebMouseWheelEvent* wheel_event = 1434 static_cast<const WebMouseWheelEvent*>(input_event); 1435 EXPECT_EQ(20, wheel_event->x); 1436 EXPECT_EQ(25, wheel_event->y); 1437 EXPECT_EQ(20, wheel_event->globalX); 1438 EXPECT_EQ(25, wheel_event->globalY); 1439 EXPECT_EQ(20, wheel_event->windowX); 1440 EXPECT_EQ(25, wheel_event->windowY); 1441 EXPECT_EQ(PinchScaleToWheelDelta(1.5), wheel_event->deltaY); 1442 EXPECT_EQ(0, wheel_event->deltaX); 1443 EXPECT_EQ(1, wheel_event->hasPreciseScrollingDeltas); 1444 EXPECT_EQ(1, wheel_event->wheelTicksY); 1445 EXPECT_EQ(0, wheel_event->wheelTicksX); 1446 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 1447 1448 // Indicate that the wheel event was unhandled. 1449 SendInputEventACK(WebInputEvent::MouseWheel, 1450 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 1451 1452 // Check that the correct unhandled pinch event was received. 1453 EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount()); 1454 ASSERT_EQ(WebInputEvent::GesturePinchUpdate, ack_handler_->ack_event_type()); 1455 EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, ack_handler_->ack_state()); 1456 EXPECT_EQ(1.5f, ack_handler_->acked_gesture_event().data.pinchUpdate.scale); 1457 EXPECT_EQ(0, client_->in_flight_event_count()); 1458 1459 // Second a second pinch event. 1460 SimulateGesturePinchUpdateEvent( 1461 0.3f, 20, 25, 0, blink::WebGestureDeviceTouchpad); 1462 input_event = GetInputEventFromMessage(*process_->sink().GetMessageAt(0)); 1463 ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type); 1464 wheel_event = static_cast<const WebMouseWheelEvent*>(input_event); 1465 EXPECT_FLOAT_EQ(PinchScaleToWheelDelta(0.3f), wheel_event->deltaY); 1466 EXPECT_EQ(1, wheel_event->hasPreciseScrollingDeltas); 1467 EXPECT_EQ(-1, wheel_event->wheelTicksY); 1468 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 1469 1470 // Indicate that the wheel event was handled this time. 1471 SendInputEventACK(WebInputEvent::MouseWheel, INPUT_EVENT_ACK_STATE_CONSUMED); 1472 1473 // Check that the correct HANDLED pinch event was received. 1474 EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount()); 1475 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, ack_handler_->ack_event_type()); 1476 EXPECT_EQ(INPUT_EVENT_ACK_STATE_CONSUMED, ack_handler_->ack_state()); 1477 EXPECT_FLOAT_EQ(0.3f, 1478 ack_handler_->acked_gesture_event().data.pinchUpdate.scale); 1479} 1480 1481// Test that touchpad pinch events are coalesced property, with their synthetic 1482// wheel events getting the right ACKs. 1483TEST_F(InputRouterImplTest, TouchpadPinchCoalescing) { 1484 // Send the first pinch. 1485 SimulateGesturePinchUpdateEvent( 1486 1.5f, 20, 25, 0, blink::WebGestureDeviceTouchpad); 1487 1488 // Verify we sent the wheel event to the renderer. 1489 const WebInputEvent* input_event = 1490 GetInputEventFromMessage(*process_->sink().GetMessageAt(0)); 1491 ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type); 1492 const WebMouseWheelEvent* wheel_event = 1493 static_cast<const WebMouseWheelEvent*>(input_event); 1494 EXPECT_EQ(PinchScaleToWheelDelta(1.5f), wheel_event->deltaY); 1495 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 1496 EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount()); 1497 EXPECT_EQ(1, client_->in_flight_event_count()); 1498 1499 // Send a second pinch, this should be queued in the GestureEventQueue. 1500 SimulateGesturePinchUpdateEvent( 1501 1.6f, 20, 25, 0, blink::WebGestureDeviceTouchpad); 1502 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 1503 EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount()); 1504 1505 // Send a third pinch, this should be coalesced into the second in the 1506 // GestureEventQueue. 1507 SimulateGesturePinchUpdateEvent( 1508 1.7f, 20, 25, 0, blink::WebGestureDeviceTouchpad); 1509 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 1510 EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount()); 1511 1512 // Indicate that the first wheel event was unhandled and verify the ACK. 1513 SendInputEventACK(WebInputEvent::MouseWheel, 1514 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 1515 EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount()); 1516 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, ack_handler_->ack_event_type()); 1517 EXPECT_EQ(INPUT_EVENT_ACK_STATE_NOT_CONSUMED, ack_handler_->ack_state()); 1518 EXPECT_EQ(1.5f, ack_handler_->acked_gesture_event().data.pinchUpdate.scale); 1519 1520 // Verify a second wheel event was sent representing the 2nd and 3rd pinch 1521 // events. 1522 EXPECT_EQ(1, client_->in_flight_event_count()); 1523 input_event = GetInputEventFromMessage(*process_->sink().GetMessageAt(0)); 1524 ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type); 1525 wheel_event = static_cast<const WebMouseWheelEvent*>(input_event); 1526 EXPECT_FLOAT_EQ(PinchScaleToWheelDelta(1.6f * 1.7f), 1527 PinchScaleToWheelDelta(1.6f) + PinchScaleToWheelDelta(1.7f)); 1528 EXPECT_FLOAT_EQ(PinchScaleToWheelDelta(1.6f * 1.7f), wheel_event->deltaY); 1529 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 1530 EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount()); 1531 1532 // Indicate that the second wheel event was handled and verify the ACK. 1533 SendInputEventACK(WebInputEvent::MouseWheel, INPUT_EVENT_ACK_STATE_CONSUMED); 1534 EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount()); 1535 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, ack_handler_->ack_event_type()); 1536 EXPECT_EQ(INPUT_EVENT_ACK_STATE_CONSUMED, ack_handler_->ack_state()); 1537 EXPECT_FLOAT_EQ(1.6f * 1.7f, 1538 ack_handler_->acked_gesture_event().data.pinchUpdate.scale); 1539} 1540 1541// Test interleaving pinch and wheel events. 1542TEST_F(InputRouterImplTest, TouchpadPinchAndWheel) { 1543 // Simulate queued wheel and pinch events events. 1544 // Note that in practice interleaving pinch and wheel events should be rare 1545 // (eg. requires the use of a mouse and trackpad at the same time). 1546 1547 // Use the control modifier to match the synthetic wheel events so that 1548 // they're elligble for coalescing. 1549 int mod = WebInputEvent::ControlKey; 1550 1551 // Event 1: sent directly. 1552 SimulateWheelEvent(0, -5, mod, true); 1553 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 1554 1555 // Event 2: enqueued in InputRouter. 1556 SimulateWheelEvent(0, -10, mod, true); 1557 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 1558 1559 // Event 3: enqueued in InputRouter, not coalesced into #2. 1560 SimulateGesturePinchUpdateEvent( 1561 1.5f, 20, 25, 0, blink::WebGestureDeviceTouchpad); 1562 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 1563 1564 // Event 4: enqueued in GestureEventQueue. 1565 SimulateGesturePinchUpdateEvent( 1566 1.2f, 20, 25, 0, blink::WebGestureDeviceTouchpad); 1567 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 1568 1569 // Event 5: coalesced into wheel event for #3. 1570 SimulateWheelEvent(2, 0, mod, true); 1571 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 1572 1573 // Send ack for #1. 1574 SendInputEventACK(WebInputEvent::MouseWheel, 1575 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 1576 EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount()); 1577 EXPECT_EQ(WebInputEvent::MouseWheel, ack_handler_->ack_event_type()); 1578 1579 // Verify we sent #2. 1580 ASSERT_EQ(1U, process_->sink().message_count()); 1581 const WebInputEvent* input_event = 1582 GetInputEventFromMessage(*process_->sink().GetMessageAt(0)); 1583 ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type); 1584 const WebMouseWheelEvent* wheel_event = 1585 static_cast<const WebMouseWheelEvent*>(input_event); 1586 EXPECT_EQ(0, wheel_event->deltaX); 1587 EXPECT_EQ(-10, wheel_event->deltaY); 1588 EXPECT_EQ(mod, wheel_event->modifiers); 1589 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 1590 1591 // Send ack for #2. 1592 SendInputEventACK(WebInputEvent::MouseWheel, 1593 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 1594 EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount()); 1595 EXPECT_EQ(WebInputEvent::MouseWheel, ack_handler_->ack_event_type()); 1596 1597 // Verify we sent #3 (with #5 coalesced in). 1598 ASSERT_EQ(1U, process_->sink().message_count()); 1599 input_event = GetInputEventFromMessage(*process_->sink().GetMessageAt(0)); 1600 ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type); 1601 wheel_event = static_cast<const WebMouseWheelEvent*>(input_event); 1602 EXPECT_EQ(2, wheel_event->deltaX); 1603 EXPECT_EQ(PinchScaleToWheelDelta(1.5f), wheel_event->deltaY); 1604 EXPECT_EQ(mod, wheel_event->modifiers); 1605 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 1606 1607 // Send ack for #3. 1608 SendInputEventACK(WebInputEvent::MouseWheel, 1609 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 1610 EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount()); 1611 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, ack_handler_->ack_event_type()); 1612 1613 // Verify we sent #4. 1614 ASSERT_EQ(1U, process_->sink().message_count()); 1615 input_event = GetInputEventFromMessage(*process_->sink().GetMessageAt(0)); 1616 ASSERT_EQ(WebInputEvent::MouseWheel, input_event->type); 1617 wheel_event = static_cast<const WebMouseWheelEvent*>(input_event); 1618 EXPECT_EQ(0, wheel_event->deltaX); 1619 EXPECT_FLOAT_EQ(PinchScaleToWheelDelta(1.2f), wheel_event->deltaY); 1620 EXPECT_EQ(mod, wheel_event->modifiers); 1621 EXPECT_EQ(1U, GetSentMessageCountAndResetSink()); 1622 1623 // Send ack for #4. 1624 SendInputEventACK(WebInputEvent::MouseWheel, 1625 INPUT_EVENT_ACK_STATE_NOT_CONSUMED); 1626 EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount()); 1627 EXPECT_EQ(WebInputEvent::GesturePinchUpdate, ack_handler_->ack_event_type()); 1628} 1629 1630// Test proper handling of touchpad Gesture{Pinch,Scroll}Update sequences. 1631TEST_F(InputRouterImplTest, TouchpadPinchAndScrollUpdate) { 1632 // The first scroll should be sent immediately. 1633 SimulateGestureEvent(WebInputEvent::GestureScrollUpdate, 1634 blink::WebGestureDeviceTouchpad); 1635 ASSERT_EQ(1U, GetSentMessageCountAndResetSink()); 1636 EXPECT_EQ(1, client_->in_flight_event_count()); 1637 1638 // Subsequent scroll and pinch events should remain queued, coalescing as 1639 // more trackpad events arrive. 1640 SimulateGestureEvent(WebInputEvent::GesturePinchUpdate, 1641 blink::WebGestureDeviceTouchpad); 1642 ASSERT_EQ(0U, GetSentMessageCountAndResetSink()); 1643 EXPECT_EQ(1, client_->in_flight_event_count()); 1644 1645 SimulateGestureEvent(WebInputEvent::GestureScrollUpdate, 1646 blink::WebGestureDeviceTouchpad); 1647 ASSERT_EQ(0U, GetSentMessageCountAndResetSink()); 1648 EXPECT_EQ(1, client_->in_flight_event_count()); 1649 1650 SimulateGestureEvent(WebInputEvent::GesturePinchUpdate, 1651 blink::WebGestureDeviceTouchpad); 1652 ASSERT_EQ(0U, GetSentMessageCountAndResetSink()); 1653 EXPECT_EQ(1, client_->in_flight_event_count()); 1654 1655 SimulateGestureEvent(WebInputEvent::GestureScrollUpdate, 1656 blink::WebGestureDeviceTouchpad); 1657 ASSERT_EQ(0U, GetSentMessageCountAndResetSink()); 1658 EXPECT_EQ(1, client_->in_flight_event_count()); 1659 1660 // Ack'ing the first scroll should trigger both the coalesced scroll and the 1661 // coalesced pinch events (which is sent to the renderer as a wheel event). 1662 SendInputEventACK(WebInputEvent::GestureScrollUpdate, 1663 INPUT_EVENT_ACK_STATE_CONSUMED); 1664 EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount()); 1665 EXPECT_EQ(2U, GetSentMessageCountAndResetSink()); 1666 EXPECT_EQ(2, client_->in_flight_event_count()); 1667 1668 // Ack the second scroll. 1669 SendInputEventACK(WebInputEvent::GestureScrollUpdate, 1670 INPUT_EVENT_ACK_STATE_CONSUMED); 1671 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 1672 EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount()); 1673 EXPECT_EQ(1, client_->in_flight_event_count()); 1674 1675 // Ack the wheel event. 1676 SendInputEventACK(WebInputEvent::MouseWheel, INPUT_EVENT_ACK_STATE_CONSUMED); 1677 EXPECT_EQ(0U, GetSentMessageCountAndResetSink()); 1678 EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount()); 1679 EXPECT_EQ(0, client_->in_flight_event_count()); 1680} 1681 1682// Test proper routing of overscroll notifications received either from 1683// event acks or from |DidOverscroll| IPC messages. 1684TEST_F(InputRouterImplTest, OverscrollDispatch) { 1685 DidOverscrollParams overscroll; 1686 overscroll.accumulated_overscroll = gfx::Vector2dF(-14, 14); 1687 overscroll.latest_overscroll_delta = gfx::Vector2dF(-7, 0); 1688 overscroll.current_fling_velocity = gfx::Vector2dF(-1, 0); 1689 1690 input_router_->OnMessageReceived(InputHostMsg_DidOverscroll(0, overscroll)); 1691 DidOverscrollParams client_overscroll = client_->GetAndResetOverscroll(); 1692 EXPECT_EQ(overscroll.accumulated_overscroll, 1693 client_overscroll.accumulated_overscroll); 1694 EXPECT_EQ(overscroll.latest_overscroll_delta, 1695 client_overscroll.latest_overscroll_delta); 1696 EXPECT_EQ(overscroll.current_fling_velocity, 1697 client_overscroll.current_fling_velocity); 1698 1699 DidOverscrollParams wheel_overscroll; 1700 wheel_overscroll.accumulated_overscroll = gfx::Vector2dF(7, -7); 1701 wheel_overscroll.latest_overscroll_delta = gfx::Vector2dF(3, 0); 1702 wheel_overscroll.current_fling_velocity = gfx::Vector2dF(1, 0); 1703 1704 SimulateWheelEvent(3, 0, 0, false); 1705 InputHostMsg_HandleInputEvent_ACK_Params ack; 1706 ack.type = WebInputEvent::MouseWheel; 1707 ack.state = INPUT_EVENT_ACK_STATE_NOT_CONSUMED; 1708 ack.overscroll.reset(new DidOverscrollParams(wheel_overscroll)); 1709 input_router_->OnMessageReceived(InputHostMsg_HandleInputEvent_ACK(0, ack)); 1710 1711 client_overscroll = client_->GetAndResetOverscroll(); 1712 EXPECT_EQ(wheel_overscroll.accumulated_overscroll, 1713 client_overscroll.accumulated_overscroll); 1714 EXPECT_EQ(wheel_overscroll.latest_overscroll_delta, 1715 client_overscroll.latest_overscroll_delta); 1716 EXPECT_EQ(wheel_overscroll.current_fling_velocity, 1717 client_overscroll.current_fling_velocity); 1718} 1719 1720} // namespace content 1721