blob: 34c98e3a753ccc94c25e5b13d34480505489adba [file] [log] [blame]
// 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 "ui/events/event.h"
#include <utility>
#include <vector>
#include "base/macros.h"
#include "testing/gtest/include/gtest/gtest.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(make_scoped_ptr(new TestEventTarget()));
processor_.Reset();
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);
}
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(std::move(child));
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));
SetTarget(root());
root()->RemoveChild(root()->child_at(0));
DispatchEvent(&mouse);
EXPECT_TRUE(root()->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 {}
// TestEventHandler:
void OnMouseEvent(MouseEvent* event) override {
TestEventHandler::OnMouseEvent(event);
EXPECT_EQ(expected_target_, event->target());
EXPECT_EQ(EP_TARGET, event->phase());
gfx::Point location(event->location());
EventDispatchDetails details = processor_->OnEventFromSource(event);
EXPECT_FALSE(details.dispatcher_destroyed);
EXPECT_FALSE(details.target_destroyed);
// The nested event-processing should not have mutated the target,
// phase, or location of |event|.
EXPECT_EQ(expected_target_, event->target());
EXPECT_EQ(EP_TARGET, event->phase());
EXPECT_EQ(location, event->location());
}
private:
EventProcessor* processor_;
EventTarget* expected_target_;
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(std::move(child));
// 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());
scoped_ptr<TestEventTarget> second_child(new TestEventTarget());
second_root->SetEventTargeter(
make_scoped_ptr(new TestEventTargeter(second_child.get(), false)));
second_root->AddChild(std::move(second_child));
// Define a second event processor which owns the second root.
scoped_ptr<TestEventProcessor> second_processor(new TestEventProcessor());
second_processor->SetRoot(std::move(second_root_scoped));
// 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)));
ignore_result(root()->child_at(0)->SetTargetHandler(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),
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_EQ(1, target_handler->num_mouse_events());
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();
target_handler->Reset();
// 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),
EventTimeForNow(), EF_NONE, EF_NONE);
DispatchEvent(&mouse2);
EXPECT_EQ(1, target_handler->num_mouse_events());
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(std::move(child));
// 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),
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(std::move(child));
// 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),
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),
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());
}
// Tests that unhandled events are correctly dispatched to the next-best
// 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(
make_scoped_ptr(new TestEventTargeter(grandchild.get(), true)));
child->AddChild(std::move(grandchild));
root()->AddChild(std::move(child));
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 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
// as handled. No targets in the hierarchy should receive the event.
TestEventHandler handler;
child_r->AddPreTargetHandler(&handler);
key_event = KeyEvent(ET_KEY_PRESSED, VKEY_ESCAPE, EF_NONE);
DispatchEvent(&key_event);
EXPECT_FALSE(root()->DidReceiveEvent(ET_KEY_PRESSED));
EXPECT_FALSE(child_r->DidReceiveEvent(ET_KEY_PRESSED));
EXPECT_FALSE(grandchild_r->DidReceiveEvent(ET_KEY_PRESSED));
EXPECT_EQ(1, handler.num_key_events());
handler.Reset();
// Add a post-target handler on the child of the root that will mark the event
// as handled. Only the grandchild (the initial target) should receive the
// event.
child_r->RemovePreTargetHandler(&handler);
child_r->AddPostTargetHandler(&handler);
key_event = KeyEvent(ET_KEY_PRESSED, VKEY_ESCAPE, EF_NONE);
DispatchEvent(&key_event);
EXPECT_FALSE(root()->DidReceiveEvent(ET_KEY_PRESSED));
EXPECT_FALSE(child_r->DidReceiveEvent(ET_KEY_PRESSED));
EXPECT_TRUE(grandchild_r->DidReceiveEvent(ET_KEY_PRESSED));
EXPECT_EQ(1, handler.num_key_events());
handler.Reset();
grandchild_r->ResetReceivedEvents();
child_r->RemovePostTargetHandler(&handler);
// Mark the event as handled when it reaches the EP_TARGET phase of
// dispatch at the child of the root. The child and grandchild
// targets should both receive the event, but the root should not.
child_r->set_mark_events_as_handled(true);
key_event = KeyEvent(ET_KEY_PRESSED, VKEY_ESCAPE, EF_NONE);
DispatchEvent(&key_event);
EXPECT_FALSE(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();
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 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(
make_scoped_ptr(new TestEventTargeter(grandchild.get(), true)));
child->AddChild(std::move(grandchild));
root()->AddChild(std::move(child));
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);
HandlerSequenceRecorder recorder;
root()->set_target_name("R");
root()->set_recorder(&recorder);
child_r->set_target_name("C");
child_r->set_recorder(&recorder);
grandchild_r->set_target_name("G");
grandchild_r->set_recorder(&recorder);
TestEventHandler pre_root;
pre_root.set_handler_name("PreR");
pre_root.set_recorder(&recorder);
root()->AddPreTargetHandler(&pre_root);
TestEventHandler pre_child;
pre_child.set_handler_name("PreC");
pre_child.set_recorder(&recorder);
child_r->AddPreTargetHandler(&pre_child);
TestEventHandler pre_grandchild;
pre_grandchild.set_handler_name("PreG");
pre_grandchild.set_recorder(&recorder);
grandchild_r->AddPreTargetHandler(&pre_grandchild);
TestEventHandler post_root;
post_root.set_handler_name("PostR");
post_root.set_recorder(&recorder);
root()->AddPostTargetHandler(&post_root);
TestEventHandler post_child;
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),
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