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     root()->SetEventTargeter(make_scoped_ptr(new EventTargeter()));
  29   }
  30
  31   TestEventTarget* root() {
  32     return static_cast<TestEventTarget*>(processor_.GetRootTarget());
  33   }
  34
  35   void DispatchEvent(Event* event) {
  36     processor_.OnEventFromSource(event);
  37   }
  38
  39  protected:
  40   TestEventProcessor processor_;
  41
  42   DISALLOW_COPY_AND_ASSIGN(EventProcessorTest);
  43 };
  44
  45 TEST_F(EventProcessorTest, Basic) {
  46   scoped_ptr<TestEventTarget> child(new TestEventTarget());
  47   root()->AddChild(child.Pass());
  48
  49   MouseEvent mouse(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
  50                    EF_NONE, EF_NONE);
  51   DispatchEvent(&mouse);
  52   EXPECT_TRUE(root()->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
  53   EXPECT_FALSE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
  54
  55   root()->RemoveChild(root()->child_at(0));
  56   DispatchEvent(&mouse);
  57   EXPECT_TRUE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
  58 }
  59
  60 template<typename T>
  61 class BoundsEventTargeter : public EventTargeter {
  62  public:
  63   virtual ~BoundsEventTargeter() {}
  64
  65  protected:
  66   virtual bool SubtreeShouldBeExploredForEvent(
  67       EventTarget* target, const LocatedEvent& event) OVERRIDE {
  68     T* t = static_cast<T*>(target);
  69     return (t->bounds().Contains(event.location()));
  70   }
  71 };
  72
  73 class BoundsTestTarget : public TestEventTarget {
  74  public:
  75   BoundsTestTarget() {}
  76   virtual ~BoundsTestTarget() {}
  77
  78   void set_bounds(gfx::Rect rect) { bounds_ = rect; }
  79   gfx::Rect bounds() const { return bounds_; }
  80
  81   static void ConvertPointToTarget(BoundsTestTarget* source,
  82                                    BoundsTestTarget* target,
  83                                    gfx::Point* location) {
  84     gfx::Vector2d vector;
  85     if (source->Contains(target)) {
  86       for (; target && target != source;
  87            target = static_cast<BoundsTestTarget*>(target->parent())) {
  88         vector += target->bounds().OffsetFromOrigin();
  89       }
  90       *location -= vector;
  91     } else if (target->Contains(source)) {
  92       for (; source && source != target;
  93            source = static_cast<BoundsTestTarget*>(source->parent())) {
  94         vector += source->bounds().OffsetFromOrigin();
  95       }
  96       *location += vector;
  97     } else {
  98       NOTREACHED();
  99     }
 100   }
 101
 102  private:
 103   // EventTarget:
 104   virtual void ConvertEventToTarget(EventTarget* target,
 105                                     LocatedEvent* event) OVERRIDE {
 106     event->ConvertLocationToTarget(this,
 107                                    static_cast<BoundsTestTarget*>(target));
 108   }
 109
 110   gfx::Rect bounds_;
 111
 112   DISALLOW_COPY_AND_ASSIGN(BoundsTestTarget);
 113 };
 114
 115 TEST_F(EventProcessorTest, Bounds) {
 116   scoped_ptr<BoundsTestTarget> parent(new BoundsTestTarget());
 117   scoped_ptr<BoundsTestTarget> child(new BoundsTestTarget());
 118   scoped_ptr<BoundsTestTarget> grandchild(new BoundsTestTarget());
 119
 120   parent->set_bounds(gfx::Rect(0, 0, 30, 30));
 121   child->set_bounds(gfx::Rect(5, 5, 20, 20));
 122   grandchild->set_bounds(gfx::Rect(5, 5, 5, 5));
 123
 124   child->AddChild(scoped_ptr<TestEventTarget>(grandchild.Pass()));
 125   parent->AddChild(scoped_ptr<TestEventTarget>(child.Pass()));
 126   root()->AddChild(scoped_ptr<TestEventTarget>(parent.Pass()));
 127
 128   ASSERT_EQ(1u, root()->child_count());
 129   ASSERT_EQ(1u, root()->child_at(0)->child_count());
 130   ASSERT_EQ(1u, root()->child_at(0)->child_at(0)->child_count());
 131
 132   TestEventTarget* parent_r = root()->child_at(0);
 133   TestEventTarget* child_r = parent_r->child_at(0);
 134   TestEventTarget* grandchild_r = child_r->child_at(0);
 135
 136   // Dispatch a mouse event that falls on the parent, but not on the child. When
 137   // the default event-targeter used, the event will still reach |grandchild|,
 138   // because the default targeter does not look at the bounds.
 139   MouseEvent mouse(ET_MOUSE_MOVED, gfx::Point(1, 1), gfx::Point(1, 1), EF_NONE,
 140                    EF_NONE);
 141   DispatchEvent(&mouse);
 142   EXPECT_FALSE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
 143   EXPECT_FALSE(parent_r->DidReceiveEvent(ET_MOUSE_MOVED));
 144   EXPECT_FALSE(child_r->DidReceiveEvent(ET_MOUSE_MOVED));
 145   EXPECT_TRUE(grandchild_r->DidReceiveEvent(ET_MOUSE_MOVED));
 146   grandchild_r->ResetReceivedEvents();
 147
 148   // Now install a targeter on the parent that looks at the bounds and makes
 149   // sure the event reaches the target only if the location of the event within
 150   // the bounds of the target.
 151   MouseEvent mouse2(ET_MOUSE_MOVED, gfx::Point(1, 1), gfx::Point(1, 1), EF_NONE,
 152                     EF_NONE);
 153   parent_r->SetEventTargeter(scoped_ptr<EventTargeter>(
 154       new BoundsEventTargeter<BoundsTestTarget>()));
 155   DispatchEvent(&mouse2);
 156   EXPECT_FALSE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
 157   EXPECT_TRUE(parent_r->DidReceiveEvent(ET_MOUSE_MOVED));
 158   EXPECT_FALSE(child_r->DidReceiveEvent(ET_MOUSE_MOVED));
 159   EXPECT_FALSE(grandchild_r->DidReceiveEvent(ET_MOUSE_MOVED));
 160   parent_r->ResetReceivedEvents();
 161
 162   MouseEvent second(ET_MOUSE_MOVED, gfx::Point(12, 12), gfx::Point(12, 12),
 163                     EF_NONE, EF_NONE);
 164   DispatchEvent(&second);
 165   EXPECT_FALSE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
 166   EXPECT_FALSE(parent_r->DidReceiveEvent(ET_MOUSE_MOVED));
 167   EXPECT_FALSE(child_r->DidReceiveEvent(ET_MOUSE_MOVED));
 168   EXPECT_TRUE(grandchild_r->DidReceiveEvent(ET_MOUSE_MOVED));
 169 }
 170
 171 class IgnoreEventTargeter : public EventTargeter {
 172  public:
 173   IgnoreEventTargeter() {}
 174   virtual ~IgnoreEventTargeter() {}
 175
 176  private:
 177   // EventTargeter:
 178   virtual bool SubtreeShouldBeExploredForEvent(
 179       EventTarget* target, const LocatedEvent& event) OVERRIDE {
 180     return false;
 181   }
 182 };
 183
 184 // Verifies that the EventTargeter installed on an EventTarget can dictate
 185 // whether the target itself can process an event.
 186 TEST_F(EventProcessorTest, TargeterChecksOwningEventTarget) {
 187   scoped_ptr<TestEventTarget> child(new TestEventTarget());
 188   root()->AddChild(child.Pass());
 189
 190   MouseEvent mouse(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
 191                    EF_NONE, EF_NONE);
 192   DispatchEvent(&mouse);
 193   EXPECT_TRUE(root()->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
 194   EXPECT_FALSE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
 195   root()->child_at(0)->ResetReceivedEvents();
 196
 197   // Install an event handler on |child| which always prevents the target from
 198   // receiving event.
 199   root()->child_at(0)->SetEventTargeter(
 200       scoped_ptr<EventTargeter>(new IgnoreEventTargeter()));
 201   MouseEvent mouse2(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
 202                     EF_NONE, EF_NONE);
 203   DispatchEvent(&mouse2);
 204   EXPECT_FALSE(root()->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
 205   EXPECT_TRUE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
 206 }
 207
 208 // An EventTargeter which is used to allow a bubbling behaviour in event
 209 // dispatch: if an event is not handled after being dispatched to its
 210 // initial target, the event is dispatched to the next-best target as
 211 // specified by FindNextBestTarget().
 212 class BubblingEventTargeter : public EventTargeter {
 213  public:
 214   explicit BubblingEventTargeter(TestEventTarget* initial_target)
 215     : initial_target_(initial_target) {}
 216   virtual ~BubblingEventTargeter() {}
 217
 218  private:
 219   // EventTargeter:
 220   virtual EventTarget* FindTargetForEvent(EventTarget* root,
 221                                           Event* event) OVERRIDE {
 222     return initial_target_;
 223   }
 224
 225   virtual EventTarget* FindNextBestTarget(EventTarget* previous_target,
 226                                           Event* event) OVERRIDE {
 227     return previous_target->GetParentTarget();
 228   }
 229
 230   TestEventTarget* initial_target_;
 231
 232   DISALLOW_COPY_AND_ASSIGN(BubblingEventTargeter);
 233 };
 234
 235 // Tests that unhandled events are correctly dispatched to the next-best
 236 // target as decided by the BubblingEventTargeter.
 237 TEST_F(EventProcessorTest, DispatchToNextBestTarget) {
 238   scoped_ptr<TestEventTarget> child(new TestEventTarget());
 239   scoped_ptr<TestEventTarget> grandchild(new TestEventTarget());
 240
 241   root()->SetEventTargeter(
 242       scoped_ptr<EventTargeter>(new BubblingEventTargeter(grandchild.get())));
 243   child->AddChild(grandchild.Pass());
 244   root()->AddChild(child.Pass());
 245
 246   ASSERT_EQ(1u, root()->child_count());
 247   ASSERT_EQ(1u, root()->child_at(0)->child_count());
 248   ASSERT_EQ(0u, root()->child_at(0)->child_at(0)->child_count());
 249
 250   TestEventTarget* child_r = root()->child_at(0);
 251   TestEventTarget* grandchild_r = child_r->child_at(0);
 252
 253   // When the root has a BubblingEventTargeter installed, events targeted
 254   // at the grandchild target should be dispatched to all three targets.
 255   KeyEvent key_event(ET_KEY_PRESSED, VKEY_ESCAPE, 0, false);
 256   DispatchEvent(&key_event);
 257   EXPECT_TRUE(root()->DidReceiveEvent(ET_KEY_PRESSED));
 258   EXPECT_TRUE(child_r->DidReceiveEvent(ET_KEY_PRESSED));
 259   EXPECT_TRUE(grandchild_r->DidReceiveEvent(ET_KEY_PRESSED));
 260   root()->ResetReceivedEvents();
 261   child_r->ResetReceivedEvents();
 262   grandchild_r->ResetReceivedEvents();
 263
 264   // Add a pre-target handler on the child of the root that will mark the event
 265   // as handled. No targets in the hierarchy should receive the event.
 266   TestEventHandler handler;
 267   child_r->AddPreTargetHandler(&handler);
 268   key_event = KeyEvent(ET_KEY_PRESSED, VKEY_ESCAPE, 0, false);
 269   DispatchEvent(&key_event);
 270   EXPECT_FALSE(root()->DidReceiveEvent(ET_KEY_PRESSED));
 271   EXPECT_FALSE(child_r->DidReceiveEvent(ET_KEY_PRESSED));
 272   EXPECT_FALSE(grandchild_r->DidReceiveEvent(ET_KEY_PRESSED));
 273   EXPECT_EQ(1, handler.num_key_events());
 274   handler.Reset();
 275
 276   // Add a post-target handler on the child of the root that will mark the event
 277   // as handled. Only the grandchild (the initial target) should receive the
 278   // event.
 279   child_r->RemovePreTargetHandler(&handler);
 280   child_r->AddPostTargetHandler(&handler);
 281   key_event = KeyEvent(ET_KEY_PRESSED, VKEY_ESCAPE, 0, false);
 282   DispatchEvent(&key_event);
 283   EXPECT_FALSE(root()->DidReceiveEvent(ET_KEY_PRESSED));
 284   EXPECT_FALSE(child_r->DidReceiveEvent(ET_KEY_PRESSED));
 285   EXPECT_TRUE(grandchild_r->DidReceiveEvent(ET_KEY_PRESSED));
 286   EXPECT_EQ(1, handler.num_key_events());
 287   handler.Reset();
 288   grandchild_r->ResetReceivedEvents();
 289   child_r->RemovePostTargetHandler(&handler);
 290
 291   // Mark the event as handled when it reaches the EP_TARGET phase of
 292   // dispatch at the child of the root. The child and grandchild
 293   // targets should both receive the event, but the root should not.
 294   child_r->set_mark_events_as_handled(true);
 295   key_event = KeyEvent(ET_KEY_PRESSED, VKEY_ESCAPE, 0, false);
 296   DispatchEvent(&key_event);
 297   EXPECT_FALSE(root()->DidReceiveEvent(ET_KEY_PRESSED));
 298   EXPECT_TRUE(child_r->DidReceiveEvent(ET_KEY_PRESSED));
 299   EXPECT_TRUE(grandchild_r->DidReceiveEvent(ET_KEY_PRESSED));
 300   root()->ResetReceivedEvents();
 301   child_r->ResetReceivedEvents();
 302   grandchild_r->ResetReceivedEvents();
 303   child_r->set_mark_events_as_handled(false);
 304 }
 305
 306 // Tests that unhandled events are seen by the correct sequence of
 307 // targets, pre-target handlers, and post-target handlers when
 308 // a BubblingEventTargeter is installed on the root target.
 309 TEST_F(EventProcessorTest, HandlerSequence) {
 310   scoped_ptr<TestEventTarget> child(new TestEventTarget());
 311   scoped_ptr<TestEventTarget> grandchild(new TestEventTarget());
 312
 313   root()->SetEventTargeter(
 314       scoped_ptr<EventTargeter>(new BubblingEventTargeter(grandchild.get())));
 315   child->AddChild(grandchild.Pass());
 316   root()->AddChild(child.Pass());
 317
 318   ASSERT_EQ(1u, root()->child_count());
 319   ASSERT_EQ(1u, root()->child_at(0)->child_count());
 320   ASSERT_EQ(0u, root()->child_at(0)->child_at(0)->child_count());
 321
 322   TestEventTarget* child_r = root()->child_at(0);
 323   TestEventTarget* grandchild_r = child_r->child_at(0);
 324
 325   HandlerSequenceRecorder recorder;
 326   root()->set_target_name("R");
 327   root()->set_recorder(&recorder);
 328   child_r->set_target_name("C");
 329   child_r->set_recorder(&recorder);
 330   grandchild_r->set_target_name("G");
 331   grandchild_r->set_recorder(&recorder);
 332
 333   TestEventHandler pre_root;
 334   pre_root.set_handler_name("PreR");
 335   pre_root.set_recorder(&recorder);
 336   root()->AddPreTargetHandler(&pre_root);
 337
 338   TestEventHandler pre_child;
 339   pre_child.set_handler_name("PreC");
 340   pre_child.set_recorder(&recorder);
 341   child_r->AddPreTargetHandler(&pre_child);
 342
 343   TestEventHandler pre_grandchild;
 344   pre_grandchild.set_handler_name("PreG");
 345   pre_grandchild.set_recorder(&recorder);
 346   grandchild_r->AddPreTargetHandler(&pre_grandchild);
 347
 348   TestEventHandler post_root;
 349   post_root.set_handler_name("PostR");
 350   post_root.set_recorder(&recorder);
 351   root()->AddPostTargetHandler(&post_root);
 352
 353   TestEventHandler post_child;
 354   post_child.set_handler_name("PostC");
 355   post_child.set_recorder(&recorder);
 356   child_r->AddPostTargetHandler(&post_child);
 357
 358   TestEventHandler post_grandchild;
 359   post_grandchild.set_handler_name("PostG");
 360   post_grandchild.set_recorder(&recorder);
 361   grandchild_r->AddPostTargetHandler(&post_grandchild);
 362
 363   MouseEvent mouse(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
 364                    EF_NONE, EF_NONE);
 365   DispatchEvent(&mouse);
 366
 367   std::string expected[] = { "PreR", "PreC", "PreG", "G", "PostG", "PostC",
 368       "PostR", "PreR", "PreC", "C", "PostC", "PostR", "PreR", "R", "PostR" };
 369   EXPECT_EQ(std::vector<std::string>(
 370       expected, expected + arraysize(expected)), recorder);
 371 }
 372
 373 }  // namespace test
 374 }  // namespace ui