OLD | NEW |
---|---|
1 /* | 1 /* |
2 * Copyright (C) 1999 Lars Knoll (knoll@kde.org) | 2 * Copyright (C) 1999 Lars Knoll (knoll@kde.org) |
3 * (C) 1999 Antti Koivisto (koivisto@kde.org) | 3 * (C) 1999 Antti Koivisto (koivisto@kde.org) |
4 * (C) 2001 Dirk Mueller (mueller@kde.org) | 4 * (C) 2001 Dirk Mueller (mueller@kde.org) |
5 * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved. | 5 * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved. |
6 * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org) | 6 * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org) |
7 * (C) 2007, 2008 Nikolas Zimmermann <zimmermann@kde.org> | 7 * (C) 2007, 2008 Nikolas Zimmermann <zimmermann@kde.org> |
8 * | 8 * |
9 * Redistribution and use in source and binary forms, with or without | 9 * Redistribution and use in source and binary forms, with or without |
10 * modification, are permitted provided that the following conditions | 10 * modification, are permitted provided that the following conditions |
(...skipping 20 matching lines...) Expand all Loading... | |
31 | 31 |
32 #ifndef EventTarget_h | 32 #ifndef EventTarget_h |
33 #define EventTarget_h | 33 #define EventTarget_h |
34 | 34 |
35 #include "core/events/EventListenerMap.h" | 35 #include "core/events/EventListenerMap.h" |
36 #include "core/events/ThreadLocalEventNames.h" | 36 #include "core/events/ThreadLocalEventNames.h" |
37 #include "wtf/Forward.h" | 37 #include "wtf/Forward.h" |
38 | 38 |
39 namespace WebCore { | 39 namespace WebCore { |
40 | 40 |
41 class ApplicationCache; | 41 class ApplicationCache; |
42 class AudioContext; | 42 class AudioContext; |
43 class DOMWindow; | 43 class DOMWindow; |
44 class DedicatedWorkerGlobalScope; | 44 class DedicatedWorkerGlobalScope; |
45 class Event; | 45 class Event; |
46 class EventListener; | 46 class EventListener; |
47 class EventSource; | 47 class EventSource; |
48 class ExceptionState; | 48 class ExceptionState; |
49 class FileReader; | 49 class FileReader; |
50 class FileWriter; | 50 class FileWriter; |
51 class IDBDatabase; | 51 class IDBDatabase; |
52 class IDBRequest; | 52 class IDBRequest; |
53 class IDBTransaction; | 53 class IDBTransaction; |
54 class MIDIAccess; | 54 class MIDIAccess; |
55 class MIDIInput; | 55 class MIDIInput; |
56 class MIDIPort; | 56 class MIDIPort; |
57 class MediaController; | 57 class MediaController; |
58 class MediaStream; | 58 class MediaStream; |
59 class MessagePort; | 59 class MessagePort; |
60 class NamedFlow; | 60 class NamedFlow; |
61 class Node; | 61 class Node; |
62 class Notification; | 62 class Notification; |
63 class SVGElementInstance; | 63 class SVGElementInstance; |
64 class ExecutionContext; | 64 class ExecutionContext; |
65 class ScriptProcessorNode; | 65 class ScriptProcessorNode; |
66 class SharedWorker; | 66 class SharedWorker; |
67 class SharedWorkerGlobalScope; | 67 class SharedWorkerGlobalScope; |
68 class TextTrack; | 68 class TextTrack; |
69 class TextTrackCue; | 69 class TextTrackCue; |
70 class WebSocket; | 70 class WebSocket; |
71 class Worker; | 71 class Worker; |
72 class XMLHttpRequest; | 72 class XMLHttpRequest; |
73 class XMLHttpRequestUpload; | 73 class XMLHttpRequestUpload; |
74 | 74 |
75 struct FiringEventIterator { | 75 struct FiringEventIterator { |
76 FiringEventIterator(const AtomicString& eventType, size_t& iterator, siz e_t& end) | 76 FiringEventIterator(const AtomicString& eventType, size_t& iterator, size_t& end) |
77 : eventType(eventType) | 77 : eventType(eventType) |
78 , iterator(iterator) | 78 , iterator(iterator) |
79 , end(end) | 79 , end(end) |
80 { | |
81 } | |
82 | |
83 const AtomicString& eventType; | |
84 size_t& iterator; | |
85 size_t& end; | |
86 }; | |
87 typedef Vector<FiringEventIterator, 1> FiringEventIteratorVector; | |
88 | |
89 struct EventTargetData { | |
90 WTF_MAKE_NONCOPYABLE(EventTargetData); WTF_MAKE_FAST_ALLOCATED; | |
91 public: | |
92 EventTargetData(); | |
93 ~EventTargetData(); | |
94 | |
95 EventListenerMap eventListenerMap; | |
96 OwnPtr<FiringEventIteratorVector> firingEventIterators; | |
97 }; | |
98 | |
99 class EventTarget { | |
100 public: | |
101 void ref() { refEventTarget(); } | |
102 void deref() { derefEventTarget(); } | |
103 | |
104 virtual const AtomicString& interfaceName() const = 0; | |
105 virtual ExecutionContext* executionContext() const = 0; | |
106 | |
107 virtual Node* toNode(); | |
108 virtual DOMWindow* toDOMWindow(); | |
109 virtual MessagePort* toMessagePort(); | |
110 | |
111 virtual bool addEventListener(const AtomicString& eventType, PassRefPtr< EventListener>, bool useCapture); | |
112 virtual bool removeEventListener(const AtomicString& eventType, EventLis tener*, bool useCapture); | |
113 virtual void removeAllEventListeners(); | |
114 virtual bool dispatchEvent(PassRefPtr<Event>); | |
115 bool dispatchEvent(PassRefPtr<Event>, ExceptionState&); // DOM API | |
116 virtual void uncaughtExceptionInEventHandler(); | |
117 | |
118 // Used for legacy "onEvent" attribute APIs. | |
119 bool setAttributeEventListener(const AtomicString& eventType, PassRefPtr <EventListener>, DOMWrapperWorld* isolatedWorld = 0); | |
120 EventListener* getAttributeEventListener(const AtomicString& eventType, DOMWrapperWorld* isolatedWorld = 0); | |
121 | |
122 bool hasEventListeners() const; | |
123 bool hasEventListeners(const AtomicString& eventType) const; | |
124 bool hasCapturingEventListeners(const AtomicString& eventType); | |
125 const EventListenerVector& getEventListeners(const AtomicString& eventTy pe); | |
126 | |
127 bool fireEventListeners(Event*); | |
128 bool isFiringEventListeners(); | |
129 | |
130 protected: | |
131 virtual ~EventTarget(); | |
132 | |
133 // Subclasses should likely not override these themselves; instead, they should subclass EventTargetWithInlineData. | |
134 virtual EventTargetData* eventTargetData() = 0; | |
135 virtual EventTargetData& ensureEventTargetData() = 0; | |
136 | |
137 private: | |
138 // Subclasses should likely not override these themselves; instead, they should use the REFCOUNTED_EVENT_TARGET() macro. | |
139 virtual void refEventTarget() = 0; | |
140 virtual void derefEventTarget() = 0; | |
141 | |
142 DOMWindow* executingWindow(); | |
143 void fireEventListeners(Event*, EventTargetData*, EventListenerVector&); | |
144 void countLegacyEvents(const AtomicString& legacyTypeName, EventListener Vector*, EventListenerVector*); | |
145 | |
146 bool clearAttributeEventListener(const AtomicString& eventType, DOMWrapp erWorld* isolatedWorld); | |
147 | |
148 friend class EventListenerIterator; | |
149 }; | |
150 | |
151 class EventTargetWithInlineData : public EventTarget { | |
152 protected: | |
153 virtual EventTargetData* eventTargetData() OVERRIDE FINAL { return &m_ev entTargetData; } | |
154 virtual EventTargetData& ensureEventTargetData() OVERRIDE FINAL { return m_eventTargetData; } | |
155 private: | |
156 EventTargetData m_eventTargetData; | |
157 }; | |
158 | |
159 // FIXME: These macros should be split into separate DEFINE and DECLARE | |
160 // macros to avoid causing so many header includes. | |
161 #define DEFINE_ATTRIBUTE_EVENT_LISTENER(attribute) \ | |
162 EventListener* on##attribute(DOMWrapperWorld* isolatedWorld) { return ge tAttributeEventListener(EventTypeNames::attribute, isolatedWorld); } \ | |
163 void setOn##attribute(PassRefPtr<EventListener> listener, DOMWrapperWorl d* isolatedWorld = 0) { setAttributeEventListener(EventTypeNames::attribute, lis tener, isolatedWorld); } \ | |
164 | |
165 #define DECLARE_VIRTUAL_ATTRIBUTE_EVENT_LISTENER(attribute) \ | |
166 virtual EventListener* on##attribute(DOMWrapperWorld* isolatedWorld); \ | |
167 virtual void setOn##attribute(PassRefPtr<EventListener>, DOMWrapperWorld * isolatedWorld); \ | |
168 | |
169 #define DEFINE_VIRTUAL_ATTRIBUTE_EVENT_LISTENER(type, attribute) \ | |
170 EventListener* type::on##attribute(DOMWrapperWorld* isolatedWorld) { ret urn getAttributeEventListener(EventTypeNames::attribute, isolatedWorld); } \ | |
171 void type::setOn##attribute(PassRefPtr<EventListener> listener, DOMWrapp erWorld* isolatedWorld) { setAttributeEventListener(EventTypeNames::attribute, l istener, isolatedWorld); } \ | |
172 | |
173 #define DEFINE_WINDOW_ATTRIBUTE_EVENT_LISTENER(attribute) \ | |
174 EventListener* on##attribute(DOMWrapperWorld* isolatedWorld) { return do cument().getWindowAttributeEventListener(EventTypeNames::attribute, isolatedWorl d); } \ | |
175 void setOn##attribute(PassRefPtr<EventListener> listener, DOMWrapperWorl d* isolatedWorld) { document().setWindowAttributeEventListener(EventTypeNames::a ttribute, listener, isolatedWorld); } \ | |
176 | |
177 #define DEFINE_MAPPED_ATTRIBUTE_EVENT_LISTENER(attribute, eventName) \ | |
178 EventListener* on##attribute(DOMWrapperWorld* isolatedWorld) { return ge tAttributeEventListener(EventTypeNames::eventName, isolatedWorld); } \ | |
179 void setOn##attribute(PassRefPtr<EventListener> listener, DOMWrapperWorl d* isolatedWorld) { setAttributeEventListener(EventTypeNames::eventName, listene r, isolatedWorld); } \ | |
180 | |
181 #define DECLARE_FORWARDING_ATTRIBUTE_EVENT_LISTENER(recipient, attribute) \ | |
182 EventListener* on##attribute(DOMWrapperWorld* isolatedWorld); \ | |
183 void setOn##attribute(PassRefPtr<EventListener> listener, DOMWrapperWorl d* isolatedWorld); | |
184 | |
185 #define DEFINE_FORWARDING_ATTRIBUTE_EVENT_LISTENER(type, recipient, attribut e) \ | |
186 EventListener* type::on##attribute(DOMWrapperWorld* isolatedWorld) { ret urn recipient ? recipient->getAttributeEventListener(EventTypeNames::attribute, isolatedWorld) : 0; } \ | |
187 void type::setOn##attribute(PassRefPtr<EventListener> listener, DOMWrapp erWorld* isolatedWorld) { if (recipient) recipient->setAttributeEventListener(Ev entTypeNames::attribute, listener, isolatedWorld); } | |
188 | |
189 inline bool EventTarget::isFiringEventListeners() | |
190 { | 80 { |
191 EventTargetData* d = eventTargetData(); | |
192 if (!d) | |
193 return false; | |
194 return d->firingEventIterators && !d->firingEventIterators->isEmpty(); | |
195 } | 81 } |
196 | 82 |
197 inline bool EventTarget::hasEventListeners() const | 83 const AtomicString& eventType; |
198 { | 84 size_t& iterator; |
199 // FIXME: We should have a const version of eventTargetData. | 85 size_t& end; |
200 if (const EventTargetData* d = const_cast<EventTarget*>(this)->eventTarg etData()) | 86 }; |
201 return !d->eventListenerMap.isEmpty(); | 87 typedef Vector<FiringEventIterator, 1> FiringEventIteratorVector; |
202 return false; | 88 |
89 struct EventTargetData { | |
90 WTF_MAKE_NONCOPYABLE(EventTargetData); WTF_MAKE_FAST_ALLOCATED; | |
91 public: | |
92 EventTargetData(); | |
93 ~EventTargetData(); | |
94 | |
95 EventListenerMap eventListenerMap; | |
96 OwnPtr<FiringEventIteratorVector> firingEventIterators; | |
97 }; | |
98 | |
99 class EventTarget { | |
100 public: | |
101 void ref() { refEventTarget(); } | |
102 void deref() { derefEventTarget(); } | |
103 | |
104 virtual const AtomicString& interfaceName() const = 0; | |
105 virtual ExecutionContext* executionContext() const = 0; | |
106 | |
107 virtual Node* toNode(); | |
108 virtual DOMWindow* toDOMWindow(); | |
109 virtual MessagePort* toMessagePort(); | |
110 | |
111 virtual bool addEventListener(const AtomicString& eventType, PassRefPtr<Even tListener>, bool useCapture); | |
112 virtual bool removeEventListener(const AtomicString& eventType, EventListene r*, bool useCapture); | |
113 virtual void removeAllEventListeners(); | |
114 virtual bool dispatchEvent(PassRefPtr<Event>); | |
115 bool dispatchEvent(PassRefPtr<Event>, ExceptionState&); // DOM API | |
116 virtual void uncaughtExceptionInEventHandler(); | |
117 | |
118 // Used for legacy "onEvent" attribute APIs. | |
119 bool setAttributeEventListener(const AtomicString& eventType, PassRefPtr<Eve ntListener>, DOMWrapperWorld* isolatedWorld = 0); | |
120 EventListener* getAttributeEventListener(const AtomicString& eventType, DOMW rapperWorld* isolatedWorld = 0); | |
121 | |
122 bool hasEventListeners() const; | |
123 bool hasEventListeners(const AtomicString& eventType) const; | |
124 bool hasCapturingEventListeners(const AtomicString& eventType); | |
125 const EventListenerVector& getEventListeners(const AtomicString& eventType); | |
126 | |
127 bool fireEventListeners(Event*); | |
128 bool isFiringEventListeners(); | |
129 | |
130 protected: | |
131 virtual ~EventTarget(); | |
132 | |
133 // Subclasses should likely not override these themselves; instead, they sho uld subclass EventTargetWithInlineData. | |
134 virtual EventTargetData* eventTargetData() = 0; | |
135 virtual EventTargetData& ensureEventTargetData() = 0; | |
136 | |
137 private: | |
138 // Subclasses should likely not override these themselves; instead, they sho uld use the REFCOUNTED_EVENT_TARGET() macro. | |
139 virtual void refEventTarget() = 0; | |
140 virtual void derefEventTarget() = 0; | |
141 | |
142 DOMWindow* executingWindow(); | |
143 void fireEventListeners(Event*, EventTargetData*, EventListenerVector&); | |
144 void countLegacyEvents(const AtomicString& legacyTypeName, EventListenerVect or*, EventListenerVector*); | |
145 | |
146 bool clearAttributeEventListener(const AtomicString& eventType, DOMWrapperWo rld* isolatedWorld); | |
147 | |
148 friend class EventListenerIterator; | |
149 }; | |
150 | |
151 class EventTargetWithInlineData : public EventTarget { | |
152 protected: | |
153 virtual EventTargetData* eventTargetData() OVERRIDE FINAL { return &m_eventT argetData; } | |
154 virtual EventTargetData& ensureEventTargetData() OVERRIDE FINAL { return m_e ventTargetData; } | |
155 private: | |
156 EventTargetData m_eventTargetData; | |
157 }; | |
158 | |
159 // FIXME: These macros should be split into separate DEFINE and DECLARE | |
160 // macros to avoid causing so many header includes. | |
161 #define DEFINE_ATTRIBUTE_EVENT_LISTENER(attribute) \ | |
162 EventListener* on##attribute(DOMWrapperWorld* isolatedWorld) { return getAtt ributeEventListener(EventTypeNames::attribute, isolatedWorld); } \ | |
163 void setOn##attribute(PassRefPtr<EventListener> listener, DOMWrapperWorld* i solatedWorld = 0) { setAttributeEventListener(EventTypeNames::attribute, listene r, isolatedWorld); } \ | |
haraken
2013/10/26 17:03:15
Not related to your CL, it wouldn't be a good thin
philipj_slow
2013/10/26 20:27:50
Created https://codereview.chromium.org/45973006/
| |
164 | |
165 #define DEFINE_STATIC_ATTRIBUTE_EVENT_LISTENER(attribute) \ | |
166 static EventListener* on##attribute(EventTarget* eventTarget, DOMWrapperWorl d* isolatedWorld) { return eventTarget->getAttributeEventListener(EventTypeNames ::attribute, isolatedWorld); } \ | |
167 static void setOn##attribute(EventTarget* eventTarget, PassRefPtr<EventListe ner> listener, DOMWrapperWorld* isolatedWorld = 0) { eventTarget->setAttributeEv entListener(EventTypeNames::attribute, listener, isolatedWorld); } \ | |
haraken
2013/10/26 17:03:15
Ditto.
| |
168 | |
169 #define DEFINE_WINDOW_ATTRIBUTE_EVENT_LISTENER(attribute) \ | |
170 EventListener* on##attribute(DOMWrapperWorld* isolatedWorld) { return docume nt().getWindowAttributeEventListener(EventTypeNames::attribute, isolatedWorld); } \ | |
171 void setOn##attribute(PassRefPtr<EventListener> listener, DOMWrapperWorld* i solatedWorld) { document().setWindowAttributeEventListener(EventTypeNames::attri bute, listener, isolatedWorld); } \ | |
172 | |
173 #define DEFINE_MAPPED_ATTRIBUTE_EVENT_LISTENER(attribute, eventName) \ | |
174 EventListener* on##attribute(DOMWrapperWorld* isolatedWorld) { return getAtt ributeEventListener(EventTypeNames::eventName, isolatedWorld); } \ | |
175 void setOn##attribute(PassRefPtr<EventListener> listener, DOMWrapperWorld* i solatedWorld) { setAttributeEventListener(EventTypeNames::eventName, listener, i solatedWorld); } \ | |
176 | |
177 #define DECLARE_FORWARDING_ATTRIBUTE_EVENT_LISTENER(recipient, attribute) \ | |
178 EventListener* on##attribute(DOMWrapperWorld* isolatedWorld); \ | |
179 void setOn##attribute(PassRefPtr<EventListener> listener, DOMWrapperWorld* i solatedWorld); | |
180 | |
181 #define DEFINE_FORWARDING_ATTRIBUTE_EVENT_LISTENER(type, recipient, attribute) \ | |
182 EventListener* type::on##attribute(DOMWrapperWorld* isolatedWorld) { return recipient ? recipient->getAttributeEventListener(EventTypeNames::attribute, isol atedWorld) : 0; } \ | |
183 void type::setOn##attribute(PassRefPtr<EventListener> listener, DOMWrapperWo rld* isolatedWorld) \ | |
184 { \ | |
185 if (recipient) \ | |
186 recipient->setAttributeEventListener(EventTypeNames::attribute, list ener, isolatedWorld); \ | |
203 } | 187 } |
204 | 188 |
205 inline bool EventTarget::hasEventListeners(const AtomicString& eventType) co nst | 189 inline bool EventTarget::isFiringEventListeners() |
206 { | 190 { |
207 // FIXME: We should have const version of eventTargetData. | 191 EventTargetData* d = eventTargetData(); |
208 if (const EventTargetData* d = const_cast<EventTarget*>(this)->eventTarg etData()) | 192 if (!d) |
209 return d->eventListenerMap.contains(eventType); | |
210 return false; | 193 return false; |
211 } | 194 return d->firingEventIterators && !d->firingEventIterators->isEmpty(); |
195 } | |
212 | 196 |
213 inline bool EventTarget::hasCapturingEventListeners(const AtomicString& even tType) | 197 inline bool EventTarget::hasEventListeners() const |
214 { | 198 { |
215 EventTargetData* d = eventTargetData(); | 199 // FIXME: We should have a const version of eventTargetData. |
216 if (!d) | 200 if (const EventTargetData* d = const_cast<EventTarget*>(this)->eventTargetDa ta()) |
217 return false; | 201 return !d->eventListenerMap.isEmpty(); |
218 return d->eventListenerMap.containsCapturing(eventType); | 202 return false; |
219 } | 203 } |
204 | |
205 inline bool EventTarget::hasEventListeners(const AtomicString& eventType) const | |
206 { | |
207 // FIXME: We should have const version of eventTargetData. | |
208 if (const EventTargetData* d = const_cast<EventTarget*>(this)->eventTargetDa ta()) | |
209 return d->eventListenerMap.contains(eventType); | |
210 return false; | |
211 } | |
212 | |
213 inline bool EventTarget::hasCapturingEventListeners(const AtomicString& eventTyp e) | |
214 { | |
215 EventTargetData* d = eventTargetData(); | |
216 if (!d) | |
217 return false; | |
218 return d->eventListenerMap.containsCapturing(eventType); | |
219 } | |
220 | 220 |
221 } // namespace WebCore | 221 } // namespace WebCore |
222 | 222 |
223 #define DEFINE_EVENT_TARGET_REFCOUNTING(baseClass) \ | 223 #define DEFINE_EVENT_TARGET_REFCOUNTING(baseClass) \ |
224 public: \ | 224 public: \ |
225 using baseClass::ref; \ | 225 using baseClass::ref; \ |
226 using baseClass::deref; \ | 226 using baseClass::deref; \ |
227 private: \ | 227 private: \ |
228 virtual void refEventTarget() OVERRIDE FINAL { ref(); } \ | 228 virtual void refEventTarget() OVERRIDE FINAL { ref(); } \ |
229 virtual void derefEventTarget() OVERRIDE FINAL { deref(); } \ | 229 virtual void derefEventTarget() OVERRIDE FINAL { deref(); } \ |
230 typedef int thisIsHereToForceASemiColonAfterThisEventTargetMacro | 230 typedef int thisIsHereToForceASemiColonAfterThisEventTargetMacro |
231 | 231 |
232 // Use this macro if your EventTarget subclass is also a subclass of WTF::RefCou nted. | 232 // Use this macro if your EventTarget subclass is also a subclass of WTF::RefCou nted. |
233 // A ref-counted class that uses a different method of refcounting should use DE FINE_EVENT_TARGET_REFCOUNTING directly. | 233 // A ref-counted class that uses a different method of refcounting should use DE FINE_EVENT_TARGET_REFCOUNTING directly. |
234 // Both of these macros are meant to be placed just before the "public:" section of the class declaration. | 234 // Both of these macros are meant to be placed just before the "public:" section of the class declaration. |
235 #define REFCOUNTED_EVENT_TARGET(className) DEFINE_EVENT_TARGET_REFCOUNTING(RefCo unted<className>) | 235 #define REFCOUNTED_EVENT_TARGET(className) DEFINE_EVENT_TARGET_REFCOUNTING(RefCo unted<className>) |
236 | 236 |
237 #endif // EventTarget_h | 237 #endif // EventTarget_h |
OLD | NEW |