Make all ScriptWrappable IsoHeap-ed
[WebKit-https.git] / Source / WebCore / dom / Event.h
1 /*
2  * Copyright (C) 2001 Peter Kelly (pmk@post.com)
3  * Copyright (C) 2001 Tobias Anton (anton@stud.fbi.fh-darmstadt.de)
4  * Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
5  * Copyright (C) 2003-2017 Apple Inc. All rights reserved.
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Library General Public
9  * License as published by the Free Software Foundation; either
10  * version 2 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Library General Public License for more details.
16  *
17  * You should have received a copy of the GNU Library General Public License
18  * along with this library; see the file COPYING.LIB.  If not, write to
19  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20  * Boston, MA 02110-1301, USA.
21  *
22  */
23
24 #pragma once
25
26 #include "DOMHighResTimeStamp.h"
27 #include "EventInit.h"
28 #include "EventInterfaces.h"
29 #include "ExceptionOr.h"
30 #include "ScriptWrappable.h"
31 #include <wtf/MonotonicTime.h>
32 #include <wtf/TypeCasts.h>
33 #include <wtf/text/AtomString.h>
34
35 namespace WebCore {
36
37 class EventPath;
38 class EventTarget;
39 class ScriptExecutionContext;
40
41 class Event : public ScriptWrappable, public RefCounted<Event> {
42     WTF_MAKE_ISO_ALLOCATED(Event);
43 public:
44     enum class IsTrusted : uint8_t { No, Yes };
45     enum class CanBubble : uint8_t { No, Yes };
46     enum class IsCancelable : uint8_t { No, Yes };
47     enum class IsComposed : uint8_t { No, Yes };
48
49     enum PhaseType : uint8_t {
50         NONE = 0,
51         CAPTURING_PHASE = 1,
52         AT_TARGET = 2,
53         BUBBLING_PHASE = 3
54     };
55
56     WEBCORE_EXPORT static Ref<Event> create(const AtomString& type, CanBubble, IsCancelable, IsComposed = IsComposed::No);
57     static Ref<Event> createForBindings();
58     static Ref<Event> create(const AtomString& type, const EventInit&, IsTrusted = IsTrusted::No);
59
60     virtual ~Event();
61
62     WEBCORE_EXPORT void initEvent(const AtomString& type, bool canBubble, bool cancelable);
63
64     bool isInitialized() const { return m_isInitialized; }
65
66     const AtomString& type() const { return m_type; }
67     void setType(const AtomString& type) { m_type = type; }
68     
69     EventTarget* target() const { return m_target.get(); }
70     void setTarget(RefPtr<EventTarget>&&);
71
72     EventTarget* currentTarget() const { return m_currentTarget.get(); }
73     void setCurrentTarget(EventTarget*);
74
75     unsigned short eventPhase() const { return m_eventPhase; }
76     void setEventPhase(PhaseType phase) { m_eventPhase = phase; }
77
78     bool bubbles() const { return m_canBubble; }
79     bool cancelable() const { return m_cancelable; }
80     bool composed() const { return m_composed; }
81
82     DOMHighResTimeStamp timeStampForBindings(ScriptExecutionContext&) const;
83     MonotonicTime timeStamp() const { return m_createTime; }
84
85     void setEventPath(const EventPath& path) { m_eventPath = &path; }
86     Vector<EventTarget*> composedPath() const;
87
88     void stopPropagation() { m_propagationStopped = true; }
89     void stopImmediatePropagation() { m_immediatePropagationStopped = true; }
90
91     bool isTrusted() const { return m_isTrusted; }
92     void setUntrusted() { m_isTrusted = false; }
93
94     bool legacyReturnValue() const { return !m_wasCanceled; }
95     void setLegacyReturnValue(bool);
96
97     virtual EventInterface eventInterface() const { return EventInterfaceType; }
98
99     virtual bool isBeforeTextInsertedEvent() const { return false; }
100     virtual bool isBeforeUnloadEvent() const { return false; }
101     virtual bool isClipboardEvent() const { return false; }
102     virtual bool isCompositionEvent() const { return false; }
103     virtual bool isErrorEvent() const { return false; }
104     virtual bool isFocusEvent() const { return false; }
105     virtual bool isInputEvent() const { return false; }
106     virtual bool isKeyboardEvent() const { return false; }
107     virtual bool isMouseEvent() const { return false; }
108     virtual bool isPointerEvent() const { return false; }
109     virtual bool isTextEvent() const { return false; }
110     virtual bool isTouchEvent() const { return false; }
111     virtual bool isUIEvent() const { return false; }
112     virtual bool isVersionChangeEvent() const { return false; }
113     virtual bool isWheelEvent() const { return false; }
114
115     bool propagationStopped() const { return m_propagationStopped || m_immediatePropagationStopped; }
116     bool immediatePropagationStopped() const { return m_immediatePropagationStopped; }
117
118     void resetBeforeDispatch();
119     void resetAfterDispatch();
120
121     bool defaultPrevented() const { return m_wasCanceled; }
122     void preventDefault();
123
124     bool defaultHandled() const { return m_defaultHandled; }
125     void setDefaultHandled() { m_defaultHandled = true; }
126
127     bool isDefaultEventHandlerIgnored() const { return m_isDefaultEventHandlerIgnored; }
128     void setIsDefaultEventHandlerIgnored() { m_isDefaultEventHandlerIgnored = true; }
129
130     void setInPassiveListener(bool value) { m_isExecutingPassiveEventListener = value; }
131
132     bool cancelBubble() const { return propagationStopped(); }
133     void setCancelBubble(bool);
134
135     Event* underlyingEvent() const { return m_underlyingEvent.get(); }
136     void setUnderlyingEvent(Event*);
137
138     // Returns true if the dispatch flag is set.
139     // https://dom.spec.whatwg.org/#dispatch-flag
140     bool isBeingDispatched() const { return eventPhase(); }
141
142     virtual EventTarget* relatedTarget() const { return nullptr; }
143     virtual void setRelatedTarget(EventTarget&) { }
144
145 protected:
146     explicit Event(IsTrusted = IsTrusted::No);
147     Event(const AtomString& type, CanBubble, IsCancelable, IsComposed = IsComposed::No);
148     Event(const AtomString& type, CanBubble, IsCancelable, IsComposed, MonotonicTime timestamp, IsTrusted isTrusted = IsTrusted::Yes);
149     Event(const AtomString& type, const EventInit&, IsTrusted);
150
151     virtual void receivedTarget() { }
152
153 private:
154     explicit Event(MonotonicTime createTime, const AtomString& type, IsTrusted, CanBubble, IsCancelable, IsComposed);
155
156     void setCanceledFlagIfPossible();
157
158     unsigned m_isInitialized : 1;
159     unsigned m_canBubble : 1;
160     unsigned m_cancelable : 1;
161     unsigned m_composed : 1;
162
163     unsigned m_propagationStopped : 1;
164     unsigned m_immediatePropagationStopped : 1;
165     unsigned m_wasCanceled : 1;
166     unsigned m_defaultHandled : 1;
167     unsigned m_isDefaultEventHandlerIgnored : 1;
168     unsigned m_isTrusted : 1;
169     unsigned m_isExecutingPassiveEventListener : 1;
170
171     unsigned m_eventPhase : 2;
172
173     AtomString m_type;
174
175     RefPtr<EventTarget> m_currentTarget;
176     const EventPath* m_eventPath { nullptr };
177     RefPtr<EventTarget> m_target;
178     MonotonicTime m_createTime;
179
180     RefPtr<Event> m_underlyingEvent;
181 };
182
183 inline void Event::preventDefault()
184 {
185     setCanceledFlagIfPossible();
186 }
187
188 inline void Event::setLegacyReturnValue(bool returnValue)
189 {
190     if (!returnValue)
191         setCanceledFlagIfPossible();
192 }
193
194 // https://dom.spec.whatwg.org/#set-the-canceled-flag
195 inline void Event::setCanceledFlagIfPossible()
196 {
197     if (m_cancelable && !m_isExecutingPassiveEventListener)
198         m_wasCanceled = true;
199     // FIXME: Specification suggests we log something to the console when preventDefault is called but
200     // doesn't do anything because the event is not cancelable or is executing passive event listeners.
201 }
202
203 inline void Event::setCancelBubble(bool cancel)
204 {
205     if (cancel)
206         m_propagationStopped = true;
207 }
208
209 } // namespace WebCore
210
211 #define SPECIALIZE_TYPE_TRAITS_EVENT(ToValueTypeName) \
212 SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::ToValueTypeName) \
213     static bool isType(const WebCore::Event& event) { return event.is##ToValueTypeName(); } \
214 SPECIALIZE_TYPE_TRAITS_END()