Remove all uses of PassRefPtr in WebCore/svg
[WebKit-https.git] / Source / WebCore / dom / EventTarget.h
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, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
6  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
7  *           (C) 2007, 2008 Nikolas Zimmermann <zimmermann@kde.org>
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  *
18  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
21  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
22  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
23  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
24  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
25  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
26  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #ifndef EventTarget_h
32 #define EventTarget_h
33
34 #include "EventListenerMap.h"
35 #include "EventNames.h"
36 #include "EventTargetInterfaces.h"
37 #include <memory>
38 #include <wtf/Forward.h>
39 #include <wtf/HashMap.h>
40
41 namespace WTF {
42 class AtomicString;
43 }
44
45 namespace WebCore {
46
47 class AudioNode;
48 class AudioContext;
49 class AudioTrackList;
50 class DedicatedWorkerGlobalScope;
51 class DOMApplicationCache;
52 class DOMWindow;
53 class Event;
54 class EventListener;
55 class EventSource;
56 class FileReader;
57 class FileWriter;
58 class IDBDatabase;
59 class IDBRequest;
60 class IDBTransaction;
61 class ScriptProcessorNode;
62 class MediaController;
63 class MediaStream;
64 class MessagePort;
65 class Node;
66 class Notification;
67 class ScriptExecutionContext;
68 class TextTrack;
69 class TextTrackCue;
70 class VideoTrackList;
71 class WebSocket;
72 class WebKitNamedFlow;
73 class Worker;
74 class XMLHttpRequest;
75 class XMLHttpRequestUpload;
76
77 typedef int ExceptionCode;
78
79 struct FiringEventIterator {
80     FiringEventIterator(const AtomicString& eventType, size_t& iterator, size_t& size)
81         : eventType(eventType)
82         , iterator(iterator)
83         , size(size)
84     {
85     }
86
87     const AtomicString& eventType;
88     size_t& iterator;
89     size_t& size;
90 };
91 typedef Vector<FiringEventIterator, 1> FiringEventIteratorVector;
92
93 struct EventTargetData {
94     WTF_MAKE_NONCOPYABLE(EventTargetData); WTF_MAKE_FAST_ALLOCATED;
95 public:
96     EventTargetData();
97     ~EventTargetData();
98
99     EventListenerMap eventListenerMap;
100     std::unique_ptr<FiringEventIteratorVector> firingEventIterators;
101 };
102
103 enum EventTargetInterface {
104
105 #define DOM_EVENT_INTERFACE_DECLARE(name) name##EventTargetInterfaceType,
106 DOM_EVENT_TARGET_INTERFACES_FOR_EACH(DOM_EVENT_INTERFACE_DECLARE)
107 #undef DOM_EVENT_INTERFACE_DECLARE
108
109 };
110
111 class EventTarget {
112 public:
113     void ref() { refEventTarget(); }
114     void deref() { derefEventTarget(); }
115
116     virtual EventTargetInterface eventTargetInterface() const = 0;
117     virtual ScriptExecutionContext* scriptExecutionContext() const = 0;
118
119     virtual Node* toNode();
120     virtual DOMWindow* toDOMWindow();
121     virtual bool isMessagePort() const;
122
123     virtual bool addEventListener(const AtomicString& eventType, RefPtr<EventListener>&&, bool useCapture);
124     virtual bool removeEventListener(const AtomicString& eventType, EventListener*, bool useCapture);
125     virtual void removeAllEventListeners();
126     virtual bool dispatchEvent(PassRefPtr<Event>);
127     bool dispatchEvent(PassRefPtr<Event>, ExceptionCode&); // DOM API
128     virtual void uncaughtExceptionInEventHandler();
129
130     // Used for legacy "onEvent" attribute APIs.
131     bool setAttributeEventListener(const AtomicString& eventType, PassRefPtr<EventListener>);
132     bool clearAttributeEventListener(const AtomicString& eventType);
133     EventListener* getAttributeEventListener(const AtomicString& eventType);
134
135     bool hasEventListeners() const;
136     bool hasEventListeners(const AtomicString& eventType);
137     bool hasCapturingEventListeners(const AtomicString& eventType);
138     const EventListenerVector& getEventListeners(const AtomicString& eventType);
139
140     bool fireEventListeners(Event*);
141     bool isFiringEventListeners();
142
143     void visitJSEventListeners(JSC::SlotVisitor&);
144     void invalidateJSEventListeners(JSC::JSObject*);
145
146 protected:
147     virtual ~EventTarget();
148     
149     virtual EventTargetData* eventTargetData() = 0;
150     virtual EventTargetData& ensureEventTargetData() = 0;
151
152 private:
153     virtual void refEventTarget() = 0;
154     virtual void derefEventTarget() = 0;
155     
156     void fireEventListeners(Event*, EventTargetData*, EventListenerVector&);
157
158     friend class EventListenerIterator;
159 };
160
161 class EventTargetWithInlineData : public EventTarget {
162 protected:
163     virtual EventTargetData* eventTargetData() override final { return &m_eventTargetData; }
164     virtual EventTargetData& ensureEventTargetData() override final { return m_eventTargetData; }
165 private:
166     EventTargetData m_eventTargetData;
167 };
168
169 inline void EventTarget::visitJSEventListeners(JSC::SlotVisitor& visitor)
170 {
171     EventListenerIterator iterator(this);
172     while (EventListener* listener = iterator.nextListener())
173         listener->visitJSFunction(visitor);
174 }
175
176 inline bool EventTarget::isFiringEventListeners()
177 {
178     EventTargetData* d = eventTargetData();
179     if (!d)
180         return false;
181     return d->firingEventIterators && !d->firingEventIterators->isEmpty();
182 }
183
184 inline bool EventTarget::hasEventListeners() const
185 {
186     EventTargetData* d = const_cast<EventTarget*>(this)->eventTargetData();
187     if (!d)
188         return false;
189     return !d->eventListenerMap.isEmpty();
190 }
191
192 inline bool EventTarget::hasEventListeners(const AtomicString& eventType)
193 {
194     EventTargetData* d = eventTargetData();
195     if (!d)
196         return false;
197     return d->eventListenerMap.contains(eventType);
198 }
199
200 inline bool EventTarget::hasCapturingEventListeners(const AtomicString& eventType)
201 {
202     EventTargetData* d = eventTargetData();
203     if (!d)
204         return false;
205     return d->eventListenerMap.containsCapturing(eventType);
206 }
207
208 } // namespace WebCore
209
210 #endif // EventTarget_h