Sync ui/events to chromium @ https://codereview.chromium.org/1210203002

ui/events/event_processor_unittest.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/event.h"
+#include "ui/events/event_target_iterator.h"
 #include "ui/events/event_targeter.h"
+#include "ui/events/event_utils.h"
 #include "ui/events/test/events_test_utils.h"
 #include "ui/events/test/test_event_handler.h"
 #include "ui/events/test/test_event_processor.h"
 #include "ui/events/test/test_event_target.h"
+#include "ui/events/test/test_event_targeter.h"
 
 typedef std::vector<std::string> HandlerSequenceRecorder;
 
 namespace ui {
 namespace test {
 
 class EventProcessorTest : public testing::Test {
  public:
   EventProcessorTest() {}
   ~EventProcessorTest() override {}
 
+ protected:
   // testing::Test:
   void SetUp() override {
-    processor_.SetRoot(scoped_ptr<EventTarget>(new TestEventTarget()));
+    processor_.SetRoot(make_scoped_ptr(new TestEventTarget()));
     processor_.Reset();
-    root()->SetEventTargeter(make_scoped_ptr(new EventTargeter()));
+    root()->SetEventTargeter(
+        make_scoped_ptr(new TestEventTargeter(root(), false)));
   }
 
   TestEventTarget* root() {
     return static_cast<TestEventTarget*>(processor_.GetRootTarget());
   }
 
   TestEventProcessor* processor() {
     return &processor_;
   }
 
   void DispatchEvent(Event* event) {
     processor_.OnEventFromSource(event);
   }
 
- protected:
+  void SetTarget(TestEventTarget* target) {
+    static_cast<TestEventTargeter*>(root()->GetEventTargeter())
+        ->set_target(target);
+  }
+
+ private:
   TestEventProcessor processor_;
 
   DISALLOW_COPY_AND_ASSIGN(EventProcessorTest);
 };
 
 TEST_F(EventProcessorTest, Basic) {
   scoped_ptr<TestEventTarget> child(new TestEventTarget());
+  child->SetEventTargeter(
+      make_scoped_ptr(new TestEventTargeter(child.get(), false)));
+  SetTarget(child.get());
   root()->AddChild(child.Pass());
 
   MouseEvent mouse(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
-                   EF_NONE, EF_NONE);
+                   EventTimeForNow(), EF_NONE, EF_NONE);
   DispatchEvent(&mouse);
   EXPECT_TRUE(root()->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
   EXPECT_FALSE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
 
+  SetTarget(root());
   root()->RemoveChild(root()->child_at(0));
   DispatchEvent(&mouse);
   EXPECT_TRUE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
 }
 
-template<typename T>
-class BoundsEventTargeter : public EventTargeter {
- public:
-  virtual ~BoundsEventTargeter() {}
-
- protected:
-  virtual bool SubtreeShouldBeExploredForEvent(
-      EventTarget* target, const LocatedEvent& event) override {
-    T* t = static_cast<T*>(target);
-    return (t->bounds().Contains(event.location()));
-  }
-};
-
-class BoundsTestTarget : public TestEventTarget {
- public:
-  BoundsTestTarget() {}
-  ~BoundsTestTarget() override {}
-
-  void set_bounds(gfx::Rect rect) { bounds_ = rect; }
-  gfx::Rect bounds() const { return bounds_; }
-
-  static void ConvertPointToTarget(BoundsTestTarget* source,
-                                   BoundsTestTarget* target,
-                                   gfx::Point* location) {
-    gfx::Vector2d vector;
-    if (source->Contains(target)) {
-      for (; target && target != source;
-           target = static_cast<BoundsTestTarget*>(target->parent())) {
-        vector += target->bounds().OffsetFromOrigin();
-      }
-      *location -= vector;
-    } else if (target->Contains(source)) {
-      for (; source && source != target;
-           source = static_cast<BoundsTestTarget*>(source->parent())) {
-        vector += source->bounds().OffsetFromOrigin();
-      }
-      *location += vector;
-    } else {
-      NOTREACHED();
-    }
-  }
-
- private:
-  // EventTarget:
-  void ConvertEventToTarget(EventTarget* target,
-                            LocatedEvent* event) override {
-    event->ConvertLocationToTarget(this,
-                                   static_cast<BoundsTestTarget*>(target));
-  }
-
-  gfx::Rect bounds_;
-
-  DISALLOW_COPY_AND_ASSIGN(BoundsTestTarget);
-};
-
-TEST_F(EventProcessorTest, Bounds) {
-  scoped_ptr<BoundsTestTarget> parent(new BoundsTestTarget());
-  scoped_ptr<BoundsTestTarget> child(new BoundsTestTarget());
-  scoped_ptr<BoundsTestTarget> grandchild(new BoundsTestTarget());
-
-  parent->set_bounds(gfx::Rect(0, 0, 30, 30));
-  child->set_bounds(gfx::Rect(5, 5, 20, 20));
-  grandchild->set_bounds(gfx::Rect(5, 5, 5, 5));
-
-  child->AddChild(scoped_ptr<TestEventTarget>(grandchild.Pass()));
-  parent->AddChild(scoped_ptr<TestEventTarget>(child.Pass()));
-  root()->AddChild(scoped_ptr<TestEventTarget>(parent.Pass()));
-
-  ASSERT_EQ(1u, root()->child_count());
-  ASSERT_EQ(1u, root()->child_at(0)->child_count());
-  ASSERT_EQ(1u, root()->child_at(0)->child_at(0)->child_count());
-
-  TestEventTarget* parent_r = root()->child_at(0);
-  TestEventTarget* child_r = parent_r->child_at(0);
-  TestEventTarget* grandchild_r = child_r->child_at(0);
-
-  // Dispatch a mouse event that falls on the parent, but not on the child. When
-  // the default event-targeter used, the event will still reach |grandchild|,
-  // because the default targeter does not look at the bounds.
-  MouseEvent mouse(ET_MOUSE_MOVED, gfx::Point(1, 1), gfx::Point(1, 1), EF_NONE,
-                   EF_NONE);
-  DispatchEvent(&mouse);
-  EXPECT_FALSE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
-  EXPECT_FALSE(parent_r->DidReceiveEvent(ET_MOUSE_MOVED));
-  EXPECT_FALSE(child_r->DidReceiveEvent(ET_MOUSE_MOVED));
-  EXPECT_TRUE(grandchild_r->DidReceiveEvent(ET_MOUSE_MOVED));
-  grandchild_r->ResetReceivedEvents();
-
-  // Now install a targeter on the parent that looks at the bounds and makes
-  // sure the event reaches the target only if the location of the event within
-  // the bounds of the target.
-  MouseEvent mouse2(ET_MOUSE_MOVED, gfx::Point(1, 1), gfx::Point(1, 1), EF_NONE,
-                    EF_NONE);
-  parent_r->SetEventTargeter(scoped_ptr<EventTargeter>(
-      new BoundsEventTargeter<BoundsTestTarget>()));
-  DispatchEvent(&mouse2);
-  EXPECT_FALSE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
-  EXPECT_TRUE(parent_r->DidReceiveEvent(ET_MOUSE_MOVED));
-  EXPECT_FALSE(child_r->DidReceiveEvent(ET_MOUSE_MOVED));
-  EXPECT_FALSE(grandchild_r->DidReceiveEvent(ET_MOUSE_MOVED));
-  parent_r->ResetReceivedEvents();
-
-  MouseEvent second(ET_MOUSE_MOVED, gfx::Point(12, 12), gfx::Point(12, 12),
-                    EF_NONE, EF_NONE);
-  DispatchEvent(&second);
-  EXPECT_FALSE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
-  EXPECT_FALSE(parent_r->DidReceiveEvent(ET_MOUSE_MOVED));
-  EXPECT_FALSE(child_r->DidReceiveEvent(ET_MOUSE_MOVED));
-  EXPECT_TRUE(grandchild_r->DidReceiveEvent(ET_MOUSE_MOVED));
-}
-
 // ReDispatchEventHandler is used to receive mouse events and forward them
 // to a specified EventProcessor. Verifies that the event has the correct
 // target and phase both before and after the nested event processing. Also
 // verifies that the location of the event remains the same after it has
 // been processed by the second EventProcessor.
 class ReDispatchEventHandler : public TestEventHandler {
  public:
   ReDispatchEventHandler(EventProcessor* processor, EventTarget* target)
       : processor_(processor), expected_target_(target) {}
   ~ReDispatchEventHandler() override {}
@@ skipping 23 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ReDispatchEventHandler);
 };
 
 // Verifies that the phase and target information of an event is not mutated
 // as a result of sending the event to an event processor while it is still
 // being processed by another event processor.
 TEST_F(EventProcessorTest, NestedEventProcessing) {
   // Add one child to the default event processor used in this test suite.
   scoped_ptr<TestEventTarget> child(new TestEventTarget());
+  SetTarget(child.get());
   root()->AddChild(child.Pass());
 
   // Define a second root target and child.
   scoped_ptr<EventTarget> second_root_scoped(new TestEventTarget());
   TestEventTarget* second_root =
       static_cast<TestEventTarget*>(second_root_scoped.get());
-  second_root->SetEventTargeter(make_scoped_ptr(new EventTargeter()));
   scoped_ptr<TestEventTarget> second_child(new TestEventTarget());
+  second_root->SetEventTargeter(
+      make_scoped_ptr(new TestEventTargeter(second_child.get(), false)));
   second_root->AddChild(second_child.Pass());
 
   // Define a second event processor which owns the second root.
   scoped_ptr<TestEventProcessor> second_processor(new TestEventProcessor());
   second_processor->SetRoot(second_root_scoped.Pass());
 
   // Indicate that an event which is dispatched to the child target owned by the
   // first event processor should be handled by |target_handler| instead.
   scoped_ptr<TestEventHandler> target_handler(
       new ReDispatchEventHandler(second_processor.get(), root()->child_at(0)));
   root()->child_at(0)->set_target_handler(target_handler.get());
 
   // Dispatch a mouse event to the tree of event targets owned by the first
   // event processor, checking in ReDispatchEventHandler that the phase and
   // target information of the event is correct.
-  MouseEvent mouse(
-      ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10), EF_NONE, EF_NONE);
+  MouseEvent mouse(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
+                   EventTimeForNow(), EF_NONE, EF_NONE);
   DispatchEvent(&mouse);
 
   // Verify also that |mouse| was seen by the child nodes contained in both
   // event processors and that the event was not handled.
   EXPECT_TRUE(root()->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
   EXPECT_TRUE(second_root->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
   EXPECT_FALSE(mouse.handled());
   second_root->child_at(0)->ResetReceivedEvents();
   root()->child_at(0)->ResetReceivedEvents();
 
   // Indicate that the child of the second root should handle events, and
   // dispatch another mouse event to verify that it is marked as handled.
   second_root->child_at(0)->set_mark_events_as_handled(true);
-  MouseEvent mouse2(
-      ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10), EF_NONE, EF_NONE);
+  MouseEvent mouse2(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
+                    EventTimeForNow(), EF_NONE, EF_NONE);
   DispatchEvent(&mouse2);
   EXPECT_TRUE(root()->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
   EXPECT_TRUE(second_root->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
   EXPECT_TRUE(mouse2.handled());
 }
 
 // Verifies that OnEventProcessingFinished() is called when an event
 // has been handled.
 TEST_F(EventProcessorTest, OnEventProcessingFinished) {
   scoped_ptr<TestEventTarget> child(new TestEventTarget());
   child->set_mark_events_as_handled(true);
+  SetTarget(child.get());
   root()->AddChild(child.Pass());
 
   // Dispatch a mouse event. We expect the event to be seen by the target,
   // handled, and we expect OnEventProcessingFinished() to be invoked once.
   MouseEvent mouse(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
-                   EF_NONE, EF_NONE);
+                   EventTimeForNow(), EF_NONE, EF_NONE);
   DispatchEvent(&mouse);
   EXPECT_TRUE(root()->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
   EXPECT_FALSE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
   EXPECT_TRUE(mouse.handled());
   EXPECT_EQ(1, processor()->num_times_processing_finished());
 }
 
 // Verifies that OnEventProcessingStarted() has been called when starting to
 // process an event, and that processing does not take place if
 // OnEventProcessingStarted() marks the event as handled. Also verifies that
 // OnEventProcessingFinished() is also called in either case.
 TEST_F(EventProcessorTest, OnEventProcessingStarted) {
   scoped_ptr<TestEventTarget> child(new TestEventTarget());
+  SetTarget(child.get());
   root()->AddChild(child.Pass());
 
   // Dispatch a mouse event. We expect the event to be seen by the target,
   // OnEventProcessingStarted() should be called once, and
   // OnEventProcessingFinished() should be called once. The event should
   // remain unhandled.
-  MouseEvent mouse(
-      ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10), EF_NONE, EF_NONE);
+  MouseEvent mouse(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
+                   EventTimeForNow(), EF_NONE, EF_NONE);
   DispatchEvent(&mouse);
   EXPECT_TRUE(root()->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
   EXPECT_FALSE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
   EXPECT_FALSE(mouse.handled());
   EXPECT_EQ(1, processor()->num_times_processing_started());
   EXPECT_EQ(1, processor()->num_times_processing_finished());
   processor()->Reset();
   root()->ResetReceivedEvents();
   root()->child_at(0)->ResetReceivedEvents();
 
   // Dispatch another mouse event, but with OnEventProcessingStarted() marking
   // the event as handled to prevent processing. We expect the event to not be
   // seen by the target this time, but OnEventProcessingStarted() and
   // OnEventProcessingFinished() should both still be called once.
   processor()->set_should_processing_occur(false);
-  MouseEvent mouse2(
-      ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10), EF_NONE, EF_NONE);
+  MouseEvent mouse2(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
+                    EventTimeForNow(), EF_NONE, EF_NONE);
   DispatchEvent(&mouse2);
   EXPECT_FALSE(root()->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
   EXPECT_FALSE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
   EXPECT_TRUE(mouse2.handled());
   EXPECT_EQ(1, processor()->num_times_processing_started());
   EXPECT_EQ(1, processor()->num_times_processing_finished());
 }
 
-class IgnoreEventTargeter : public EventTargeter {
- public:
-  IgnoreEventTargeter() {}
-  ~IgnoreEventTargeter() override {}
-
- private:
-  // EventTargeter:
-  bool SubtreeShouldBeExploredForEvent(
-      EventTarget* target, const LocatedEvent& event) override {
-    return false;
-  }
-};
-
-// Verifies that the EventTargeter installed on an EventTarget can dictate
-// whether the target itself can process an event.
-TEST_F(EventProcessorTest, TargeterChecksOwningEventTarget) {
-  scoped_ptr<TestEventTarget> child(new TestEventTarget());
-  root()->AddChild(child.Pass());
-
-  MouseEvent mouse(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
-                   EF_NONE, EF_NONE);
-  DispatchEvent(&mouse);
-  EXPECT_TRUE(root()->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
-  EXPECT_FALSE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
-  root()->child_at(0)->ResetReceivedEvents();
-
-  // Install an event handler on |child| which always prevents the target from
-  // receiving event.
-  root()->child_at(0)->SetEventTargeter(
-      scoped_ptr<EventTargeter>(new IgnoreEventTargeter()));
-  MouseEvent mouse2(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
-                    EF_NONE, EF_NONE);
-  DispatchEvent(&mouse2);
-  EXPECT_FALSE(root()->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
-  EXPECT_TRUE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
-}
-
-// An EventTargeter which is used to allow a bubbling behaviour in event
-// dispatch: if an event is not handled after being dispatched to its
-// initial target, the event is dispatched to the next-best target as
-// specified by FindNextBestTarget().
-class BubblingEventTargeter : public EventTargeter {
- public:
-  explicit BubblingEventTargeter(TestEventTarget* initial_target)
-    : initial_target_(initial_target) {}
-  ~BubblingEventTargeter() override {}
-
- private:
-  // EventTargeter:
-  EventTarget* FindTargetForEvent(EventTarget* root,
-                                          Event* event) override {
-    return initial_target_;
-  }
-
-  EventTarget* FindNextBestTarget(EventTarget* previous_target,
-                                          Event* event) override {
-    return previous_target->GetParentTarget();
-  }
-
-  TestEventTarget* initial_target_;
-
-  DISALLOW_COPY_AND_ASSIGN(BubblingEventTargeter);
-};
-
 // Tests that unhandled events are correctly dispatched to the next-best
-// target as decided by the BubblingEventTargeter.
+// target as decided by the TestEventTargeter.
 TEST_F(EventProcessorTest, DispatchToNextBestTarget) {
   scoped_ptr<TestEventTarget> child(new TestEventTarget());
   scoped_ptr<TestEventTarget> grandchild(new TestEventTarget());
 
+  // Install a TestEventTargeter which permits bubbling.
   root()->SetEventTargeter(
-      scoped_ptr<EventTargeter>(new BubblingEventTargeter(grandchild.get())));
+      make_scoped_ptr(new TestEventTargeter(grandchild.get(), true)));
   child->AddChild(grandchild.Pass());
   root()->AddChild(child.Pass());
 
   ASSERT_EQ(1u, root()->child_count());
   ASSERT_EQ(1u, root()->child_at(0)->child_count());
   ASSERT_EQ(0u, root()->child_at(0)->child_at(0)->child_count());
 
   TestEventTarget* child_r = root()->child_at(0);
   TestEventTarget* grandchild_r = child_r->child_at(0);
 
-  // When the root has a BubblingEventTargeter installed, events targeted
-  // at the grandchild target should be dispatched to all three targets.
+  // When the root has a TestEventTargeter installed which permits bubbling,
+  // events targeted at the grandchild target should be dispatched to all three
+  // targets.
   KeyEvent key_event(ET_KEY_PRESSED, VKEY_ESCAPE, EF_NONE);
   DispatchEvent(&key_event);
   EXPECT_TRUE(root()->DidReceiveEvent(ET_KEY_PRESSED));
   EXPECT_TRUE(child_r->DidReceiveEvent(ET_KEY_PRESSED));
   EXPECT_TRUE(grandchild_r->DidReceiveEvent(ET_KEY_PRESSED));
   root()->ResetReceivedEvents();
   child_r->ResetReceivedEvents();
   grandchild_r->ResetReceivedEvents();
 
   // Add a pre-target handler on the child of the root that will mark the event
@@ skipping 33 matching lines @@
   EXPECT_TRUE(child_r->DidReceiveEvent(ET_KEY_PRESSED));
   EXPECT_TRUE(grandchild_r->DidReceiveEvent(ET_KEY_PRESSED));
   root()->ResetReceivedEvents();
   child_r->ResetReceivedEvents();
   grandchild_r->ResetReceivedEvents();
   child_r->set_mark_events_as_handled(false);
 }
 
 // Tests that unhandled events are seen by the correct sequence of
 // targets, pre-target handlers, and post-target handlers when
-// a BubblingEventTargeter is installed on the root target.
+// a TestEventTargeter is installed on the root target which permits bubbling.
 TEST_F(EventProcessorTest, HandlerSequence) {
   scoped_ptr<TestEventTarget> child(new TestEventTarget());
   scoped_ptr<TestEventTarget> grandchild(new TestEventTarget());
 
+  // Install a TestEventTargeter which permits bubbling.
   root()->SetEventTargeter(
-      scoped_ptr<EventTargeter>(new BubblingEventTargeter(grandchild.get())));
+      make_scoped_ptr(new TestEventTargeter(grandchild.get(), true)));
   child->AddChild(grandchild.Pass());
   root()->AddChild(child.Pass());
 
   ASSERT_EQ(1u, root()->child_count());
   ASSERT_EQ(1u, root()->child_at(0)->child_count());
   ASSERT_EQ(0u, root()->child_at(0)->child_at(0)->child_count());
 
   TestEventTarget* child_r = root()->child_at(0);
   TestEventTarget* grandchild_r = child_r->child_at(0);
 
@@ skipping 29 matching lines @@
   post_child.set_handler_name("PostC");
   post_child.set_recorder(&recorder);
   child_r->AddPostTargetHandler(&post_child);
 
   TestEventHandler post_grandchild;
   post_grandchild.set_handler_name("PostG");
   post_grandchild.set_recorder(&recorder);
   grandchild_r->AddPostTargetHandler(&post_grandchild);
 
   MouseEvent mouse(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
-                   EF_NONE, EF_NONE);
+                   EventTimeForNow(), EF_NONE, EF_NONE);
   DispatchEvent(&mouse);
 
   std::string expected[] = { "PreR", "PreC", "PreG", "G", "PostG", "PostC",
       "PostR", "PreR", "PreC", "C", "PostC", "PostR", "PreR", "R", "PostR" };
   EXPECT_EQ(std::vector<std::string>(
       expected, expected + arraysize(expected)), recorder);
 }
 
 }  // namespace test
 }  // namespace ui