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 <utility> | 9 #include <utility> |
9 #include <vector> | 10 #include <vector> |
10 | 11 |
11 #include "base/bind.h" | 12 #include "base/bind.h" |
12 #include "base/macros.h" | 13 #include "base/macros.h" |
13 #include "base/threading/thread_task_runner_handle.h" | 14 #include "base/threading/thread_task_runner_handle.h" |
14 #include "build/build_config.h" | 15 #include "build/build_config.h" |
15 #include "content/common/input/synthetic_web_input_event_builders.h" | 16 #include "content/common/input/synthetic_web_input_event_builders.h" |
16 #include "content/common/input_messages.h" | 17 #include "content/common/input_messages.h" |
17 #include "content/common/view_messages.h" | 18 #include "content/common/view_messages.h" |
(...skipping 166 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
184 ASSERT_EQ(arraysize(kEvents), event_recorder_.record_count()); | 185 ASSERT_EQ(arraysize(kEvents), event_recorder_.record_count()); |
185 EXPECT_EQ(0U, message_recorder_.message_count()); | 186 EXPECT_EQ(0U, message_recorder_.message_count()); |
186 | 187 |
187 for (size_t i = 0; i < arraysize(kEvents); ++i) { | 188 for (size_t i = 0; i < arraysize(kEvents); ++i) { |
188 const IPC::Message* message = ipc_sink_.GetMessageAt(i); | 189 const IPC::Message* message = ipc_sink_.GetMessageAt(i); |
189 EXPECT_EQ(kTestRoutingID, message->routing_id()); | 190 EXPECT_EQ(kTestRoutingID, message->routing_id()); |
190 EXPECT_EQ(InputHostMsg_HandleInputEvent_ACK::ID, message->type()); | 191 EXPECT_EQ(InputHostMsg_HandleInputEvent_ACK::ID, message->type()); |
191 | 192 |
192 InputHostMsg_HandleInputEvent_ACK::Param params; | 193 InputHostMsg_HandleInputEvent_ACK::Param params; |
193 EXPECT_TRUE(InputHostMsg_HandleInputEvent_ACK::Read(message, ¶ms)); | 194 EXPECT_TRUE(InputHostMsg_HandleInputEvent_ACK::Read(message, ¶ms)); |
194 WebInputEvent::Type event_type = base::get<0>(params).type; | 195 WebInputEvent::Type event_type = std::get<0>(params).type; |
195 InputEventAckState ack_result = base::get<0>(params).state; | 196 InputEventAckState ack_result = std::get<0>(params).state; |
196 | 197 |
197 EXPECT_EQ(kEvents[i].type, event_type); | 198 EXPECT_EQ(kEvents[i].type, event_type); |
198 EXPECT_EQ(ack_result, INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS); | 199 EXPECT_EQ(ack_result, INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS); |
199 | 200 |
200 const WebInputEvent* event = event_recorder_.record_at(i); | 201 const WebInputEvent* event = event_recorder_.record_at(i); |
201 ASSERT_TRUE(event); | 202 ASSERT_TRUE(event); |
202 | 203 |
203 EXPECT_EQ(kEvents[i].size, event->size); | 204 EXPECT_EQ(kEvents[i].size, event->size); |
204 EXPECT_TRUE(memcmp(&kEvents[i], event, event->size) == 0); | 205 EXPECT_TRUE(memcmp(&kEvents[i], event, event->size) == 0); |
205 } | 206 } |
206 | 207 |
207 event_recorder_.set_send_to_widget(true); | 208 event_recorder_.set_send_to_widget(true); |
208 | 209 |
209 AddEventsToFilter(filter_.get(), kEvents, arraysize(kEvents)); | 210 AddEventsToFilter(filter_.get(), kEvents, arraysize(kEvents)); |
210 EXPECT_EQ(arraysize(kEvents), ipc_sink_.message_count()); | 211 EXPECT_EQ(arraysize(kEvents), ipc_sink_.message_count()); |
211 EXPECT_EQ(2 * arraysize(kEvents), event_recorder_.record_count()); | 212 EXPECT_EQ(2 * arraysize(kEvents), event_recorder_.record_count()); |
212 EXPECT_EQ(arraysize(kEvents), message_recorder_.message_count()); | 213 EXPECT_EQ(arraysize(kEvents), message_recorder_.message_count()); |
213 | 214 |
214 for (size_t i = 0; i < arraysize(kEvents); ++i) { | 215 for (size_t i = 0; i < arraysize(kEvents); ++i) { |
215 const IPC::Message& message = message_recorder_.message_at(i); | 216 const IPC::Message& message = message_recorder_.message_at(i); |
216 | 217 |
217 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); | 218 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); |
218 InputMsg_HandleInputEvent::Param params; | 219 InputMsg_HandleInputEvent::Param params; |
219 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); | 220 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); |
220 const WebInputEvent* event = base::get<0>(params); | 221 const WebInputEvent* event = std::get<0>(params); |
221 | 222 |
222 EXPECT_EQ(kEvents[i].size, event->size); | 223 EXPECT_EQ(kEvents[i].size, event->size); |
223 EXPECT_TRUE(memcmp(&kEvents[i], event, event->size) == 0); | 224 EXPECT_TRUE(memcmp(&kEvents[i], event, event->size) == 0); |
224 } | 225 } |
225 | 226 |
226 // Now reset everything, and test that DidHandleInputEvent is called. | 227 // Now reset everything, and test that DidHandleInputEvent is called. |
227 | 228 |
228 ipc_sink_.ClearMessages(); | 229 ipc_sink_.ClearMessages(); |
229 event_recorder_.Clear(); | 230 event_recorder_.Clear(); |
230 message_recorder_.Clear(); | 231 message_recorder_.Clear(); |
231 | 232 |
232 event_recorder_.set_handle_events(true); | 233 event_recorder_.set_handle_events(true); |
233 | 234 |
234 AddEventsToFilter(filter_.get(), kEvents, arraysize(kEvents)); | 235 AddEventsToFilter(filter_.get(), kEvents, arraysize(kEvents)); |
235 EXPECT_EQ(arraysize(kEvents), ipc_sink_.message_count()); | 236 EXPECT_EQ(arraysize(kEvents), ipc_sink_.message_count()); |
236 EXPECT_EQ(arraysize(kEvents), event_recorder_.record_count()); | 237 EXPECT_EQ(arraysize(kEvents), event_recorder_.record_count()); |
237 EXPECT_EQ(0U, message_recorder_.message_count()); | 238 EXPECT_EQ(0U, message_recorder_.message_count()); |
238 | 239 |
239 for (size_t i = 0; i < arraysize(kEvents); ++i) { | 240 for (size_t i = 0; i < arraysize(kEvents); ++i) { |
240 const IPC::Message* message = ipc_sink_.GetMessageAt(i); | 241 const IPC::Message* message = ipc_sink_.GetMessageAt(i); |
241 EXPECT_EQ(kTestRoutingID, message->routing_id()); | 242 EXPECT_EQ(kTestRoutingID, message->routing_id()); |
242 EXPECT_EQ(InputHostMsg_HandleInputEvent_ACK::ID, message->type()); | 243 EXPECT_EQ(InputHostMsg_HandleInputEvent_ACK::ID, message->type()); |
243 | 244 |
244 InputHostMsg_HandleInputEvent_ACK::Param params; | 245 InputHostMsg_HandleInputEvent_ACK::Param params; |
245 EXPECT_TRUE(InputHostMsg_HandleInputEvent_ACK::Read(message, ¶ms)); | 246 EXPECT_TRUE(InputHostMsg_HandleInputEvent_ACK::Read(message, ¶ms)); |
246 WebInputEvent::Type event_type = base::get<0>(params).type; | 247 WebInputEvent::Type event_type = std::get<0>(params).type; |
247 InputEventAckState ack_result = base::get<0>(params).state; | 248 InputEventAckState ack_result = std::get<0>(params).state; |
248 EXPECT_EQ(kEvents[i].type, event_type); | 249 EXPECT_EQ(kEvents[i].type, event_type); |
249 EXPECT_EQ(ack_result, INPUT_EVENT_ACK_STATE_CONSUMED); | 250 EXPECT_EQ(ack_result, INPUT_EVENT_ACK_STATE_CONSUMED); |
250 } | 251 } |
251 | 252 |
252 filter_->OnFilterRemoved(); | 253 filter_->OnFilterRemoved(); |
253 } | 254 } |
254 | 255 |
255 TEST_F(InputEventFilterTest, PreserveRelativeOrder) { | 256 TEST_F(InputEventFilterTest, PreserveRelativeOrder) { |
256 filter_->DidAddInputHandler(kTestRoutingID); | 257 filter_->DidAddInputHandler(kTestRoutingID); |
257 event_recorder_.set_send_to_widget(true); | 258 event_recorder_.set_send_to_widget(true); |
(...skipping 86 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
344 base::MessageLoop::current()->RunUntilIdle(); | 345 base::MessageLoop::current()->RunUntilIdle(); |
345 EXPECT_EQ(3u, message_recorder_.message_count()); | 346 EXPECT_EQ(3u, message_recorder_.message_count()); |
346 | 347 |
347 // First two messages should be identical. | 348 // First two messages should be identical. |
348 for (size_t i = 0; i < 2; ++i) { | 349 for (size_t i = 0; i < 2; ++i) { |
349 const IPC::Message& message = message_recorder_.message_at(i); | 350 const IPC::Message& message = message_recorder_.message_at(i); |
350 | 351 |
351 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); | 352 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); |
352 InputMsg_HandleInputEvent::Param params; | 353 InputMsg_HandleInputEvent::Param params; |
353 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); | 354 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); |
354 const WebInputEvent* event = base::get<0>(params); | 355 const WebInputEvent* event = std::get<0>(params); |
355 InputEventDispatchType dispatch_type = base::get<2>(params); | 356 InputEventDispatchType dispatch_type = std::get<2>(params); |
356 | 357 |
357 EXPECT_EQ(kEvents[i].size, event->size); | 358 EXPECT_EQ(kEvents[i].size, event->size); |
358 kEvents[i].dispatchType = | 359 kEvents[i].dispatchType = |
359 WebInputEvent::DispatchType::ListenersNonBlockingPassive; | 360 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
360 EXPECT_TRUE(memcmp(&kEvents[i], event, event->size) == 0); | 361 EXPECT_TRUE(memcmp(&kEvents[i], event, event->size) == 0); |
361 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN, | 362 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN, |
362 dispatch_type); | 363 dispatch_type); |
363 } | 364 } |
364 | 365 |
365 // Third message is coalesced. | 366 // Third message is coalesced. |
366 { | 367 { |
367 const IPC::Message& message = message_recorder_.message_at(2); | 368 const IPC::Message& message = message_recorder_.message_at(2); |
368 | 369 |
369 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); | 370 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); |
370 InputMsg_HandleInputEvent::Param params; | 371 InputMsg_HandleInputEvent::Param params; |
371 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); | 372 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); |
372 const WebMouseWheelEvent* event = | 373 const WebMouseWheelEvent* event = |
373 static_cast<const WebMouseWheelEvent*>(base::get<0>(params)); | 374 static_cast<const WebMouseWheelEvent*>(std::get<0>(params)); |
374 InputEventDispatchType dispatch_type = base::get<2>(params); | 375 InputEventDispatchType dispatch_type = std::get<2>(params); |
375 | 376 |
376 kEvents[2].dispatchType = | 377 kEvents[2].dispatchType = |
377 WebInputEvent::DispatchType::ListenersNonBlockingPassive; | 378 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
378 EXPECT_EQ(kEvents[2].size, event->size); | 379 EXPECT_EQ(kEvents[2].size, event->size); |
379 EXPECT_EQ(kEvents[2].deltaX + kEvents[3].deltaX, event->deltaX); | 380 EXPECT_EQ(kEvents[2].deltaX + kEvents[3].deltaX, event->deltaX); |
380 EXPECT_EQ(kEvents[2].deltaY + kEvents[3].deltaY, event->deltaY); | 381 EXPECT_EQ(kEvents[2].deltaY + kEvents[3].deltaY, event->deltaY); |
381 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN, | 382 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN, |
382 dispatch_type); | 383 dispatch_type); |
383 } | 384 } |
384 } | 385 } |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
422 base::MessageLoop::current()->RunUntilIdle(); | 423 base::MessageLoop::current()->RunUntilIdle(); |
423 EXPECT_EQ(3u, message_recorder_.message_count()); | 424 EXPECT_EQ(3u, message_recorder_.message_count()); |
424 | 425 |
425 // First two messages should be identical. | 426 // First two messages should be identical. |
426 for (size_t i = 0; i < 2; ++i) { | 427 for (size_t i = 0; i < 2; ++i) { |
427 const IPC::Message& message = message_recorder_.message_at(i); | 428 const IPC::Message& message = message_recorder_.message_at(i); |
428 | 429 |
429 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); | 430 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); |
430 InputMsg_HandleInputEvent::Param params; | 431 InputMsg_HandleInputEvent::Param params; |
431 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); | 432 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); |
432 const WebInputEvent* event = base::get<0>(params); | 433 const WebInputEvent* event = std::get<0>(params); |
433 InputEventDispatchType dispatch_type = base::get<2>(params); | 434 InputEventDispatchType dispatch_type = std::get<2>(params); |
434 | 435 |
435 EXPECT_EQ(kEvents[i].size, event->size); | 436 EXPECT_EQ(kEvents[i].size, event->size); |
436 kEvents[i].dispatchType = | 437 kEvents[i].dispatchType = |
437 WebInputEvent::DispatchType::ListenersNonBlockingPassive; | 438 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
438 EXPECT_TRUE(memcmp(&kEvents[i], event, event->size) == 0); | 439 EXPECT_TRUE(memcmp(&kEvents[i], event, event->size) == 0); |
439 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN, | 440 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN, |
440 dispatch_type); | 441 dispatch_type); |
441 } | 442 } |
442 | 443 |
443 // Third message is coalesced. | 444 // Third message is coalesced. |
444 { | 445 { |
445 const IPC::Message& message = message_recorder_.message_at(2); | 446 const IPC::Message& message = message_recorder_.message_at(2); |
446 | 447 |
447 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); | 448 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); |
448 InputMsg_HandleInputEvent::Param params; | 449 InputMsg_HandleInputEvent::Param params; |
449 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); | 450 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); |
450 const WebTouchEvent* event = | 451 const WebTouchEvent* event = |
451 static_cast<const WebTouchEvent*>(base::get<0>(params)); | 452 static_cast<const WebTouchEvent*>(std::get<0>(params)); |
452 InputEventDispatchType dispatch_type = base::get<2>(params); | 453 InputEventDispatchType dispatch_type = std::get<2>(params); |
453 | 454 |
454 EXPECT_EQ(kEvents[3].size, event->size); | 455 EXPECT_EQ(kEvents[3].size, event->size); |
455 EXPECT_EQ(1u, kEvents[3].touchesLength); | 456 EXPECT_EQ(1u, kEvents[3].touchesLength); |
456 EXPECT_EQ(kEvents[3].touches[0].position.x, event->touches[0].position.x); | 457 EXPECT_EQ(kEvents[3].touches[0].position.x, event->touches[0].position.x); |
457 EXPECT_EQ(kEvents[3].touches[0].position.y, event->touches[0].position.y); | 458 EXPECT_EQ(kEvents[3].touches[0].position.y, event->touches[0].position.y); |
458 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN, | 459 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN, |
459 dispatch_type); | 460 dispatch_type); |
460 } | 461 } |
461 } | 462 } |
462 | 463 |
(...skipping 18 matching lines...) Expand all Loading... |
481 ASSERT_EQ(3u, event_recorder_.record_count()); | 482 ASSERT_EQ(3u, event_recorder_.record_count()); |
482 | 483 |
483 { | 484 { |
484 // First event is sent right away. | 485 // First event is sent right away. |
485 EXPECT_EQ(1u, message_recorder_.message_count()); | 486 EXPECT_EQ(1u, message_recorder_.message_count()); |
486 | 487 |
487 const IPC::Message& message = message_recorder_.message_at(0); | 488 const IPC::Message& message = message_recorder_.message_at(0); |
488 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); | 489 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); |
489 InputMsg_HandleInputEvent::Param params; | 490 InputMsg_HandleInputEvent::Param params; |
490 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); | 491 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); |
491 const WebInputEvent* event = base::get<0>(params); | 492 const WebInputEvent* event = std::get<0>(params); |
492 InputEventDispatchType dispatch_type = base::get<2>(params); | 493 InputEventDispatchType dispatch_type = std::get<2>(params); |
493 | 494 |
494 EXPECT_EQ(kEvents[0].size, event->size); | 495 EXPECT_EQ(kEvents[0].size, event->size); |
495 kEvents[0].dispatchType = | 496 kEvents[0].dispatchType = |
496 WebInputEvent::DispatchType::ListenersNonBlockingPassive; | 497 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
497 EXPECT_TRUE(memcmp(&kEvents[0], event, event->size) == 0); | 498 EXPECT_TRUE(memcmp(&kEvents[0], event, event->size) == 0); |
498 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN, | 499 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN, |
499 dispatch_type); | 500 dispatch_type); |
500 } | 501 } |
501 | 502 |
502 { | 503 { |
503 // Second event was queued; ack the first. | 504 // Second event was queued; ack the first. |
504 filter_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::TouchStart); | 505 filter_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::TouchStart); |
505 base::MessageLoop::current()->RunUntilIdle(); | 506 base::MessageLoop::current()->RunUntilIdle(); |
506 EXPECT_EQ(2u, message_recorder_.message_count()); | 507 EXPECT_EQ(2u, message_recorder_.message_count()); |
507 | 508 |
508 const IPC::Message& message = message_recorder_.message_at(1); | 509 const IPC::Message& message = message_recorder_.message_at(1); |
509 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); | 510 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); |
510 InputMsg_HandleInputEvent::Param params; | 511 InputMsg_HandleInputEvent::Param params; |
511 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); | 512 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); |
512 const WebInputEvent* event = base::get<0>(params); | 513 const WebInputEvent* event = std::get<0>(params); |
513 InputEventDispatchType dispatch_type = base::get<2>(params); | 514 InputEventDispatchType dispatch_type = std::get<2>(params); |
514 | 515 |
515 EXPECT_EQ(kEvents[1].size, event->size); | 516 EXPECT_EQ(kEvents[1].size, event->size); |
516 kEvents[1].dispatchType = | 517 kEvents[1].dispatchType = |
517 WebInputEvent::DispatchType::ListenersNonBlockingPassive; | 518 WebInputEvent::DispatchType::ListenersNonBlockingPassive; |
518 EXPECT_TRUE(memcmp(&kEvents[1], event, event->size) == 0); | 519 EXPECT_TRUE(memcmp(&kEvents[1], event, event->size) == 0); |
519 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN, | 520 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN, |
520 dispatch_type); | 521 dispatch_type); |
521 } | 522 } |
522 | 523 |
523 { | 524 { |
524 // Third event should be put in the queue. | 525 // Third event should be put in the queue. |
525 filter_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::TouchEnd); | 526 filter_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::TouchEnd); |
526 base::MessageLoop::current()->RunUntilIdle(); | 527 base::MessageLoop::current()->RunUntilIdle(); |
527 EXPECT_EQ(3u, message_recorder_.message_count()); | 528 EXPECT_EQ(3u, message_recorder_.message_count()); |
528 | 529 |
529 const IPC::Message& message = message_recorder_.message_at(2); | 530 const IPC::Message& message = message_recorder_.message_at(2); |
530 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); | 531 ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type()); |
531 InputMsg_HandleInputEvent::Param params; | 532 InputMsg_HandleInputEvent::Param params; |
532 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); | 533 EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, ¶ms)); |
533 const WebInputEvent* event = base::get<0>(params); | 534 const WebInputEvent* event = std::get<0>(params); |
534 InputEventDispatchType dispatch_type = base::get<2>(params); | 535 InputEventDispatchType dispatch_type = std::get<2>(params); |
535 | 536 |
536 EXPECT_EQ(kBlockingEvents[0].size, event->size); | 537 EXPECT_EQ(kBlockingEvents[0].size, event->size); |
537 EXPECT_TRUE(memcmp(&kBlockingEvents[0], event, event->size) == 0); | 538 EXPECT_TRUE(memcmp(&kBlockingEvents[0], event, event->size) == 0); |
538 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_BLOCKING_NOTIFY_MAIN, | 539 EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_BLOCKING_NOTIFY_MAIN, |
539 dispatch_type); | 540 dispatch_type); |
540 } | 541 } |
541 } | 542 } |
542 | 543 |
543 } // namespace content | 544 } // namespace content |
OLD | NEW |