ui/events/event_dispatcher_unittest.cc

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