Expand r209943 to suppress paste during provisional navigation as well
[WebKit-https.git] / Source / WebCore / dom / EventDispatcher.cpp
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  *           (C) 2001 Dirk Mueller (mueller@kde.org)
5  * Copyright (C) 2004-2016 Apple Inc. All rights reserved.
6  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
7  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
8  * Copyright (C) 2010, 2011, 2012, 2013 Google Inc. All rights reserved.
9  *
10  * This library is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Library General Public
12  * License as published by the Free Software Foundation; either
13  * version 2 of the License, or (at your option) any later version.
14  *
15  * This library is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * Library General Public License for more details.
19  *
20  * You should have received a copy of the GNU Library General Public License
21  * along with this library; see the file COPYING.LIB.  If not, write to
22  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
23  * Boston, MA 02110-1301, USA.
24  */
25
26 #include "config.h"
27 #include "EventDispatcher.h"
28
29 #include "CompositionEvent.h"
30 #include "EventContext.h"
31 #include "EventPath.h"
32 #include "Frame.h"
33 #include "FrameLoader.h"
34 #include "FrameView.h"
35 #include "HTMLInputElement.h"
36 #include "InputEvent.h"
37 #include "KeyboardEvent.h"
38 #include "MainFrame.h"
39 #include "MouseEvent.h"
40 #include "NoEventDispatchAssertion.h"
41 #include "ScopedEventQueue.h"
42 #include "ShadowRoot.h"
43 #include "TextEvent.h"
44 #include "TouchEvent.h"
45
46 namespace WebCore {
47
48 void EventDispatcher::dispatchScopedEvent(Node& node, Event& event)
49 {
50     // We need to set the target here because it can go away by the time we actually fire the event.
51     event.setTarget(EventPath::eventTargetRespectingTargetRules(node));
52     ScopedEventQueue::singleton().enqueueEvent(event);
53 }
54
55 static void callDefaultEventHandlersInTheBubblingOrder(Event& event, const EventPath& path)
56 {
57     if (path.isEmpty())
58         return;
59
60     // Non-bubbling events call only one default event handler, the one for the target.
61     path.contextAt(0).node()->defaultEventHandler(event);
62     ASSERT(!event.defaultPrevented());
63
64     if (event.defaultHandled() || !event.bubbles())
65         return;
66
67     size_t size = path.size();
68     for (size_t i = 1; i < size; ++i) {
69         path.contextAt(i).node()->defaultEventHandler(event);
70         ASSERT(!event.defaultPrevented());
71         if (event.defaultHandled())
72             return;
73     }
74 }
75
76 static void dispatchEventInDOM(Event& event, const EventPath& path)
77 {
78     // Trigger capturing event handlers, starting at the top and working our way down.
79     event.setEventPhase(Event::CAPTURING_PHASE);
80
81     for (size_t i = path.size() - 1; i > 0; --i) {
82         const EventContext& eventContext = path.contextAt(i);
83         if (eventContext.currentTargetSameAsTarget())
84             continue;
85         eventContext.handleLocalEvents(event);
86         if (event.propagationStopped())
87             return;
88     }
89
90     event.setEventPhase(Event::AT_TARGET);
91     path.contextAt(0).handleLocalEvents(event);
92     if (event.propagationStopped())
93         return;
94
95     // Trigger bubbling event handlers, starting at the bottom and working our way up.
96     size_t size = path.size();
97     for (size_t i = 1; i < size; ++i) {
98         const EventContext& eventContext = path.contextAt(i);
99         if (eventContext.currentTargetSameAsTarget())
100             event.setEventPhase(Event::AT_TARGET);
101         else if (event.bubbles())
102             event.setEventPhase(Event::BUBBLING_PHASE);
103         else
104             continue;
105         eventContext.handleLocalEvents(event);
106         if (event.propagationStopped())
107             return;
108     }
109 }
110
111 static bool shouldSuppressEventDispatchInDOM(Node& node, Event& event)
112 {
113     if (!event.isTrusted())
114         return false;
115
116     auto frame = node.document().frame();
117     if (!frame)
118         return false;
119
120     if (!frame->mainFrame().loader().shouldSuppressTextInputFromEditing())
121         return false;
122
123     if (is<TextEvent>(event)) {
124         auto& textEvent = downcast<TextEvent>(event);
125         return textEvent.isKeyboard() || textEvent.isComposition();
126     }
127
128     return is<CompositionEvent>(event) || is<InputEvent>(event) || is<KeyboardEvent>(event);
129 }
130
131 bool EventDispatcher::dispatchEvent(Node& node, Event& event)
132 {
133     ASSERT_WITH_SECURITY_IMPLICATION(NoEventDispatchAssertion::isEventAllowedInMainThread());
134     Ref<Node> protectedNode(node);
135     RefPtr<FrameView> view = node.document().view();
136     EventPath eventPath(node, event);
137
138     if (EventTarget* relatedTarget = event.relatedTarget())
139         eventPath.setRelatedTarget(node, *relatedTarget);
140 #if ENABLE(TOUCH_EVENTS)
141     if (is<TouchEvent>(event))
142         eventPath.retargetTouchLists(downcast<TouchEvent>(event));
143 #endif
144
145     ChildNodesLazySnapshot::takeChildNodesLazySnapshot();
146
147     EventTarget* target = EventPath::eventTargetRespectingTargetRules(node);
148     event.setTarget(target);
149     if (!event.target())
150         return true;
151
152     ASSERT_WITH_SECURITY_IMPLICATION(NoEventDispatchAssertion::isEventAllowedInMainThread());
153
154     InputElementClickState clickHandlingState;
155     if (is<HTMLInputElement>(node))
156         downcast<HTMLInputElement>(node).willDispatchEvent(event, clickHandlingState);
157
158     if (shouldSuppressEventDispatchInDOM(node, event))
159         event.stopPropagation();
160
161     if (!event.propagationStopped() && !eventPath.isEmpty()) {
162         event.setEventPath(eventPath);
163         dispatchEventInDOM(event, eventPath);
164         event.clearEventPath();
165     }
166
167     auto* finalTarget = event.target();
168     event.setTarget(EventPath::eventTargetRespectingTargetRules(node));
169     event.setCurrentTarget(nullptr);
170     event.resetPropagationFlags();
171     event.setEventPhase(Event::NONE);
172
173     if (clickHandlingState.stateful)
174         downcast<HTMLInputElement>(node).didDispatchClickEvent(event, clickHandlingState);
175
176     // Call default event handlers. While the DOM does have a concept of preventing
177     // default handling, the detail of which handlers are called is an internal
178     // implementation detail and not part of the DOM.
179     if (!event.defaultPrevented() && !event.defaultHandled())
180         callDefaultEventHandlersInTheBubblingOrder(event, eventPath);
181
182     event.setTarget(finalTarget);
183     event.setCurrentTarget(nullptr);
184
185     return !event.defaultPrevented();
186 }
187
188 }