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/test/events_test_utils.h"
  11 #include "ui/events/test/test_event_handler.h"
  12 #include "ui/events/test/test_event_processor.h"
  13 #include "ui/events/test/test_event_target.h"
  14
  15 typedef std::vector<std::string> HandlerSequenceRecorder;
  16
  17 namespace ui {
  18 namespace test {
  19
  20 class EventProcessorTest : public testing::Test {
  21  public:
  22   EventProcessorTest() {}
  23   virtual ~EventProcessorTest() {}
  24
  25   // testing::Test:
  26   virtual void SetUp() override {
  27     processor_.SetRoot(scoped_ptr<EventTarget>(new TestEventTarget()));
  28     processor_.Reset();
  29     root()->SetEventTargeter(make_scoped_ptr(new EventTargeter()));
  30   }
  31
  32   TestEventTarget* root() {
  33     return static_cast<TestEventTarget*>(processor_.GetRootTarget());
  34   }
  35
  36   TestEventProcessor* processor() {
  37     return &processor_;
  38   }
  39
  40   void DispatchEvent(Event* event) {
  41     processor_.OnEventFromSource(event);
  42   }
  43
  44  protected:
  45   TestEventProcessor processor_;
  46
  47   DISALLOW_COPY_AND_ASSIGN(EventProcessorTest);
  48 };
  49
  50 TEST_F(EventProcessorTest, Basic) {
  51   scoped_ptr<TestEventTarget> child(new TestEventTarget());
  52   root()->AddChild(child.Pass());
  53
  54   MouseEvent mouse(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
  55                    EF_NONE, EF_NONE);
  56   DispatchEvent(&mouse);
  57   EXPECT_TRUE(root()->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
  58   EXPECT_FALSE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
  59
  60   root()->RemoveChild(root()->child_at(0));
  61   DispatchEvent(&mouse);
  62   EXPECT_TRUE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
  63 }
  64
  65 template<typename T>
  66 class BoundsEventTargeter : public EventTargeter {
  67  public:
  68   virtual ~BoundsEventTargeter() {}
  69
  70  protected:
  71   virtual bool SubtreeShouldBeExploredForEvent(
  72       EventTarget* target, const LocatedEvent& event) override {
  73     T* t = static_cast<T*>(target);
  74     return (t->bounds().Contains(event.location()));
  75   }
  76 };
  77
  78 class BoundsTestTarget : public TestEventTarget {
  79  public:
  80   BoundsTestTarget() {}
  81   virtual ~BoundsTestTarget() {}
  82
  83   void set_bounds(gfx::Rect rect) { bounds_ = rect; }
  84   gfx::Rect bounds() const { return bounds_; }
  85
  86   static void ConvertPointToTarget(BoundsTestTarget* source,
  87                                    BoundsTestTarget* target,
  88                                    gfx::Point* location) {
  89     gfx::Vector2d vector;
  90     if (source->Contains(target)) {
  91       for (; target && target != source;
  92            target = static_cast<BoundsTestTarget*>(target->parent())) {
  93         vector += target->bounds().OffsetFromOrigin();
  94       }
  95       *location -= vector;
  96     } else if (target->Contains(source)) {
  97       for (; source && source != target;
  98            source = static_cast<BoundsTestTarget*>(source->parent())) {
  99         vector += source->bounds().OffsetFromOrigin();
 100       }
 101       *location += vector;
 102     } else {
 103       NOTREACHED();
 104     }
 105   }
 106
 107  private:
 108   // EventTarget:
 109   virtual void ConvertEventToTarget(EventTarget* target,
 110                                     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), EF_NONE,
 145                    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), EF_NONE,
 157                     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                     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   virtual ~ReDispatchEventHandler() {}
 186
 187   // TestEventHandler:
 188   virtual 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(
 243       ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10), 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(
 258       ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10), 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                    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(
 296       ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10), 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(
 313       ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10), 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   virtual ~IgnoreEventTargeter() {}
 326
 327  private:
 328   // EventTargeter:
 329   virtual bool SubtreeShouldBeExploredForEvent(
 330       EventTarget* target, 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                    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                     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   virtual ~BubblingEventTargeter() {}
 368
 369  private:
 370   // EventTargeter:
 371   virtual EventTarget* FindTargetForEvent(EventTarget* root,
 372                                           Event* event) override {
 373     return initial_target_;
 374   }
 375
 376   virtual EventTarget* FindNextBestTarget(EventTarget* previous_target,
 377                                           Event* event) override {
 378     return previous_target->GetParentTarget();
 379   }
 380
 381   TestEventTarget* initial_target_;
 382
 383   DISALLOW_COPY_AND_ASSIGN(BubblingEventTargeter);
 384 };
 385
 386 // Tests that unhandled events are correctly dispatched to the next-best
 387 // target as decided by the BubblingEventTargeter.
 388 TEST_F(EventProcessorTest, DispatchToNextBestTarget) {
 389   scoped_ptr<TestEventTarget> child(new TestEventTarget());
 390   scoped_ptr<TestEventTarget> grandchild(new TestEventTarget());
 391
 392   root()->SetEventTargeter(
 393       scoped_ptr<EventTargeter>(new BubblingEventTargeter(grandchild.get())));
 394   child->AddChild(grandchild.Pass());
 395   root()->AddChild(child.Pass());
 396
 397   ASSERT_EQ(1u, root()->child_count());
 398   ASSERT_EQ(1u, root()->child_at(0)->child_count());
 399   ASSERT_EQ(0u, root()->child_at(0)->child_at(0)->child_count());
 400
 401   TestEventTarget* child_r = root()->child_at(0);
 402   TestEventTarget* grandchild_r = child_r->child_at(0);
 403
 404   // When the root has a BubblingEventTargeter installed, events targeted
 405   // at the grandchild target should be dispatched to all three targets.
 406   KeyEvent key_event(ET_KEY_PRESSED, VKEY_ESCAPE, EF_NONE);
 407   DispatchEvent(&key_event);
 408   EXPECT_TRUE(root()->DidReceiveEvent(ET_KEY_PRESSED));
 409   EXPECT_TRUE(child_r->DidReceiveEvent(ET_KEY_PRESSED));
 410   EXPECT_TRUE(grandchild_r->DidReceiveEvent(ET_KEY_PRESSED));
 411   root()->ResetReceivedEvents();
 412   child_r->ResetReceivedEvents();
 413   grandchild_r->ResetReceivedEvents();
 414
 415   // Add a pre-target handler on the child of the root that will mark the event
 416   // as handled. No targets in the hierarchy should receive the event.
 417   TestEventHandler handler;
 418   child_r->AddPreTargetHandler(&handler);
 419   key_event = KeyEvent(ET_KEY_PRESSED, VKEY_ESCAPE, EF_NONE);
 420   DispatchEvent(&key_event);
 421   EXPECT_FALSE(root()->DidReceiveEvent(ET_KEY_PRESSED));
 422   EXPECT_FALSE(child_r->DidReceiveEvent(ET_KEY_PRESSED));
 423   EXPECT_FALSE(grandchild_r->DidReceiveEvent(ET_KEY_PRESSED));
 424   EXPECT_EQ(1, handler.num_key_events());
 425   handler.Reset();
 426
 427   // Add a post-target handler on the child of the root that will mark the event
 428   // as handled. Only the grandchild (the initial target) should receive the
 429   // event.
 430   child_r->RemovePreTargetHandler(&handler);
 431   child_r->AddPostTargetHandler(&handler);
 432   key_event = KeyEvent(ET_KEY_PRESSED, VKEY_ESCAPE, EF_NONE);
 433   DispatchEvent(&key_event);
 434   EXPECT_FALSE(root()->DidReceiveEvent(ET_KEY_PRESSED));
 435   EXPECT_FALSE(child_r->DidReceiveEvent(ET_KEY_PRESSED));
 436   EXPECT_TRUE(grandchild_r->DidReceiveEvent(ET_KEY_PRESSED));
 437   EXPECT_EQ(1, handler.num_key_events());
 438   handler.Reset();
 439   grandchild_r->ResetReceivedEvents();
 440   child_r->RemovePostTargetHandler(&handler);
 441
 442   // Mark the event as handled when it reaches the EP_TARGET phase of
 443   // dispatch at the child of the root. The child and grandchild
 444   // targets should both receive the event, but the root should not.
 445   child_r->set_mark_events_as_handled(true);
 446   key_event = KeyEvent(ET_KEY_PRESSED, VKEY_ESCAPE, EF_NONE);
 447   DispatchEvent(&key_event);
 448   EXPECT_FALSE(root()->DidReceiveEvent(ET_KEY_PRESSED));
 449   EXPECT_TRUE(child_r->DidReceiveEvent(ET_KEY_PRESSED));
 450   EXPECT_TRUE(grandchild_r->DidReceiveEvent(ET_KEY_PRESSED));
 451   root()->ResetReceivedEvents();
 452   child_r->ResetReceivedEvents();
 453   grandchild_r->ResetReceivedEvents();
 454   child_r->set_mark_events_as_handled(false);
 455 }
 456
 457 // Tests that unhandled events are seen by the correct sequence of
 458 // targets, pre-target handlers, and post-target handlers when
 459 // a BubblingEventTargeter is installed on the root target.
 460 TEST_F(EventProcessorTest, HandlerSequence) {
 461   scoped_ptr<TestEventTarget> child(new TestEventTarget());
 462   scoped_ptr<TestEventTarget> grandchild(new TestEventTarget());
 463
 464   root()->SetEventTargeter(
 465       scoped_ptr<EventTargeter>(new BubblingEventTargeter(grandchild.get())));
 466   child->AddChild(grandchild.Pass());
 467   root()->AddChild(child.Pass());
 468
 469   ASSERT_EQ(1u, root()->child_count());
 470   ASSERT_EQ(1u, root()->child_at(0)->child_count());
 471   ASSERT_EQ(0u, root()->child_at(0)->child_at(0)->child_count());
 472
 473   TestEventTarget* child_r = root()->child_at(0);
 474   TestEventTarget* grandchild_r = child_r->child_at(0);
 475
 476   HandlerSequenceRecorder recorder;
 477   root()->set_target_name("R");
 478   root()->set_recorder(&recorder);
 479   child_r->set_target_name("C");
 480   child_r->set_recorder(&recorder);
 481   grandchild_r->set_target_name("G");
 482   grandchild_r->set_recorder(&recorder);
 483
 484   TestEventHandler pre_root;
 485   pre_root.set_handler_name("PreR");
 486   pre_root.set_recorder(&recorder);
 487   root()->AddPreTargetHandler(&pre_root);
 488
 489   TestEventHandler pre_child;
 490   pre_child.set_handler_name("PreC");
 491   pre_child.set_recorder(&recorder);
 492   child_r->AddPreTargetHandler(&pre_child);
 493
 494   TestEventHandler pre_grandchild;
 495   pre_grandchild.set_handler_name("PreG");
 496   pre_grandchild.set_recorder(&recorder);
 497   grandchild_r->AddPreTargetHandler(&pre_grandchild);
 498
 499   TestEventHandler post_root;
 500   post_root.set_handler_name("PostR");
 501   post_root.set_recorder(&recorder);
 502   root()->AddPostTargetHandler(&post_root);
 503
 504   TestEventHandler post_child;
 505   post_child.set_handler_name("PostC");
 506   post_child.set_recorder(&recorder);
 507   child_r->AddPostTargetHandler(&post_child);
 508
 509   TestEventHandler post_grandchild;
 510   post_grandchild.set_handler_name("PostG");
 511   post_grandchild.set_recorder(&recorder);
 512   grandchild_r->AddPostTargetHandler(&post_grandchild);
 513
 514   MouseEvent mouse(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
 515                    EF_NONE, EF_NONE);
 516   DispatchEvent(&mouse);
 517
 518   std::string expected[] = { "PreR", "PreC", "PreG", "G", "PostG", "PostC",
 519       "PostR", "PreR", "PreC", "C", "PostC", "PostR", "PreR", "R", "PostR" };
 520   EXPECT_EQ(std::vector<std::string>(
 521       expected, expected + arraysize(expected)), recorder);
 522 }
 523
 524 }  // namespace test
 525 }  // namespace ui