1 // Copyright (c) 2012 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 "ui/base/events/event_dispatcher.h" 6 7 #include "testing/gtest/include/gtest/gtest.h" 8 #include "ui/base/events/event.h" 9 #include "ui/base/events/event_utils.h" 10 11 namespace ui { 12 13 namespace { 14 15 class TestTarget : public EventTarget { 16 public: 17 TestTarget() : parent_(NULL), valid_(true) {} 18 virtual ~TestTarget() {} 19 20 void set_parent(TestTarget* parent) { parent_ = parent; } 21 22 bool valid() const { return valid_; } 23 void set_valid(bool valid) { valid_ = valid; } 24 25 void AddHandlerId(int id) { 26 handler_list_.push_back(id); 27 } 28 29 const std::vector<int>& handler_list() const { return handler_list_; } 30 31 void Reset() { 32 handler_list_.clear(); 33 valid_ = true; 34 } 35 36 private: 37 // Overridden from EventTarget: 38 virtual bool CanAcceptEvent(const ui::Event& event) OVERRIDE { 39 return true; 40 } 41 42 virtual EventTarget* GetParentTarget() OVERRIDE { 43 return parent_; 44 } 45 46 TestTarget* parent_; 47 std::vector<int> handler_list_; 48 bool valid_; 49 50 DISALLOW_COPY_AND_ASSIGN(TestTarget); 51 }; 52 53 class TestEventHandler : public EventHandler { 54 public: 55 TestEventHandler(int id) 56 : id_(id), 57 event_result_(ER_UNHANDLED), 58 expect_pre_target_(false), 59 expect_post_target_(false), 60 received_pre_target_(false) { 61 } 62 63 virtual ~TestEventHandler() {} 64 65 virtual void ReceivedEvent(Event* event) { 66 static_cast<TestTarget*>(event->target())->AddHandlerId(id_); 67 if (event->phase() == ui::EP_POSTTARGET) { 68 EXPECT_TRUE(expect_post_target_); 69 if (expect_pre_target_) 70 EXPECT_TRUE(received_pre_target_); 71 } else if (event->phase() == ui::EP_PRETARGET) { 72 EXPECT_TRUE(expect_pre_target_); 73 received_pre_target_ = true; 74 } else { 75 NOTREACHED(); 76 } 77 } 78 79 void set_event_result(EventResult result) { event_result_ = result; } 80 81 void set_expect_pre_target(bool expect) { expect_pre_target_ = expect; } 82 void set_expect_post_target(bool expect) { expect_post_target_ = expect; } 83 84 private: 85 // Overridden from EventHandler: 86 virtual void OnEvent(Event* event) OVERRIDE { 87 ui::EventHandler::OnEvent(event); 88 ReceivedEvent(event); 89 SetStatusOnEvent(event); 90 } 91 92 void SetStatusOnEvent(Event* event) { 93 if (event_result_ & ui::ER_CONSUMED) 94 event->StopPropagation(); 95 if (event_result_ & ui::ER_HANDLED) 96 event->SetHandled(); 97 } 98 99 int id_; 100 EventResult event_result_; 101 bool expect_pre_target_; 102 bool expect_post_target_; 103 bool received_pre_target_; 104 105 DISALLOW_COPY_AND_ASSIGN(TestEventHandler); 106 }; 107 108 class NonCancelableEvent : public Event { 109 public: 110 NonCancelableEvent() 111 : Event(ui::ET_CANCEL_MODE, ui::EventTimeForNow(), 0) { 112 set_cancelable(false); 113 } 114 115 virtual ~NonCancelableEvent() {} 116 117 private: 118 DISALLOW_COPY_AND_ASSIGN(NonCancelableEvent); 119 }; 120 121 // Destroys the dispatcher-delegate when it receives any event. 122 class EventHandlerDestroyDispatcherDelegate : public TestEventHandler { 123 public: 124 EventHandlerDestroyDispatcherDelegate(EventDispatcherDelegate* delegate, 125 int id) 126 : TestEventHandler(id), 127 dispatcher_delegate_(delegate) { 128 } 129 130 virtual ~EventHandlerDestroyDispatcherDelegate() {} 131 132 private: 133 virtual void ReceivedEvent(Event* event) OVERRIDE { 134 TestEventHandler::ReceivedEvent(event); 135 delete dispatcher_delegate_; 136 } 137 138 EventDispatcherDelegate* dispatcher_delegate_; 139 140 DISALLOW_COPY_AND_ASSIGN(EventHandlerDestroyDispatcherDelegate); 141 }; 142 143 // Invalidates the target when it receives any event. 144 class InvalidateTargetEventHandler : public TestEventHandler { 145 public: 146 explicit InvalidateTargetEventHandler(int id) : TestEventHandler(id) {} 147 virtual ~InvalidateTargetEventHandler() {} 148 149 private: 150 virtual void ReceivedEvent(Event* event) OVERRIDE { 151 TestEventHandler::ReceivedEvent(event); 152 TestTarget* target = static_cast<TestTarget*>(event->target()); 153 target->set_valid(false); 154 } 155 156 DISALLOW_COPY_AND_ASSIGN(InvalidateTargetEventHandler); 157 }; 158 159 // Destroys a second event handler when this handler gets an event. 160 // Optionally also destroys the dispatcher. 161 class EventHandlerDestroyer : public TestEventHandler { 162 public: 163 EventHandlerDestroyer(int id, EventHandler* destroy) 164 : TestEventHandler(id), 165 to_destroy_(destroy), 166 dispatcher_delegate_(NULL) { 167 } 168 169 virtual ~EventHandlerDestroyer() { 170 CHECK(!to_destroy_); 171 } 172 173 void set_dispatcher_delegate(EventDispatcherDelegate* dispatcher_delegate) { 174 dispatcher_delegate_ = dispatcher_delegate; 175 } 176 177 private: 178 virtual void ReceivedEvent(Event* event) OVERRIDE { 179 TestEventHandler::ReceivedEvent(event); 180 delete to_destroy_; 181 to_destroy_ = NULL; 182 183 if (dispatcher_delegate_) { 184 delete dispatcher_delegate_; 185 dispatcher_delegate_ = NULL; 186 } 187 } 188 189 EventHandler* to_destroy_; 190 EventDispatcherDelegate* dispatcher_delegate_; 191 192 DISALLOW_COPY_AND_ASSIGN(EventHandlerDestroyer); 193 }; 194 195 class TestEventDispatcher : public EventDispatcherDelegate { 196 public: 197 TestEventDispatcher() {} 198 199 virtual ~TestEventDispatcher() {} 200 201 void ProcessEvent(EventTarget* target, Event* event) { 202 DispatchEvent(target, event); 203 } 204 205 private: 206 // Overridden from EventDispatcherDelegate: 207 virtual bool CanDispatchToTarget(EventTarget* target) OVERRIDE { 208 TestTarget* test_target = static_cast<TestTarget*>(target); 209 return test_target->valid(); 210 } 211 212 DISALLOW_COPY_AND_ASSIGN(TestEventDispatcher); 213 }; 214 215 } // namespace 216 217 TEST(EventDispatcherTest, EventDispatchOrder) { 218 TestEventDispatcher dispatcher; 219 TestTarget parent, child; 220 TestEventHandler h1(1), h2(2), h3(3), h4(4); 221 TestEventHandler h5(5), h6(6), h7(7), h8(8); 222 223 child.set_parent(&parent); 224 225 parent.AddPreTargetHandler(&h1); 226 parent.AddPreTargetHandler(&h2); 227 228 child.AddPreTargetHandler(&h3); 229 child.AddPreTargetHandler(&h4); 230 231 h1.set_expect_pre_target(true); 232 h2.set_expect_pre_target(true); 233 h3.set_expect_pre_target(true); 234 h4.set_expect_pre_target(true); 235 236 child.AddPostTargetHandler(&h5); 237 child.AddPostTargetHandler(&h6); 238 239 parent.AddPostTargetHandler(&h7); 240 parent.AddPostTargetHandler(&h8); 241 242 h5.set_expect_post_target(true); 243 h6.set_expect_post_target(true); 244 h7.set_expect_post_target(true); 245 h8.set_expect_post_target(true); 246 247 MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4), 248 gfx::Point(3, 4), 0); 249 Event::DispatcherApi event_mod(&mouse); 250 dispatcher.ProcessEvent(&child, &mouse); 251 EXPECT_FALSE(mouse.stopped_propagation()); 252 EXPECT_FALSE(mouse.handled()); 253 254 { 255 int expected[] = { 1, 2, 3, 4, 5, 6, 7, 8 }; 256 EXPECT_EQ( 257 std::vector<int>(expected, expected + sizeof(expected) / sizeof(int)), 258 child.handler_list()); 259 } 260 261 child.Reset(); 262 event_mod.set_phase(EP_PREDISPATCH); 263 event_mod.set_result(ER_UNHANDLED); 264 265 h1.set_event_result(ER_HANDLED); 266 dispatcher.ProcessEvent(&child, &mouse); 267 EXPECT_EQ(EP_POSTDISPATCH, mouse.phase()); 268 EXPECT_FALSE(mouse.stopped_propagation()); 269 EXPECT_TRUE(mouse.handled()); 270 { 271 // |h1| marks the event as handled. So only the pre-target handlers should 272 // receive the event. 273 int expected[] = { 1, 2, 3, 4 }; 274 EXPECT_EQ( 275 std::vector<int>(expected, expected + sizeof(expected) / sizeof(int)), 276 child.handler_list()); 277 } 278 279 child.Reset(); 280 event_mod.set_phase(EP_PREDISPATCH); 281 event_mod.set_result(ER_UNHANDLED); 282 283 int nexpected[] = { 1, 2, 3, 4, 5 }; 284 h1.set_event_result(ER_UNHANDLED); 285 h5.set_event_result(ER_CONSUMED); 286 dispatcher.ProcessEvent(&child, &mouse); 287 EXPECT_EQ(EP_POSTDISPATCH, mouse.phase()); 288 EXPECT_TRUE(mouse.stopped_propagation()); 289 EXPECT_TRUE(mouse.handled()); 290 EXPECT_EQ( 291 std::vector<int>(nexpected, nexpected + sizeof(nexpected) / sizeof(int)), 292 child.handler_list()); 293 294 child.Reset(); 295 event_mod.set_phase(EP_PREDISPATCH); 296 event_mod.set_result(ER_UNHANDLED); 297 298 int exp[] = { 1 }; 299 h1.set_event_result(ER_CONSUMED); 300 dispatcher.ProcessEvent(&child, &mouse); 301 EXPECT_EQ(EP_POSTDISPATCH, mouse.phase()); 302 EXPECT_TRUE(mouse.stopped_propagation()); 303 EXPECT_TRUE(mouse.handled()); 304 EXPECT_EQ( 305 std::vector<int>(exp, exp + sizeof(exp) / sizeof(int)), 306 child.handler_list()); 307 } 308 309 // Tests that the event-phases are correct. 310 TEST(EventDispatcherTest, EventDispatchPhase) { 311 TestEventDispatcher dispatcher; 312 TestTarget target; 313 314 TestEventHandler handler(11); 315 316 target.AddPreTargetHandler(&handler); 317 target.AddPostTargetHandler(&handler); 318 handler.set_expect_pre_target(true); 319 handler.set_expect_post_target(true); 320 321 MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4), 322 gfx::Point(3, 4), 0); 323 Event::DispatcherApi event_mod(&mouse); 324 dispatcher.ProcessEvent(&target, &mouse); 325 EXPECT_EQ(ER_UNHANDLED, mouse.result()); 326 327 int handlers[] = { 11, 11 }; 328 EXPECT_EQ( 329 std::vector<int>(handlers, handlers + sizeof(handlers) / sizeof(int)), 330 target.handler_list()); 331 } 332 333 // Tests that if the dispatcher is destroyed in the middle of pre or post-target 334 // dispatching events, it doesn't cause a crash. 335 TEST(EventDispatcherTest, EventDispatcherDestroyedDuringDispatch) { 336 // Test for pre-target first. 337 { 338 TestEventDispatcher* dispatcher = new TestEventDispatcher(); 339 TestTarget target; 340 EventHandlerDestroyDispatcherDelegate handler(dispatcher, 5); 341 TestEventHandler h1(1), h2(2); 342 343 target.AddPreTargetHandler(&h1); 344 target.AddPreTargetHandler(&handler); 345 target.AddPreTargetHandler(&h2); 346 347 h1.set_expect_pre_target(true); 348 handler.set_expect_pre_target(true); 349 // |h2| should not receive any events at all since |handler| will have 350 // destroyed the dispatcher. 351 h2.set_expect_pre_target(false); 352 353 MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4), 354 gfx::Point(3, 4), 0); 355 Event::DispatcherApi event_mod(&mouse); 356 dispatcher->ProcessEvent(&target, &mouse); 357 EXPECT_EQ(ER_CONSUMED, mouse.result()); 358 EXPECT_EQ(2U, target.handler_list().size()); 359 EXPECT_EQ(1, target.handler_list()[0]); 360 EXPECT_EQ(5, target.handler_list()[1]); 361 } 362 363 // Test for non-cancelable event. 364 { 365 TestEventDispatcher* dispatcher = new TestEventDispatcher(); 366 TestTarget target; 367 EventHandlerDestroyDispatcherDelegate handler(dispatcher, 5); 368 TestEventHandler h1(1), h2(2); 369 370 target.AddPreTargetHandler(&h1); 371 target.AddPreTargetHandler(&handler); 372 target.AddPreTargetHandler(&h2); 373 374 h1.set_expect_pre_target(true); 375 handler.set_expect_pre_target(true); 376 // |h2| should not receive any events at all since |handler| will have 377 // destroyed the dispatcher. 378 h2.set_expect_pre_target(false); 379 380 NonCancelableEvent event; 381 Event::DispatcherApi event_mod(&event); 382 dispatcher->ProcessEvent(&target, &event); 383 EXPECT_EQ(2U, target.handler_list().size()); 384 EXPECT_EQ(1, target.handler_list()[0]); 385 EXPECT_EQ(5, target.handler_list()[1]); 386 } 387 388 // Now test for post-target. 389 { 390 TestEventDispatcher* dispatcher = new TestEventDispatcher(); 391 TestTarget target; 392 EventHandlerDestroyDispatcherDelegate handler(dispatcher, 5); 393 TestEventHandler h1(1), h2(2); 394 395 target.AddPostTargetHandler(&h1); 396 target.AddPostTargetHandler(&handler); 397 target.AddPostTargetHandler(&h2); 398 399 h1.set_expect_post_target(true); 400 handler.set_expect_post_target(true); 401 // |h2| should not receive any events at all since |handler| will have 402 // destroyed the dispatcher. 403 h2.set_expect_post_target(false); 404 405 MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4), 406 gfx::Point(3, 4), 0); 407 Event::DispatcherApi event_mod(&mouse); 408 dispatcher->ProcessEvent(&target, &mouse); 409 EXPECT_EQ(ER_CONSUMED, mouse.result()); 410 EXPECT_EQ(2U, target.handler_list().size()); 411 EXPECT_EQ(1, target.handler_list()[0]); 412 EXPECT_EQ(5, target.handler_list()[1]); 413 } 414 415 // Test for non-cancelable event. 416 { 417 TestEventDispatcher* dispatcher = new TestEventDispatcher(); 418 TestTarget target; 419 EventHandlerDestroyDispatcherDelegate handler(dispatcher, 5); 420 TestEventHandler h1(1), h2(2); 421 422 target.AddPostTargetHandler(&h1); 423 target.AddPostTargetHandler(&handler); 424 target.AddPostTargetHandler(&h2); 425 426 h1.set_expect_post_target(true); 427 handler.set_expect_post_target(true); 428 // |h2| should not receive any events at all since |handler| will have 429 // destroyed the dispatcher. 430 h2.set_expect_post_target(false); 431 432 NonCancelableEvent event; 433 Event::DispatcherApi event_mod(&event); 434 dispatcher->ProcessEvent(&target, &event); 435 EXPECT_EQ(2U, target.handler_list().size()); 436 EXPECT_EQ(1, target.handler_list()[0]); 437 EXPECT_EQ(5, target.handler_list()[1]); 438 } 439 } 440 441 // Tests that a target becoming invalid in the middle of pre- or post-target 442 // event processing aborts processing. 443 TEST(EventDispatcherTest, EventDispatcherInvalidateTarget) { 444 TestEventDispatcher dispatcher; 445 TestTarget target; 446 TestEventHandler h1(1); 447 InvalidateTargetEventHandler invalidate_handler(2); 448 TestEventHandler h3(3); 449 450 target.AddPreTargetHandler(&h1); 451 target.AddPreTargetHandler(&invalidate_handler); 452 target.AddPreTargetHandler(&h3); 453 454 h1.set_expect_pre_target(true); 455 invalidate_handler.set_expect_pre_target(true); 456 // |h3| should not receive events as the target will be invalidated. 457 h3.set_expect_pre_target(false); 458 459 MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4), gfx::Point(3, 4), 0); 460 dispatcher.ProcessEvent(&target, &mouse); 461 EXPECT_FALSE(target.valid()); 462 EXPECT_TRUE(mouse.stopped_propagation()); 463 EXPECT_EQ(2U, target.handler_list().size()); 464 EXPECT_EQ(1, target.handler_list()[0]); 465 EXPECT_EQ(2, target.handler_list()[1]); 466 467 // Test for non-cancelable event. 468 target.Reset(); 469 NonCancelableEvent event; 470 dispatcher.ProcessEvent(&target, &event); 471 EXPECT_FALSE(target.valid()); 472 EXPECT_TRUE(mouse.stopped_propagation()); 473 EXPECT_EQ(2U, target.handler_list().size()); 474 EXPECT_EQ(1, target.handler_list()[0]); 475 EXPECT_EQ(2, target.handler_list()[1]); 476 } 477 478 // Tests that if an event-handler gets destroyed during event-dispatch, it does 479 // not cause a crash. 480 TEST(EventDispatcherTest, EventHandlerDestroyedDuringDispatch) { 481 { 482 TestEventDispatcher dispatcher; 483 TestTarget target; 484 TestEventHandler h1(1); 485 TestEventHandler* h3 = new TestEventHandler(3); 486 EventHandlerDestroyer handle_destroyer(2, h3); 487 488 target.AddPreTargetHandler(&h1); 489 target.AddPreTargetHandler(&handle_destroyer); 490 target.AddPreTargetHandler(h3); 491 492 h1.set_expect_pre_target(true); 493 handle_destroyer.set_expect_pre_target(true); 494 // |h3| should not receive events since |handle_destroyer| will have 495 // destroyed it. 496 h3->set_expect_pre_target(false); 497 498 MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4), gfx::Point(3, 4), 0); 499 dispatcher.ProcessEvent(&target, &mouse); 500 EXPECT_FALSE(mouse.stopped_propagation()); 501 EXPECT_EQ(2U, target.handler_list().size()); 502 EXPECT_EQ(1, target.handler_list()[0]); 503 EXPECT_EQ(2, target.handler_list()[1]); 504 } 505 506 // Test for non-cancelable events. 507 { 508 TestEventDispatcher dispatcher; 509 TestTarget target; 510 TestEventHandler h1(1); 511 TestEventHandler* h3 = new TestEventHandler(3); 512 EventHandlerDestroyer handle_destroyer(2, h3); 513 514 target.AddPreTargetHandler(&h1); 515 target.AddPreTargetHandler(&handle_destroyer); 516 target.AddPreTargetHandler(h3); 517 518 h1.set_expect_pre_target(true); 519 handle_destroyer.set_expect_pre_target(true); 520 h3->set_expect_pre_target(false); 521 522 NonCancelableEvent event; 523 dispatcher.ProcessEvent(&target, &event); 524 EXPECT_EQ(2U, target.handler_list().size()); 525 EXPECT_EQ(1, target.handler_list()[0]); 526 EXPECT_EQ(2, target.handler_list()[1]); 527 } 528 } 529 530 // Tests that things work correctly if an event-handler destroys both the 531 // dispatcher and a handler. 532 TEST(EventDispatcherTest, EventHandlerAndDispatcherDestroyedDuringDispatch) { 533 { 534 TestEventDispatcher* dispatcher = new TestEventDispatcher(); 535 TestTarget target; 536 TestEventHandler h1(1); 537 TestEventHandler* h3 = new TestEventHandler(3); 538 EventHandlerDestroyer destroyer(2, h3); 539 540 target.AddPreTargetHandler(&h1); 541 target.AddPreTargetHandler(&destroyer); 542 target.AddPreTargetHandler(h3); 543 544 h1.set_expect_pre_target(true); 545 destroyer.set_expect_pre_target(true); 546 destroyer.set_dispatcher_delegate(dispatcher); 547 // |h3| should not receive events since |destroyer| will have destroyed 548 // it. 549 h3->set_expect_pre_target(false); 550 551 MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4), gfx::Point(3, 4), 0); 552 dispatcher->ProcessEvent(&target, &mouse); 553 EXPECT_TRUE(mouse.stopped_propagation()); 554 EXPECT_EQ(2U, target.handler_list().size()); 555 EXPECT_EQ(1, target.handler_list()[0]); 556 EXPECT_EQ(2, target.handler_list()[1]); 557 } 558 559 // Test for non-cancelable events. 560 { 561 TestEventDispatcher* dispatcher = new TestEventDispatcher(); 562 TestTarget target; 563 TestEventHandler h1(1); 564 TestEventHandler* h3 = new TestEventHandler(3); 565 EventHandlerDestroyer destroyer(2, h3); 566 567 target.AddPreTargetHandler(&h1); 568 target.AddPreTargetHandler(&destroyer); 569 target.AddPreTargetHandler(h3); 570 571 h1.set_expect_pre_target(true); 572 destroyer.set_expect_pre_target(true); 573 destroyer.set_dispatcher_delegate(dispatcher); 574 // |h3| should not receive events since |destroyer| will have destroyed 575 // it. 576 h3->set_expect_pre_target(false); 577 578 NonCancelableEvent event; 579 dispatcher->ProcessEvent(&target, &event); 580 EXPECT_EQ(2U, target.handler_list().size()); 581 EXPECT_EQ(1, target.handler_list()[0]); 582 EXPECT_EQ(2, target.handler_list()[1]); 583 } 584 } 585 586 } // namespace ui 587
