[WTF] Move currentCPUTime and sleep(Seconds) to CPUTime.h and Seconds.h respectively
[WebKit-https.git] / Source / WebCore / dom / Event.cpp
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 #include "config.h"
24 #include "Event.h"
25
26 #include "DOMWindow.h"
27 #include "Document.h"
28 #include "EventNames.h"
29 #include "EventPath.h"
30 #include "EventTarget.h"
31 #include "Performance.h"
32 #include "UserGestureIndicator.h"
33 #include "WorkerGlobalScope.h"
34
35 namespace WebCore {
36
37 Event::Event(IsTrusted isTrusted)
38     : m_isTrusted(isTrusted == IsTrusted::Yes)
39     , m_createTime(MonotonicTime::now())
40 {
41 }
42
43 Event::Event(const AtomicString& eventType, bool canBubbleArg, bool cancelableArg)
44     : m_type(eventType)
45     , m_isInitialized(true)
46     , m_canBubble(canBubbleArg)
47     , m_cancelable(cancelableArg)
48     , m_isTrusted(true)
49     , m_createTime(MonotonicTime::now())
50 {
51 }
52
53 Event::Event(const AtomicString& eventType, bool canBubbleArg, bool cancelableArg, MonotonicTime timestamp)
54     : m_type(eventType)
55     , m_isInitialized(true)
56     , m_canBubble(canBubbleArg)
57     , m_cancelable(cancelableArg)
58     , m_isTrusted(true)
59     , m_createTime(timestamp)
60 {
61 }
62
63 Event::Event(const AtomicString& eventType, const EventInit& initializer, IsTrusted isTrusted)
64     : m_type(eventType)
65     , m_isInitialized(true)
66     , m_canBubble(initializer.bubbles)
67     , m_cancelable(initializer.cancelable)
68     , m_composed(initializer.composed)
69     , m_isTrusted(isTrusted == IsTrusted::Yes)
70     , m_createTime(MonotonicTime::now())
71 {
72 }
73
74 Event::~Event() = default;
75
76 Ref<Event> Event::create(const AtomicString& type, bool canBubble, bool cancelable)
77 {
78     return adoptRef(*new Event(type, canBubble, cancelable));
79 }
80
81 Ref<Event> Event::createForBindings()
82 {
83     return adoptRef(*new Event);
84 }
85
86 Ref<Event> Event::create(const AtomicString& type, const EventInit& initializer, IsTrusted isTrusted)
87 {
88     return adoptRef(*new Event(type, initializer, isTrusted));
89 }
90
91 void Event::initEvent(const AtomicString& eventTypeArg, bool canBubbleArg, bool cancelableArg)
92 {
93     if (isBeingDispatched())
94         return;
95
96     m_isInitialized = true;
97     m_propagationStopped = false;
98     m_immediatePropagationStopped = false;
99     m_wasCanceled = false;
100     m_isTrusted = false;
101     m_target = nullptr;
102     m_type = eventTypeArg;
103     m_canBubble = canBubbleArg;
104     m_cancelable = cancelableArg;
105
106     m_underlyingEvent = nullptr;
107 }
108
109 bool Event::composed() const
110 {
111     if (m_composed)
112         return true;
113
114     // http://w3c.github.io/webcomponents/spec/shadow/#scoped-flag
115     if (!isTrusted())
116         return false;
117
118     return m_type == eventNames().inputEvent
119         || m_type == eventNames().textInputEvent
120         || m_type == eventNames().DOMActivateEvent
121         || isCompositionEvent()
122         || isClipboardEvent()
123         || isFocusEvent()
124         || isKeyboardEvent()
125         || isMouseEvent()
126         || isTouchEvent()
127         || isInputEvent();
128 }
129
130 void Event::setTarget(RefPtr<EventTarget>&& target)
131 {
132     if (m_target == target)
133         return;
134
135     m_target = WTFMove(target);
136     if (m_target)
137         receivedTarget();
138 }
139
140 void Event::setCurrentTarget(EventTarget* currentTarget)
141 {
142     m_currentTarget = currentTarget;
143 }
144
145 Vector<EventTarget*> Event::composedPath() const
146 {
147     if (!m_eventPath)
148         return Vector<EventTarget*>();
149     return m_eventPath->computePathUnclosedToTarget(*m_currentTarget);
150 }
151
152 void Event::setUnderlyingEvent(Event* underlyingEvent)
153 {
154     // Prohibit creation of a cycle by doing nothing if a cycle would be created.
155     for (Event* event = underlyingEvent; event; event = event->underlyingEvent()) {
156         if (event == this)
157             return;
158     }
159     m_underlyingEvent = underlyingEvent;
160 }
161
162 DOMHighResTimeStamp Event::timeStampForBindings(ScriptExecutionContext& context) const
163 {
164     Performance* performance = nullptr;
165     if (is<WorkerGlobalScope>(context))
166         performance = &downcast<WorkerGlobalScope>(context).performance();
167     else if (auto* window = downcast<Document>(context).domWindow())
168         performance = window->performance();
169
170     if (!performance)
171         return 0;
172
173     return performance->relativeTimeFromTimeOriginInReducedResolution(m_createTime);
174 }
175
176 void Event::resetBeforeDispatch()
177 {
178     m_defaultHandled = false;
179 }
180
181 void Event::resetAfterDispatch()
182 {
183     m_eventPath = nullptr;
184     m_currentTarget = nullptr;
185     m_eventPhase = NONE;
186     m_propagationStopped = false;
187     m_immediatePropagationStopped = false;
188 }
189
190 } // namespace WebCore