ui/events/event_processor_unittest.cc

   1 // Copyright (c) 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 <vector>
   6
   7 #include "testing/gtest/include/gtest/gtest.h"
   8 #include "ui/events/event.h"
   9 #include "ui/events/event_targeter.h"
  10 #include "ui/events/event_utils.h"
  11 #include "ui/events/test/events_test_utils.h"
  12 #include "ui/events/test/test_event_handler.h"
  13 #include "ui/events/test/test_event_processor.h"
  14 #include "ui/events/test/test_event_target.h"
  15
  16 typedef std::vector<std::string> HandlerSequenceRecorder;
  17
  18 namespace ui {
  19 namespace test {
  20
  21 class EventProcessorTest : public testing::Test {
  22  public:
  23   EventProcessorTest() {}
  24   ~EventProcessorTest() override {}
  25
  26   // testing::Test:
  27   void SetUp() override {
  28     processor_.SetRoot(scoped_ptr<EventTarget>(new TestEventTarget()));
  29     processor_.Reset();
  30     root()->SetEventTargeter(make_scoped_ptr(new EventTargeter()));
  31   }
  32
  33   TestEventTarget* root() {
  34     return static_cast<TestEventTarget*>(processor_.GetRootTarget());
  35   }
  36
  37   TestEventProcessor* processor() {
  38     return &processor_;
  39   }
  40
  41   void DispatchEvent(Event* event) {
  42     processor_.OnEventFromSource(event);
  43   }
  44
  45  protected:
  46   TestEventProcessor processor_;
  47
  48   DISALLOW_COPY_AND_ASSIGN(EventProcessorTest);
  49 };
  50
  51 TEST_F(EventProcessorTest, Basic) {
  52   scoped_ptr<TestEventTarget> child(new TestEventTarget());
  53   root()->AddChild(child.Pass());
  54
  55   MouseEvent mouse(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
  56                    EventTimeForNow(), EF_NONE, EF_NONE);
  57   DispatchEvent(&mouse);
  58   EXPECT_TRUE(root()->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
  59   EXPECT_FALSE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
  60
  61   root()->RemoveChild(root()->child_at(0));
  62   DispatchEvent(&mouse);
  63   EXPECT_TRUE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
  64 }
  65
  66 template<typename T>
  67 class BoundsEventTargeter : public EventTargeter {
  68  public:
  69   virtual ~BoundsEventTargeter() {}
  70
  71  protected:
  72   virtual bool SubtreeShouldBeExploredForEvent(
  73       EventTarget* target, const LocatedEvent& event) override {
  74     T* t = static_cast<T*>(target);
  75     return (t->bounds().Contains(event.location()));
  76   }
  77 };
  78
  79 class BoundsTestTarget : public TestEventTarget {
  80  public:
  81   BoundsTestTarget() {}
  82   ~BoundsTestTarget() override {}
  83
  84   void set_bounds(gfx::Rect rect) { bounds_ = rect; }
  85   gfx::Rect bounds() const { return bounds_; }
  86
  87   static void ConvertPointToTarget(BoundsTestTarget* source,
  88                                    BoundsTestTarget* target,
  89                                    gfx::Point* location) {
  90     gfx::Vector2d vector;
  91     if (source->Contains(target)) {
  92       for (; target && target != source;
  93            target = static_cast<BoundsTestTarget*>(target->parent())) {
  94         vector += target->bounds().OffsetFromOrigin();
  95       }
  96       *location -= vector;
  97     } else if (target->Contains(source)) {
  98       for (; source && source != target;
  99            source = static_cast<BoundsTestTarget*>(source->parent())) {
 100         vector += source->bounds().OffsetFromOrigin();
 101       }
 102       *location += vector;
 103     } else {
 104       NOTREACHED();
 105     }
 106   }
 107
 108  private:
 109   // EventTarget:
 110   void ConvertEventToTarget(EventTarget* target, LocatedEvent* event) override {
 111     event->ConvertLocationToTarget(this,
 112                                    static_cast<BoundsTestTarget*>(target));
 113   }
 114
 115   gfx::Rect bounds_;
 116
 117   DISALLOW_COPY_AND_ASSIGN(BoundsTestTarget);
 118 };
 119
 120 TEST_F(EventProcessorTest, Bounds) {
 121   scoped_ptr<BoundsTestTarget> parent(new BoundsTestTarget());
 122   scoped_ptr<BoundsTestTarget> child(new BoundsTestTarget());
 123   scoped_ptr<BoundsTestTarget> grandchild(new BoundsTestTarget());
 124
 125   parent->set_bounds(gfx::Rect(0, 0, 30, 30));
 126   child->set_bounds(gfx::Rect(5, 5, 20, 20));
 127   grandchild->set_bounds(gfx::Rect(5, 5, 5, 5));
 128
 129   child->AddChild(scoped_ptr<TestEventTarget>(grandchild.Pass()));
 130   parent->AddChild(scoped_ptr<TestEventTarget>(child.Pass()));
 131   root()->AddChild(scoped_ptr<TestEventTarget>(parent.Pass()));
 132
 133   ASSERT_EQ(1u, root()->child_count());
 134   ASSERT_EQ(1u, root()->child_at(0)->child_count());
 135   ASSERT_EQ(1u, root()->child_at(0)->child_at(0)->child_count());
 136
 137   TestEventTarget* parent_r = root()->child_at(0);
 138   TestEventTarget* child_r = parent_r->child_at(0);
 139   TestEventTarget* grandchild_r = child_r->child_at(0);
 140
 141   // Dispatch a mouse event that falls on the parent, but not on the child. When
 142   // the default event-targeter used, the event will still reach |grandchild|,
 143   // because the default targeter does not look at the bounds.
 144   MouseEvent mouse(ET_MOUSE_MOVED, gfx::Point(1, 1), gfx::Point(1, 1),
 145                    EventTimeForNow(), EF_NONE, EF_NONE);
 146   DispatchEvent(&mouse);
 147   EXPECT_FALSE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
 148   EXPECT_FALSE(parent_r->DidReceiveEvent(ET_MOUSE_MOVED));
 149   EXPECT_FALSE(child_r->DidReceiveEvent(ET_MOUSE_MOVED));
 150   EXPECT_TRUE(grandchild_r->DidReceiveEvent(ET_MOUSE_MOVED));
 151   grandchild_r->ResetReceivedEvents();
 152
 153   // Now install a targeter on the parent that looks at the bounds and makes
 154   // sure the event reaches the target only if the location of the event within
 155   // the bounds of the target.
 156   MouseEvent mouse2(ET_MOUSE_MOVED, gfx::Point(1, 1), gfx::Point(1, 1),
 157                     EventTimeForNow(), EF_NONE, EF_NONE);
 158   parent_r->SetEventTargeter(scoped_ptr<EventTargeter>(
 159       new BoundsEventTargeter<BoundsTestTarget>()));
 160   DispatchEvent(&mouse2);
 161   EXPECT_FALSE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
 162   EXPECT_TRUE(parent_r->DidReceiveEvent(ET_MOUSE_MOVED));
 163   EXPECT_FALSE(child_r->DidReceiveEvent(ET_MOUSE_MOVED));
 164   EXPECT_FALSE(grandchild_r->DidReceiveEvent(ET_MOUSE_MOVED));
 165   parent_r->ResetReceivedEvents();
 166
 167   MouseEvent second(ET_MOUSE_MOVED, gfx::Point(12, 12), gfx::Point(12, 12),
 168                     EventTimeForNow(), EF_NONE, EF_NONE);
 169   DispatchEvent(&second);
 170   EXPECT_FALSE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
 171   EXPECT_FALSE(parent_r->DidReceiveEvent(ET_MOUSE_MOVED));
 172   EXPECT_FALSE(child_r->DidReceiveEvent(ET_MOUSE_MOVED));
 173   EXPECT_TRUE(grandchild_r->DidReceiveEvent(ET_MOUSE_MOVED));
 174 }
 175
 176 // ReDispatchEventHandler is used to receive mouse events and forward them
 177 // to a specified EventProcessor. Verifies that the event has the correct
 178 // target and phase both before and after the nested event processing. Also
 179 // verifies that the location of the event remains the same after it has
 180 // been processed by the second EventProcessor.
 181 class ReDispatchEventHandler : public TestEventHandler {
 182  public:
 183   ReDispatchEventHandler(EventProcessor* processor, EventTarget* target)
 184       : processor_(processor), expected_target_(target) {}
 185   ~ReDispatchEventHandler() override {}
 186
 187   // TestEventHandler:
 188   void OnMouseEvent(MouseEvent* event) override {
 189     TestEventHandler::OnMouseEvent(event);
 190
 191     EXPECT_EQ(expected_target_, event->target());
 192     EXPECT_EQ(EP_TARGET, event->phase());
 193
 194     gfx::Point location(event->location());
 195     EventDispatchDetails details = processor_->OnEventFromSource(event);
 196     EXPECT_FALSE(details.dispatcher_destroyed);
 197     EXPECT_FALSE(details.target_destroyed);
 198
 199     // The nested event-processing should not have mutated the target,
 200     // phase, or location of |event|.
 201     EXPECT_EQ(expected_target_, event->target());
 202     EXPECT_EQ(EP_TARGET, event->phase());
 203     EXPECT_EQ(location, event->location());
 204   }
 205
 206  private:
 207   EventProcessor* processor_;
 208   EventTarget* expected_target_;
 209
 210   DISALLOW_COPY_AND_ASSIGN(ReDispatchEventHandler);
 211 };
 212
 213 // Verifies that the phase and target information of an event is not mutated
 214 // as a result of sending the event to an event processor while it is still
 215 // being processed by another event processor.
 216 TEST_F(EventProcessorTest, NestedEventProcessing) {
 217   // Add one child to the default event processor used in this test suite.
 218   scoped_ptr<TestEventTarget> child(new TestEventTarget());
 219   root()->AddChild(child.Pass());
 220
 221   // Define a second root target and child.
 222   scoped_ptr<EventTarget> second_root_scoped(new TestEventTarget());
 223   TestEventTarget* second_root =
 224       static_cast<TestEventTarget*>(second_root_scoped.get());
 225   second_root->SetEventTargeter(make_scoped_ptr(new EventTargeter()));
 226   scoped_ptr<TestEventTarget> second_child(new TestEventTarget());
 227   second_root->AddChild(second_child.Pass());
 228
 229   // Define a second event processor which owns the second root.
 230   scoped_ptr<TestEventProcessor> second_processor(new TestEventProcessor());
 231   second_processor->SetRoot(second_root_scoped.Pass());
 232
 233   // Indicate that an event which is dispatched to the child target owned by the
 234   // first event processor should be handled by |target_handler| instead.
 235   scoped_ptr<TestEventHandler> target_handler(
 236       new ReDispatchEventHandler(second_processor.get(), root()->child_at(0)));
 237   root()->child_at(0)->set_target_handler(target_handler.get());
 238
 239   // Dispatch a mouse event to the tree of event targets owned by the first
 240   // event processor, checking in ReDispatchEventHandler that the phase and
 241   // target information of the event is correct.
 242   MouseEvent mouse(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
 243                    EventTimeForNow(), EF_NONE, EF_NONE);
 244   DispatchEvent(&mouse);
 245
 246   // Verify also that |mouse| was seen by the child nodes contained in both
 247   // event processors and that the event was not handled.
 248   EXPECT_TRUE(root()->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
 249   EXPECT_TRUE(second_root->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
 250   EXPECT_FALSE(mouse.handled());
 251   second_root->child_at(0)->ResetReceivedEvents();
 252   root()->child_at(0)->ResetReceivedEvents();
 253
 254   // Indicate that the child of the second root should handle events, and
 255   // dispatch another mouse event to verify that it is marked as handled.
 256   second_root->child_at(0)->set_mark_events_as_handled(true);
 257   MouseEvent mouse2(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
 258                     EventTimeForNow(), EF_NONE, EF_NONE);
 259   DispatchEvent(&mouse2);
 260   EXPECT_TRUE(root()->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
 261   EXPECT_TRUE(second_root->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
 262   EXPECT_TRUE(mouse2.handled());
 263 }
 264
 265 // Verifies that OnEventProcessingFinished() is called when an event
 266 // has been handled.
 267 TEST_F(EventProcessorTest, OnEventProcessingFinished) {
 268   scoped_ptr<TestEventTarget> child(new TestEventTarget());
 269   child->set_mark_events_as_handled(true);
 270   root()->AddChild(child.Pass());
 271
 272   // Dispatch a mouse event. We expect the event to be seen by the target,
 273   // handled, and we expect OnEventProcessingFinished() to be invoked once.
 274   MouseEvent mouse(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
 275                    EventTimeForNow(), EF_NONE, EF_NONE);
 276   DispatchEvent(&mouse);
 277   EXPECT_TRUE(root()->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
 278   EXPECT_FALSE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
 279   EXPECT_TRUE(mouse.handled());
 280   EXPECT_EQ(1, processor()->num_times_processing_finished());
 281 }
 282
 283 // Verifies that OnEventProcessingStarted() has been called when starting to
 284 // process an event, and that processing does not take place if
 285 // OnEventProcessingStarted() marks the event as handled. Also verifies that
 286 // OnEventProcessingFinished() is also called in either case.
 287 TEST_F(EventProcessorTest, OnEventProcessingStarted) {
 288   scoped_ptr<TestEventTarget> child(new TestEventTarget());
 289   root()->AddChild(child.Pass());
 290
 291   // Dispatch a mouse event. We expect the event to be seen by the target,
 292   // OnEventProcessingStarted() should be called once, and
 293   // OnEventProcessingFinished() should be called once. The event should
 294   // remain unhandled.
 295   MouseEvent mouse(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
 296                    EventTimeForNow(), EF_NONE, EF_NONE);
 297   DispatchEvent(&mouse);
 298   EXPECT_TRUE(root()->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
 299   EXPECT_FALSE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
 300   EXPECT_FALSE(mouse.handled());
 301   EXPECT_EQ(1, processor()->num_times_processing_started());
 302   EXPECT_EQ(1, processor()->num_times_processing_finished());
 303   processor()->Reset();
 304   root()->ResetReceivedEvents();
 305   root()->child_at(0)->ResetReceivedEvents();
 306
 307   // Dispatch another mouse event, but with OnEventProcessingStarted() marking
 308   // the event as handled to prevent processing. We expect the event to not be
 309   // seen by the target this time, but OnEventProcessingStarted() and
 310   // OnEventProcessingFinished() should both still be called once.
 311   processor()->set_should_processing_occur(false);
 312   MouseEvent mouse2(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
 313                     EventTimeForNow(), EF_NONE, EF_NONE);
 314   DispatchEvent(&mouse2);
 315   EXPECT_FALSE(root()->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
 316   EXPECT_FALSE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
 317   EXPECT_TRUE(mouse2.handled());
 318   EXPECT_EQ(1, processor()->num_times_processing_started());
 319   EXPECT_EQ(1, processor()->num_times_processing_finished());
 320 }
 321
 322 class IgnoreEventTargeter : public EventTargeter {
 323  public:
 324   IgnoreEventTargeter() {}
 325   ~IgnoreEventTargeter() override {}
 326
 327  private:
 328   // EventTargeter:
 329   bool SubtreeShouldBeExploredForEvent(EventTarget* target,
 330                                        const LocatedEvent& event) override {
 331     return false;
 332   }
 333 };
 334
 335 // Verifies that the EventTargeter installed on an EventTarget can dictate
 336 // whether the target itself can process an event.
 337 TEST_F(EventProcessorTest, TargeterChecksOwningEventTarget) {
 338   scoped_ptr<TestEventTarget> child(new TestEventTarget());
 339   root()->AddChild(child.Pass());
 340
 341   MouseEvent mouse(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
 342                    EventTimeForNow(), EF_NONE, EF_NONE);
 343   DispatchEvent(&mouse);
 344   EXPECT_TRUE(root()->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
 345   EXPECT_FALSE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
 346   root()->child_at(0)->ResetReceivedEvents();
 347
 348   // Install an event handler on |child| which always prevents the target from
 349   // receiving event.
 350   root()->child_at(0)->SetEventTargeter(
 351       scoped_ptr<EventTargeter>(new IgnoreEventTargeter()));
 352   MouseEvent mouse2(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
 353                     EventTimeForNow(), EF_NONE, EF_NONE);
 354   DispatchEvent(&mouse2);
 355   EXPECT_FALSE(root()->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
 356   EXPECT_TRUE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
 357 }
 358
 359 // An EventTargeter which is used to allow a bubbling behaviour in event
 360 // dispatch: if an event is not handled after being dispatched to its
 361 // initial target, the event is dispatched to the next-best target as
 362 // specified by FindNextBestTarget().
 363 class BubblingEventTargeter : public EventTargeter {
 364  public:
 365   explicit BubblingEventTargeter(TestEventTarget* initial_target)
 366     : initial_target_(initial_target) {}
 367   ~BubblingEventTargeter() override {}
 368
 369  private:
 370   // EventTargeter:
 371   EventTarget* FindTargetForEvent(EventTarget* root, Event* event) override {
 372     return initial_target_;
 373   }
 374
 375   EventTarget* FindNextBestTarget(EventTarget* previous_target,
 376                                   Event* event) override {
 377     return previous_target->GetParentTarget();
 378   }
 379
 380   TestEventTarget* initial_target_;
 381
 382   DISALLOW_COPY_AND_ASSIGN(BubblingEventTargeter);
 383 };
 384
 385 // Tests that unhandled events are correctly dispatched to the next-best
 386 // target as decided by the BubblingEventTargeter.
 387 TEST_F(EventProcessorTest, DispatchToNextBestTarget) {
 388   scoped_ptr<TestEventTarget> child(new TestEventTarget());
 389   scoped_ptr<TestEventTarget> grandchild(new TestEventTarget());
 390
 391   root()->SetEventTargeter(
 392       scoped_ptr<EventTargeter>(new BubblingEventTargeter(grandchild.get())));
 393   child->AddChild(grandchild.Pass());
 394   root()->AddChild(child.Pass());
 395
 396   ASSERT_EQ(1u, root()->child_count());
 397   ASSERT_EQ(1u, root()->child_at(0)->child_count());
 398   ASSERT_EQ(0u, root()->child_at(0)->child_at(0)->child_count());
 399
 400   TestEventTarget* child_r = root()->child_at(0);
 401   TestEventTarget* grandchild_r = child_r->child_at(0);
 402
 403   // When the root has a BubblingEventTargeter installed, events targeted
 404   // at the grandchild target should be dispatched to all three targets.
 405   KeyEvent key_event(ET_KEY_PRESSED, VKEY_ESCAPE, EF_NONE);
 406   DispatchEvent(&key_event);
 407   EXPECT_TRUE(root()->DidReceiveEvent(ET_KEY_PRESSED));
 408   EXPECT_TRUE(child_r->DidReceiveEvent(ET_KEY_PRESSED));
 409   EXPECT_TRUE(grandchild_r->DidReceiveEvent(ET_KEY_PRESSED));
 410   root()->ResetReceivedEvents();
 411   child_r->ResetReceivedEvents();
 412   grandchild_r->ResetReceivedEvents();
 413
 414   // Add a pre-target handler on the child of the root that will mark the event
 415   // as handled. No targets in the hierarchy should receive the event.
 416   TestEventHandler handler;
 417   child_r->AddPreTargetHandler(&handler);
 418   key_event = KeyEvent(ET_KEY_PRESSED, VKEY_ESCAPE, EF_NONE);
 419   DispatchEvent(&key_event);
 420   EXPECT_FALSE(root()->DidReceiveEvent(ET_KEY_PRESSED));
 421   EXPECT_FALSE(child_r->DidReceiveEvent(ET_KEY_PRESSED));
 422   EXPECT_FALSE(grandchild_r->DidReceiveEvent(ET_KEY_PRESSED));
 423   EXPECT_EQ(1, handler.num_key_events());
 424   handler.Reset();
 425
 426   // Add a post-target handler on the child of the root that will mark the event
 427   // as handled. Only the grandchild (the initial target) should receive the
 428   // event.
 429   child_r->RemovePreTargetHandler(&handler);
 430   child_r->AddPostTargetHandler(&handler);
 431   key_event = KeyEvent(ET_KEY_PRESSED, VKEY_ESCAPE, EF_NONE);
 432   DispatchEvent(&key_event);
 433   EXPECT_FALSE(root()->DidReceiveEvent(ET_KEY_PRESSED));
 434   EXPECT_FALSE(child_r->DidReceiveEvent(ET_KEY_PRESSED));
 435   EXPECT_TRUE(grandchild_r->DidReceiveEvent(ET_KEY_PRESSED));
 436   EXPECT_EQ(1, handler.num_key_events());
 437   handler.Reset();
 438   grandchild_r->ResetReceivedEvents();
 439   child_r->RemovePostTargetHandler(&handler);
 440
 441   // Mark the event as handled when it reaches the EP_TARGET phase of
 442   // dispatch at the child of the root. The child and grandchild
 443   // targets should both receive the event, but the root should not.
 444   child_r->set_mark_events_as_handled(true);
 445   key_event = KeyEvent(ET_KEY_PRESSED, VKEY_ESCAPE, EF_NONE);
 446   DispatchEvent(&key_event);
 447   EXPECT_FALSE(root()->DidReceiveEvent(ET_KEY_PRESSED));
 448   EXPECT_TRUE(child_r->DidReceiveEvent(ET_KEY_PRESSED));
 449   EXPECT_TRUE(grandchild_r->DidReceiveEvent(ET_KEY_PRESSED));
 450   root()->ResetReceivedEvents();
 451   child_r->ResetReceivedEvents();
 452   grandchild_r->ResetReceivedEvents();
 453   child_r->set_mark_events_as_handled(false);
 454 }
 455
 456 // Tests that unhandled events are seen by the correct sequence of
 457 // targets, pre-target handlers, and post-target handlers when
 458 // a BubblingEventTargeter is installed on the root target.
 459 TEST_F(EventProcessorTest, HandlerSequence) {
 460   scoped_ptr<TestEventTarget> child(new TestEventTarget());
 461   scoped_ptr<TestEventTarget> grandchild(new TestEventTarget());
 462
 463   root()->SetEventTargeter(
 464       scoped_ptr<EventTargeter>(new BubblingEventTargeter(grandchild.get())));
 465   child->AddChild(grandchild.Pass());
 466   root()->AddChild(child.Pass());
 467
 468   ASSERT_EQ(1u, root()->child_count());
 469   ASSERT_EQ(1u, root()->child_at(0)->child_count());
 470   ASSERT_EQ(0u, root()->child_at(0)->child_at(0)->child_count());
 471
 472   TestEventTarget* child_r = root()->child_at(0);
 473   TestEventTarget* grandchild_r = child_r->child_at(0);
 474
 475   HandlerSequenceRecorder recorder;
 476   root()->set_target_name("R");
 477   root()->set_recorder(&recorder);
 478   child_r->set_target_name("C");
 479   child_r->set_recorder(&recorder);
 480   grandchild_r->set_target_name("G");
 481   grandchild_r->set_recorder(&recorder);
 482
 483   TestEventHandler pre_root;
 484   pre_root.set_handler_name("PreR");
 485   pre_root.set_recorder(&recorder);
 486   root()->AddPreTargetHandler(&pre_root);
 487
 488   TestEventHandler pre_child;
 489   pre_child.set_handler_name("PreC");
 490   pre_child.set_recorder(&recorder);
 491   child_r->AddPreTargetHandler(&pre_child);
 492
 493   TestEventHandler pre_grandchild;
 494   pre_grandchild.set_handler_name("PreG");
 495   pre_grandchild.set_recorder(&recorder);
 496   grandchild_r->AddPreTargetHandler(&pre_grandchild);
 497
 498   TestEventHandler post_root;
 499   post_root.set_handler_name("PostR");
 500   post_root.set_recorder(&recorder);
 501   root()->AddPostTargetHandler(&post_root);
 502
 503   TestEventHandler post_child;
 504   post_child.set_handler_name("PostC");
 505   post_child.set_recorder(&recorder);
 506   child_r->AddPostTargetHandler(&post_child);
 507
 508   TestEventHandler post_grandchild;
 509   post_grandchild.set_handler_name("PostG");
 510   post_grandchild.set_recorder(&recorder);
 511   grandchild_r->AddPostTargetHandler(&post_grandchild);
 512
 513   MouseEvent mouse(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
 514                    EventTimeForNow(), EF_NONE, EF_NONE);
 515   DispatchEvent(&mouse);
 516
 517   std::string expected[] = { "PreR", "PreC", "PreG", "G", "PostG", "PostC",
 518       "PostR", "PreR", "PreC", "C", "PostC", "PostR", "PreR", "R", "PostR" };
 519   EXPECT_EQ(std::vector<std::string>(
 520       expected, expected + arraysize(expected)), recorder);
 521 }
 522
 523 }  // namespace test
 524 }  // namespace ui