OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include <stddef.h> | 5 #include <stddef.h> |
6 | 6 |
7 #include <new> | 7 #include <new> |
8 #include <tuple> | 8 #include <tuple> |
9 #include <utility> | 9 #include <utility> |
10 #include <vector> | 10 #include <vector> |
(...skipping 194 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
205 | 205 |
206 EXPECT_EQ(kEvents[i].size, event->size); | 206 EXPECT_EQ(kEvents[i].size, event->size); |
207 EXPECT_TRUE(memcmp(&kEvents[i], event, event->size) == 0); | 207 EXPECT_TRUE(memcmp(&kEvents[i], event, event->size) == 0); |
208 } | 208 } |
209 | 209 |
210 event_recorder_.set_send_to_widget(true); | 210 event_recorder_.set_send_to_widget(true); |
211 | 211 |
212 AddEventsToFilter(filter_.get(), kEvents, arraysize(kEvents)); | 212 AddEventsToFilter(filter_.get(), kEvents, arraysize(kEvents)); |
213 EXPECT_EQ(arraysize(kEvents), ipc_sink_.message_count()); | 213 EXPECT_EQ(arraysize(kEvents), ipc_sink_.message_count()); |
214 EXPECT_EQ(2 * arraysize(kEvents), event_recorder_.record_count()); | 214 EXPECT_EQ(2 * arraysize(kEvents), event_recorder_.record_count()); |
215 EXPECT_EQ(arraysize(kEvents), message_recorder_.message_count()); | 215 EXPECT_EQ(1u, message_recorder_.message_count()); |
216 | 216 |
217 for (size_t i = 0; i < arraysize(kEvents); ++i) { | 217 { |
218 const IPC::Message& message = message_recorder_.message_at(i); | 218 const IPC::Message& message = message_recorder_.message_at(0); |
219 | 219 |
220 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); | 220 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); |
221 InputMsg_HandleInputEvent::Param params; | 221 InputMsg_HandleInputEvent::Param params; |
222 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); | 222 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); |
223 const WebInputEvent* event = std::get<0>(params); | 223 const WebInputEvent* event = std::get<0>(params); |
224 | 224 |
225 EXPECT_EQ(kEvents[i].size, event->size); | 225 EXPECT_EQ(kEvents[2].size, event->size); |
226 EXPECT_TRUE(memcmp(&kEvents[i], event, event->size) == 0); | 226 EXPECT_TRUE(memcmp(&kEvents[2], event, event->size) == 0); |
227 } | 227 } |
228 | 228 |
229 // Now reset everything, and test that DidHandleInputEvent is called. | 229 // Now reset everything, and test that DidHandleInputEvent is called. |
230 | 230 |
231 ipc_sink_.ClearMessages(); | 231 ipc_sink_.ClearMessages(); |
232 event_recorder_.Clear(); | 232 event_recorder_.Clear(); |
233 message_recorder_.Clear(); | 233 message_recorder_.Clear(); |
234 | 234 |
235 event_recorder_.set_handle_events(true); | 235 event_recorder_.set_handle_events(true); |
236 | 236 |
(...skipping 69 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
306 // We should have sent all messages back to the main thread and preserved | 306 // We should have sent all messages back to the main thread and preserved |
307 // their relative order. | 307 // their relative order. |
308 ASSERT_EQ(message_recorder_.message_count(), messages.size()); | 308 ASSERT_EQ(message_recorder_.message_count(), messages.size()); |
309 for (size_t i = 0; i < messages.size(); ++i) { | 309 for (size_t i = 0; i < messages.size(); ++i) { |
310 EXPECT_EQ(message_recorder_.message_at(i).type(), messages[i].type()) << i; | 310 EXPECT_EQ(message_recorder_.message_at(i).type(), messages[i].type()) << i; |
311 } | 311 } |
312 } | 312 } |
313 | 313 |
314 TEST_F(InputEventFilterTest, NonBlockingWheel) { | 314 TEST_F(InputEventFilterTest, NonBlockingWheel) { |
315 WebMouseWheelEvent kEvents[4] = { | 315 WebMouseWheelEvent kEvents[4] = { |
316 SyntheticWebMouseWheelEventBuilder::Build(10, 10, 0, 53, 0, false), | 316 SyntheticWebMouseWheelEventBuilder::Build(10, 10, 0, 53, 1, false), |
317 SyntheticWebMouseWheelEventBuilder::Build(20, 20, 0, 53, 0, false), | 317 SyntheticWebMouseWheelEventBuilder::Build(20, 20, 0, 53, 0, false), |
318 SyntheticWebMouseWheelEventBuilder::Build(30, 30, 0, 53, 1, false), | 318 SyntheticWebMouseWheelEventBuilder::Build(30, 30, 0, 53, 1, false), |
319 SyntheticWebMouseWheelEventBuilder::Build(30, 30, 0, 53, 1, false), | 319 SyntheticWebMouseWheelEventBuilder::Build(30, 30, 0, 53, 1, false), |
320 }; | 320 }; |
321 | 321 |
322 filter_->RegisterRoutingID(kTestRoutingID); | 322 filter_->RegisterRoutingID(kTestRoutingID); |
323 event_recorder_.set_send_to_widget(true); | 323 event_recorder_.set_send_to_widget(true); |
324 event_recorder_.set_passive(true); | 324 event_recorder_.set_passive(true); |
325 | 325 |
326 AddEventsToFilter(filter_.get(), kEvents, arraysize(kEvents)); | 326 AddEventsToFilter(filter_.get(), kEvents, arraysize(kEvents)); |
327 EXPECT_EQ(arraysize(kEvents), event_recorder_.record_count()); | 327 EXPECT_EQ(arraysize(kEvents), event_recorder_.record_count()); |
328 ASSERT_EQ(4u, ipc_sink_.message_count()); | 328 ASSERT_EQ(4u, ipc_sink_.message_count()); |
329 | 329 |
330 // First event is sent right away. | 330 // All events are handled, one is coalesced. |
331 EXPECT_EQ(1u, message_recorder_.message_count()); | |
332 | |
333 // Second event was queued; ack the first. | |
334 filter_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::MouseWheel, | |
335 INPUT_EVENT_ACK_STATE_CONSUMED); | |
336 base::RunLoop().RunUntilIdle(); | |
337 ASSERT_EQ(4u, ipc_sink_.message_count()); | |
338 EXPECT_EQ(2u, message_recorder_.message_count()); | |
339 | |
340 // Third event won't be coalesced into the second because modifiers are | |
341 // different. | |
342 filter_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::MouseWheel, | |
343 INPUT_EVENT_ACK_STATE_CONSUMED); | |
344 base::RunLoop().RunUntilIdle(); | |
345 EXPECT_EQ(3u, message_recorder_.message_count()); | |
346 | |
347 // The last events will be coalesced. | |
348 filter_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::MouseWheel, | |
349 INPUT_EVENT_ACK_STATE_CONSUMED); | |
350 base::RunLoop().RunUntilIdle(); | |
351 EXPECT_EQ(3u, message_recorder_.message_count()); | 331 EXPECT_EQ(3u, message_recorder_.message_count()); |
352 | 332 |
353 // First two messages should be identical. | 333 // First two messages should be identical. |
354 for (size_t i = 0; i < 2; ++i) { | 334 for (size_t i = 0; i < 2; ++i) { |
355 const IPC::Message& message = message_recorder_.message_at(i); | 335 const IPC::Message& message = message_recorder_.message_at(i); |
356 | 336 |
357 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); | 337 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); |
358 InputMsg_HandleInputEvent::Param params; | 338 InputMsg_HandleInputEvent::Param params; |
359 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); | 339 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); |
360 const WebInputEvent* event = std::get<0>(params); | 340 const WebInputEvent* event = std::get<0>(params); |
361 InputEventDispatchType dispatch_type = std::get<2>(params); | 341 InputEventDispatchType dispatch_type = std::get<2>(params); |
362 | 342 |
363 EXPECT_EQ(kEvents[i].size, event->size); | 343 EXPECT_EQ(kEvents[i].size, event->size); |
364 kEvents[i].dispatchType = | 344 kEvents[i].dispatchType = |
365 WebInputEvent::DispatchType::ListenersNonBlockingPassive; | 345 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
366 EXPECT_TRUE(memcmp(&kEvents[i], event, event->size) == 0); | 346 EXPECT_TRUE(memcmp(&kEvents[i], event, event->size) == 0); |
367 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN, | 347 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING, |
368 dispatch_type); | 348 dispatch_type); |
369 } | 349 } |
370 | 350 |
371 // Third message is coalesced. | 351 // Third message is coalesced. |
372 { | 352 { |
373 const IPC::Message& message = message_recorder_.message_at(2); | 353 const IPC::Message& message = message_recorder_.message_at(2); |
374 | 354 |
375 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); | 355 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); |
376 InputMsg_HandleInputEvent::Param params; | 356 InputMsg_HandleInputEvent::Param params; |
377 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); | 357 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); |
378 const WebMouseWheelEvent* event = | 358 const WebMouseWheelEvent* event = |
379 static_cast<const WebMouseWheelEvent*>(std::get<0>(params)); | 359 static_cast<const WebMouseWheelEvent*>(std::get<0>(params)); |
380 InputEventDispatchType dispatch_type = std::get<2>(params); | 360 InputEventDispatchType dispatch_type = std::get<2>(params); |
381 | 361 |
382 kEvents[2].dispatchType = | 362 kEvents[2].dispatchType = |
383 WebInputEvent::DispatchType::ListenersNonBlockingPassive; | 363 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
384 EXPECT_EQ(kEvents[2].size, event->size); | 364 EXPECT_EQ(kEvents[2].size, event->size); |
385 EXPECT_EQ(kEvents[2].deltaX + kEvents[3].deltaX, event->deltaX); | 365 EXPECT_EQ(kEvents[2].deltaX + kEvents[3].deltaX, event->deltaX); |
386 EXPECT_EQ(kEvents[2].deltaY + kEvents[3].deltaY, event->deltaY); | 366 EXPECT_EQ(kEvents[2].deltaY + kEvents[3].deltaY, event->deltaY); |
387 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN, | 367 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING, |
388 dispatch_type); | 368 dispatch_type); |
389 } | 369 } |
390 } | 370 } |
391 | 371 |
392 TEST_F(InputEventFilterTest, NonBlockingTouch) { | 372 TEST_F(InputEventFilterTest, NonBlockingTouch) { |
393 SyntheticWebTouchEvent kEvents[4]; | 373 SyntheticWebTouchEvent kEvents[4]; |
394 kEvents[0].PressPoint(10, 10); | 374 kEvents[0].PressPoint(10, 10); |
395 kEvents[1].PressPoint(10, 10); | 375 kEvents[1].PressPoint(10, 10); |
396 kEvents[1].modifiers = 1; | 376 kEvents[1].modifiers = 1; |
397 kEvents[1].MovePoint(0, 20, 20); | 377 kEvents[1].MovePoint(0, 20, 20); |
398 kEvents[2].PressPoint(10, 10); | 378 kEvents[2].PressPoint(10, 10); |
399 kEvents[2].MovePoint(0, 30, 30); | 379 kEvents[2].MovePoint(0, 30, 30); |
400 kEvents[3].PressPoint(10, 10); | 380 kEvents[3].PressPoint(10, 10); |
401 kEvents[3].MovePoint(0, 35, 35); | 381 kEvents[3].MovePoint(0, 35, 35); |
402 | 382 |
403 filter_->RegisterRoutingID(kTestRoutingID); | 383 filter_->RegisterRoutingID(kTestRoutingID); |
404 event_recorder_.set_send_to_widget(true); | 384 event_recorder_.set_send_to_widget(true); |
405 event_recorder_.set_passive(true); | 385 event_recorder_.set_passive(true); |
406 | 386 |
407 AddEventsToFilter(filter_.get(), kEvents, arraysize(kEvents)); | 387 AddEventsToFilter(filter_.get(), kEvents, arraysize(kEvents)); |
408 EXPECT_EQ(arraysize(kEvents), event_recorder_.record_count()); | 388 EXPECT_EQ(arraysize(kEvents), event_recorder_.record_count()); |
409 ASSERT_EQ(4u, ipc_sink_.message_count()); | 389 ASSERT_EQ(4u, ipc_sink_.message_count()); |
410 | 390 |
411 // First event is sent right away. | 391 // All events are handled and one set was coalesced. |
412 EXPECT_EQ(1u, message_recorder_.message_count()); | |
413 | |
414 // Second event was queued; ack the first. | |
415 filter_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::TouchStart, | |
416 INPUT_EVENT_ACK_STATE_CONSUMED); | |
417 base::RunLoop().RunUntilIdle(); | |
418 ASSERT_EQ(4u, ipc_sink_.message_count()); | |
419 EXPECT_EQ(2u, message_recorder_.message_count()); | |
420 | |
421 // Third event won't be coalesced into the second because modifiers are | |
422 // different. | |
423 filter_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::TouchMove, | |
424 INPUT_EVENT_ACK_STATE_CONSUMED); | |
425 base::RunLoop().RunUntilIdle(); | |
426 EXPECT_EQ(3u, message_recorder_.message_count()); | |
427 | |
428 // The last events will be coalesced. | |
429 filter_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::TouchMove, | |
430 INPUT_EVENT_ACK_STATE_CONSUMED); | |
431 base::RunLoop().RunUntilIdle(); | |
432 EXPECT_EQ(3u, message_recorder_.message_count()); | 392 EXPECT_EQ(3u, message_recorder_.message_count()); |
433 | 393 |
434 // First two messages should be identical. | 394 // First two messages should be identical. |
435 for (size_t i = 0; i < 2; ++i) { | 395 for (size_t i = 0; i < 2; ++i) { |
436 const IPC::Message& message = message_recorder_.message_at(i); | 396 const IPC::Message& message = message_recorder_.message_at(i); |
437 | 397 |
438 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); | 398 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); |
439 InputMsg_HandleInputEvent::Param params; | 399 InputMsg_HandleInputEvent::Param params; |
440 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); | 400 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); |
441 const WebInputEvent* event = std::get<0>(params); | 401 const WebInputEvent* event = std::get<0>(params); |
442 InputEventDispatchType dispatch_type = std::get<2>(params); | 402 InputEventDispatchType dispatch_type = std::get<2>(params); |
443 | 403 |
444 EXPECT_EQ(kEvents[i].size, event->size); | 404 EXPECT_EQ(kEvents[i].size, event->size); |
445 kEvents[i].dispatchType = | 405 kEvents[i].dispatchType = |
446 WebInputEvent::DispatchType::ListenersNonBlockingPassive; | 406 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
447 EXPECT_TRUE(memcmp(&kEvents[i], event, event->size) == 0); | 407 EXPECT_TRUE(memcmp(&kEvents[i], event, event->size) == 0); |
448 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN, | 408 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING, |
449 dispatch_type); | 409 dispatch_type); |
450 } | 410 } |
451 | 411 |
452 // Third message is coalesced. | 412 // Third message is coalesced. |
453 { | 413 { |
454 const IPC::Message& message = message_recorder_.message_at(2); | 414 const IPC::Message& message = message_recorder_.message_at(2); |
455 | 415 |
456 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); | 416 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); |
457 InputMsg_HandleInputEvent::Param params; | 417 InputMsg_HandleInputEvent::Param params; |
458 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); | 418 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); |
459 const WebTouchEvent* event = | 419 const WebTouchEvent* event = |
460 static_cast<const WebTouchEvent*>(std::get<0>(params)); | 420 static_cast<const WebTouchEvent*>(std::get<0>(params)); |
461 InputEventDispatchType dispatch_type = std::get<2>(params); | 421 InputEventDispatchType dispatch_type = std::get<2>(params); |
462 | 422 |
463 EXPECT_EQ(kEvents[3].size, event->size); | 423 EXPECT_EQ(kEvents[3].size, event->size); |
464 EXPECT_EQ(1u, kEvents[3].touchesLength); | 424 EXPECT_EQ(1u, kEvents[3].touchesLength); |
465 EXPECT_EQ(kEvents[3].touches[0].position.x, event->touches[0].position.x); | 425 EXPECT_EQ(kEvents[3].touches[0].position.x, event->touches[0].position.x); |
466 EXPECT_EQ(kEvents[3].touches[0].position.y, event->touches[0].position.y); | 426 EXPECT_EQ(kEvents[3].touches[0].position.y, event->touches[0].position.y); |
467 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN, | 427 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING, |
468 dispatch_type); | 428 dispatch_type); |
469 } | 429 } |
470 } | 430 } |
471 | 431 |
472 TEST_F(InputEventFilterTest, IntermingledNonBlockingTouch) { | 432 TEST_F(InputEventFilterTest, IntermingledNonBlockingTouch) { |
473 SyntheticWebTouchEvent kEvents[2]; | 433 SyntheticWebTouchEvent kEvents[2]; |
474 kEvents[0].PressPoint(10, 10); | 434 kEvents[0].PressPoint(10, 10); |
475 kEvents[1].PressPoint(10, 10); | 435 kEvents[1].PressPoint(10, 10); |
476 kEvents[1].ReleasePoint(0); | 436 kEvents[1].ReleasePoint(0); |
477 SyntheticWebTouchEvent kBlockingEvents[1]; | 437 SyntheticWebTouchEvent kBlockingEvents[1]; |
478 kBlockingEvents[0].PressPoint(10, 10); | 438 kBlockingEvents[0].PressPoint(10, 10); |
479 | 439 |
480 filter_->RegisterRoutingID(kTestRoutingID); | 440 filter_->RegisterRoutingID(kTestRoutingID); |
481 event_recorder_.set_send_to_widget(true); | 441 event_recorder_.set_send_to_widget(true); |
482 event_recorder_.set_passive(true); | 442 event_recorder_.set_passive(true); |
483 AddEventsToFilter(filter_.get(), kEvents, arraysize(kEvents)); | 443 AddEventsToFilter(filter_.get(), kEvents, arraysize(kEvents)); |
484 EXPECT_EQ(arraysize(kEvents), event_recorder_.record_count()); | 444 EXPECT_EQ(arraysize(kEvents), event_recorder_.record_count()); |
485 | 445 |
486 event_recorder_.set_passive(false); | 446 event_recorder_.set_passive(false); |
487 AddEventsToFilter(filter_.get(), kBlockingEvents, arraysize(kBlockingEvents)); | 447 AddEventsToFilter(filter_.get(), kBlockingEvents, arraysize(kBlockingEvents)); |
488 EXPECT_EQ(arraysize(kEvents) + arraysize(kBlockingEvents), | 448 EXPECT_EQ(arraysize(kEvents) + arraysize(kBlockingEvents), |
489 event_recorder_.record_count()); | 449 event_recorder_.record_count()); |
490 ASSERT_EQ(3u, event_recorder_.record_count()); | 450 ASSERT_EQ(3u, event_recorder_.record_count()); |
| 451 EXPECT_EQ(3u, message_recorder_.message_count()); |
491 | 452 |
492 { | 453 { |
493 // First event is sent right away. | |
494 EXPECT_EQ(1u, message_recorder_.message_count()); | |
495 | |
496 const IPC::Message& message = message_recorder_.message_at(0); | 454 const IPC::Message& message = message_recorder_.message_at(0); |
497 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); | 455 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); |
498 InputMsg_HandleInputEvent::Param params; | 456 InputMsg_HandleInputEvent::Param params; |
499 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); | 457 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); |
500 const WebInputEvent* event = std::get<0>(params); | 458 const WebInputEvent* event = std::get<0>(params); |
501 InputEventDispatchType dispatch_type = std::get<2>(params); | 459 InputEventDispatchType dispatch_type = std::get<2>(params); |
502 | 460 |
503 EXPECT_EQ(kEvents[0].size, event->size); | 461 EXPECT_EQ(kEvents[0].size, event->size); |
504 kEvents[0].dispatchType = | 462 kEvents[0].dispatchType = |
505 WebInputEvent::DispatchType::ListenersNonBlockingPassive; | 463 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
506 EXPECT_TRUE(memcmp(&kEvents[0], event, event->size) == 0); | 464 EXPECT_TRUE(memcmp(&kEvents[0], event, event->size) == 0); |
507 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN, | 465 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING, |
508 dispatch_type); | 466 dispatch_type); |
509 } | 467 } |
510 | 468 |
511 { | 469 { |
512 // Second event was queued; ack the first. | |
513 filter_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::TouchStart, | |
514 INPUT_EVENT_ACK_STATE_CONSUMED); | |
515 base::RunLoop().RunUntilIdle(); | |
516 EXPECT_EQ(2u, message_recorder_.message_count()); | |
517 | |
518 const IPC::Message& message = message_recorder_.message_at(1); | 470 const IPC::Message& message = message_recorder_.message_at(1); |
519 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); | 471 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); |
520 InputMsg_HandleInputEvent::Param params; | 472 InputMsg_HandleInputEvent::Param params; |
521 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); | 473 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); |
522 const WebInputEvent* event = std::get<0>(params); | 474 const WebInputEvent* event = std::get<0>(params); |
523 InputEventDispatchType dispatch_type = std::get<2>(params); | 475 InputEventDispatchType dispatch_type = std::get<2>(params); |
524 | 476 |
525 EXPECT_EQ(kEvents[1].size, event->size); | 477 EXPECT_EQ(kEvents[1].size, event->size); |
526 kEvents[1].dispatchType = | 478 kEvents[1].dispatchType = |
527 WebInputEvent::DispatchType::ListenersNonBlockingPassive; | 479 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
528 EXPECT_TRUE(memcmp(&kEvents[1], event, event->size) == 0); | 480 EXPECT_TRUE(memcmp(&kEvents[1], event, event->size) == 0); |
529 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN, | 481 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING, |
530 dispatch_type); | 482 dispatch_type); |
531 } | 483 } |
532 | 484 |
533 { | 485 { |
534 // Third event should be put in the queue. | |
535 filter_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::TouchEnd, | |
536 INPUT_EVENT_ACK_STATE_CONSUMED); | |
537 base::RunLoop().RunUntilIdle(); | |
538 EXPECT_EQ(3u, message_recorder_.message_count()); | |
539 | |
540 const IPC::Message& message = message_recorder_.message_at(2); | 486 const IPC::Message& message = message_recorder_.message_at(2); |
541 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); | 487 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); |
542 InputMsg_HandleInputEvent::Param params; | 488 InputMsg_HandleInputEvent::Param params; |
543 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); | 489 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); |
544 const WebInputEvent* event = std::get<0>(params); | 490 const WebInputEvent* event = std::get<0>(params); |
545 InputEventDispatchType dispatch_type = std::get<2>(params); | 491 InputEventDispatchType dispatch_type = std::get<2>(params); |
546 | 492 |
547 EXPECT_EQ(kBlockingEvents[0].size, event->size); | 493 EXPECT_EQ(kBlockingEvents[0].size, event->size); |
548 EXPECT_TRUE(memcmp(&kBlockingEvents[0], event, event->size) == 0); | 494 EXPECT_TRUE(memcmp(&kBlockingEvents[0], event, event->size) == 0); |
549 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_BLOCKING_NOTIFY_MAIN, | 495 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_BLOCKING, dispatch_type); |
550 dispatch_type); | |
551 } | 496 } |
552 } | 497 } |
553 | 498 |
554 } // namespace content | 499 } // namespace content |
OLD | NEW |