Line data Source code
1 : /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 : /* vim: set ts=8 sts=2 et sw=2 tw=80: */
3 : /* This Source Code Form is subject to the terms of the Mozilla Public
4 : * License, v. 2.0. If a copy of the MPL was not distributed with this
5 : * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6 :
7 : // Microsoft's API Name hackery sucks
8 : #undef CreateEvent
9 :
10 : #include "mozilla/AddonPathService.h"
11 : #include "mozilla/BasicEvents.h"
12 : #include "mozilla/CycleCollectedJSRuntime.h"
13 : #include "mozilla/DOMEventTargetHelper.h"
14 : #include "mozilla/EventDispatcher.h"
15 : #include "mozilla/EventListenerManager.h"
16 : #ifdef MOZ_B2G
17 : #include "mozilla/Hal.h"
18 : #endif // #ifdef MOZ_B2G
19 : #include "mozilla/HalSensor.h"
20 : #include "mozilla/InternalMutationEvent.h"
21 : #include "mozilla/JSEventHandler.h"
22 : #include "mozilla/Maybe.h"
23 : #include "mozilla/MemoryReporting.h"
24 : #include "mozilla/Preferences.h"
25 : #include "mozilla/dom/BindingUtils.h"
26 : #include "mozilla/dom/Element.h"
27 : #include "mozilla/dom/Event.h"
28 : #include "mozilla/dom/EventTargetBinding.h"
29 : #include "mozilla/dom/TouchEvent.h"
30 : #include "mozilla/TimelineConsumers.h"
31 : #include "mozilla/EventTimelineMarker.h"
32 : #include "mozilla/TimeStamp.h"
33 :
34 : #include "EventListenerService.h"
35 : #include "GeckoProfiler.h"
36 : #include "ProfilerMarkerPayload.h"
37 : #include "nsCOMArray.h"
38 : #include "nsCOMPtr.h"
39 : #include "nsContentUtils.h"
40 : #include "nsDOMCID.h"
41 : #include "nsError.h"
42 : #include "nsGkAtoms.h"
43 : #include "nsIContent.h"
44 : #include "nsIContentSecurityPolicy.h"
45 : #include "nsIDocument.h"
46 : #include "nsIDOMEventListener.h"
47 : #include "nsIScriptGlobalObject.h"
48 : #include "nsISupports.h"
49 : #include "nsIXPConnect.h"
50 : #include "nsJSUtils.h"
51 : #include "nsNameSpaceManager.h"
52 : #include "nsPIDOMWindow.h"
53 : #include "nsSandboxFlags.h"
54 : #include "xpcpublic.h"
55 : #include "nsIFrame.h"
56 : #include "nsDisplayList.h"
57 :
58 : namespace mozilla {
59 :
60 : using namespace dom;
61 : using namespace hal;
62 :
63 : #define EVENT_TYPE_EQUALS(ls, message, userType, typeString, allEvents) \
64 : ((ls->mEventMessage == message && \
65 : (ls->mEventMessage != eUnidentifiedEvent || \
66 : (mIsMainThreadELM && ls->mTypeAtom == userType) || \
67 : (!mIsMainThreadELM && ls->mTypeString.Equals(typeString)))) || \
68 : (allEvents && ls->mAllEvents))
69 :
70 : static const uint32_t kAllMutationBits =
71 : NS_EVENT_BITS_MUTATION_SUBTREEMODIFIED |
72 : NS_EVENT_BITS_MUTATION_NODEINSERTED |
73 : NS_EVENT_BITS_MUTATION_NODEREMOVED |
74 : NS_EVENT_BITS_MUTATION_NODEREMOVEDFROMDOCUMENT |
75 : NS_EVENT_BITS_MUTATION_NODEINSERTEDINTODOCUMENT |
76 : NS_EVENT_BITS_MUTATION_ATTRMODIFIED |
77 : NS_EVENT_BITS_MUTATION_CHARACTERDATAMODIFIED;
78 :
79 : static uint32_t
80 0 : MutationBitForEventType(EventMessage aEventType)
81 : {
82 0 : switch (aEventType) {
83 : case eLegacySubtreeModified:
84 0 : return NS_EVENT_BITS_MUTATION_SUBTREEMODIFIED;
85 : case eLegacyNodeInserted:
86 0 : return NS_EVENT_BITS_MUTATION_NODEINSERTED;
87 : case eLegacyNodeRemoved:
88 0 : return NS_EVENT_BITS_MUTATION_NODEREMOVED;
89 : case eLegacyNodeRemovedFromDocument:
90 0 : return NS_EVENT_BITS_MUTATION_NODEREMOVEDFROMDOCUMENT;
91 : case eLegacyNodeInsertedIntoDocument:
92 0 : return NS_EVENT_BITS_MUTATION_NODEINSERTEDINTODOCUMENT;
93 : case eLegacyAttrModified:
94 0 : return NS_EVENT_BITS_MUTATION_ATTRMODIFIED;
95 : case eLegacyCharacterDataModified:
96 0 : return NS_EVENT_BITS_MUTATION_CHARACTERDATAMODIFIED;
97 : default:
98 0 : break;
99 : }
100 0 : return 0;
101 : }
102 :
103 : uint32_t EventListenerManager::sMainThreadCreatedCount = 0;
104 :
105 : static bool
106 941 : IsWebkitPrefixSupportEnabled()
107 : {
108 : static bool sIsWebkitPrefixSupportEnabled;
109 : static bool sIsPrefCached = false;
110 :
111 941 : if (!sIsPrefCached) {
112 2 : sIsPrefCached = true;
113 : Preferences::AddBoolVarCache(&sIsWebkitPrefixSupportEnabled,
114 2 : "layout.css.prefixes.webkit");
115 : }
116 :
117 941 : return sIsWebkitPrefixSupportEnabled;
118 : }
119 :
120 598 : EventListenerManagerBase::EventListenerManagerBase()
121 : : mNoListenerForEvent(eVoidEvent)
122 : , mMayHavePaintEventListener(false)
123 : , mMayHaveMutationListeners(false)
124 : , mMayHaveCapturingListeners(false)
125 : , mMayHaveSystemGroupListeners(false)
126 : , mMayHaveTouchEventListener(false)
127 : , mMayHaveMouseEnterLeaveEventListener(false)
128 : , mMayHavePointerEnterLeaveEventListener(false)
129 : , mMayHaveKeyEventListener(false)
130 : , mMayHaveInputOrCompositionEventListener(false)
131 : , mMayHaveSelectionChangeEventListener(false)
132 : , mClearingListeners(false)
133 598 : , mIsMainThreadELM(NS_IsMainThread())
134 : {
135 : static_assert(sizeof(EventListenerManagerBase) == sizeof(uint32_t),
136 : "Keep the size of EventListenerManagerBase size compact!");
137 598 : }
138 :
139 598 : EventListenerManager::EventListenerManager(EventTarget* aTarget)
140 : : EventListenerManagerBase()
141 598 : , mTarget(aTarget)
142 : {
143 598 : NS_ASSERTION(aTarget, "unexpected null pointer");
144 :
145 598 : if (mIsMainThreadELM) {
146 598 : ++sMainThreadCreatedCount;
147 : }
148 598 : }
149 :
150 6 : EventListenerManager::~EventListenerManager()
151 : {
152 : // If your code fails this assertion, a possible reason is that
153 : // a class did not call our Disconnect() manually. Note that
154 : // this class can have Disconnect called in one of two ways:
155 : // if it is part of a cycle, then in Unlink() (such a cycle
156 : // would be with one of the listeners, not mTarget which is weak).
157 : // If not part of a cycle, then Disconnect must be called manually,
158 : // typically from the destructor of the owner class (mTarget).
159 : // XXX azakai: Is there any reason to not just call Disconnect
160 : // from right here, if not previously called?
161 3 : NS_ASSERTION(!mTarget, "didn't call Disconnect");
162 3 : RemoveAllListeners();
163 3 : }
164 :
165 : void
166 7 : EventListenerManager::RemoveAllListeners()
167 : {
168 7 : if (mClearingListeners) {
169 0 : return;
170 : }
171 7 : mClearingListeners = true;
172 7 : mListeners.Clear();
173 7 : mClearingListeners = false;
174 : }
175 :
176 : void
177 0 : EventListenerManager::Shutdown()
178 : {
179 0 : Event::Shutdown();
180 0 : }
181 :
182 0 : NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(EventListenerManager, AddRef)
183 0 : NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(EventListenerManager, Release)
184 :
185 : inline void
186 0 : ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
187 : EventListenerManager::Listener& aField,
188 : const char* aName,
189 : unsigned aFlags)
190 : {
191 0 : if (MOZ_UNLIKELY(aCallback.WantDebugInfo())) {
192 0 : nsAutoCString name;
193 0 : name.AppendASCII(aName);
194 0 : if (aField.mTypeAtom) {
195 0 : name.AppendASCII(" event=");
196 0 : name.Append(nsAtomCString(aField.mTypeAtom));
197 0 : name.AppendASCII(" listenerType=");
198 0 : name.AppendInt(aField.mListenerType);
199 0 : name.AppendASCII(" ");
200 : }
201 0 : CycleCollectionNoteChild(aCallback, aField.mListener.GetISupports(), name.get(),
202 0 : aFlags);
203 : } else {
204 0 : CycleCollectionNoteChild(aCallback, aField.mListener.GetISupports(), aName,
205 0 : aFlags);
206 : }
207 0 : }
208 :
209 : NS_IMPL_CYCLE_COLLECTION_CLASS(EventListenerManager)
210 :
211 0 : NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(EventListenerManager)
212 0 : NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mListeners)
213 0 : NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
214 :
215 0 : NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(EventListenerManager)
216 0 : tmp->Disconnect();
217 0 : NS_IMPL_CYCLE_COLLECTION_UNLINK_END
218 :
219 :
220 : nsPIDOMWindowInner*
221 11 : EventListenerManager::GetInnerWindowForTarget()
222 : {
223 22 : nsCOMPtr<nsINode> node = do_QueryInterface(mTarget);
224 11 : if (node) {
225 : // XXX sXBL/XBL2 issue -- do we really want the owner here? What
226 : // if that's the XBL document?
227 7 : return node->OwnerDoc()->GetInnerWindow();
228 : }
229 :
230 8 : nsCOMPtr<nsPIDOMWindowInner> window = GetTargetAsInnerWindow();
231 4 : return window;
232 : }
233 :
234 : already_AddRefed<nsPIDOMWindowInner>
235 10 : EventListenerManager::GetTargetAsInnerWindow() const
236 : {
237 20 : nsCOMPtr<nsPIDOMWindowInner> window = do_QueryInterface(mTarget);
238 20 : return window.forget();
239 : }
240 :
241 : void
242 2093 : EventListenerManager::AddEventListenerInternal(
243 : EventListenerHolder aListenerHolder,
244 : EventMessage aEventMessage,
245 : nsIAtom* aTypeAtom,
246 : const nsAString& aTypeString,
247 : const EventListenerFlags& aFlags,
248 : bool aHandler,
249 : bool aAllEvents)
250 : {
251 2093 : MOZ_ASSERT(// Main thread
252 : (NS_IsMainThread() && aEventMessage && aTypeAtom) ||
253 : // non-main-thread
254 : (!NS_IsMainThread() && aEventMessage) ||
255 : aAllEvents, "Missing type"); // all-events listener
256 :
257 2093 : if (!aListenerHolder || mClearingListeners) {
258 175 : return;
259 : }
260 :
261 : // Since there is no public API to call us with an EventListenerHolder, we
262 : // know that there's an EventListenerHolder on the stack holding a strong ref
263 : // to the listener.
264 :
265 : Listener* listener;
266 2093 : uint32_t count = mListeners.Length();
267 18030 : for (uint32_t i = 0; i < count; i++) {
268 16112 : listener = &mListeners.ElementAt(i);
269 : // mListener == aListenerHolder is the last one, since it can be a bit slow.
270 47316 : if (listener->mListenerIsHandler == aHandler &&
271 21367 : listener->mFlags.EqualsForAddition(aFlags) &&
272 7831 : EVENT_TYPE_EQUALS(listener, aEventMessage, aTypeAtom, aTypeString,
273 16639 : aAllEvents) &&
274 527 : listener->mListener == aListenerHolder) {
275 175 : return;
276 : }
277 : }
278 :
279 1918 : mNoListenerForEvent = eVoidEvent;
280 1918 : mNoListenerForEventAtom = nullptr;
281 :
282 3836 : listener = aAllEvents ? mListeners.InsertElementAt(0) :
283 1918 : mListeners.AppendElement();
284 1918 : listener->mEventMessage = aEventMessage;
285 1918 : listener->mTypeString = aTypeString;
286 1918 : listener->mTypeAtom = aTypeAtom;
287 1918 : listener->mFlags = aFlags;
288 1918 : listener->mListenerIsHandler = aHandler;
289 1918 : listener->mHandlerIsString = false;
290 1918 : listener->mAllEvents = aAllEvents;
291 3836 : listener->mIsChrome = mIsMainThreadELM &&
292 3836 : nsContentUtils::LegacyIsCallerChromeOrNativeCode();
293 :
294 : // Detect the type of event listener.
295 3836 : nsCOMPtr<nsIXPConnectWrappedJS> wjs;
296 1918 : if (aFlags.mListenerIsJSListener) {
297 551 : MOZ_ASSERT(!aListenerHolder.HasWebIDLCallback());
298 551 : listener->mListenerType = Listener::eJSEventListener;
299 1367 : } else if (aListenerHolder.HasWebIDLCallback()) {
300 176 : listener->mListenerType = Listener::eWebIDLListener;
301 1191 : } else if ((wjs = do_QueryInterface(aListenerHolder.GetXPCOMCallback()))) {
302 131 : listener->mListenerType = Listener::eWrappedJSListener;
303 : } else {
304 1060 : listener->mListenerType = Listener::eNativeListener;
305 : }
306 1918 : listener->mListener = Move(aListenerHolder);
307 :
308 :
309 1918 : if (aFlags.mInSystemGroup) {
310 380 : mMayHaveSystemGroupListeners = true;
311 : }
312 1918 : if (aFlags.mCapture) {
313 297 : mMayHaveCapturingListeners = true;
314 : }
315 :
316 1918 : if (aEventMessage == eAfterPaint) {
317 4 : mMayHavePaintEventListener = true;
318 4 : if (nsPIDOMWindowInner* window = GetInnerWindowForTarget()) {
319 2 : window->SetHasPaintEventListeners();
320 : }
321 2654 : } else if (aEventMessage >= eLegacyMutationEventFirst &&
322 740 : aEventMessage <= eLegacyMutationEventLast) {
323 : // For mutation listeners, we need to update the global bit on the DOM window.
324 : // Otherwise we won't actually fire the mutation event.
325 0 : mMayHaveMutationListeners = true;
326 : // Go from our target to the nearest enclosing DOM window.
327 0 : if (nsPIDOMWindowInner* window = GetInnerWindowForTarget()) {
328 0 : nsCOMPtr<nsIDocument> doc = window->GetExtantDoc();
329 0 : if (doc) {
330 0 : doc->WarnOnceAbout(nsIDocument::eMutationEvent);
331 : }
332 : // If aEventMessage is eLegacySubtreeModified, we need to listen all
333 : // mutations. nsContentUtils::HasMutationListeners relies on this.
334 0 : window->SetMutationListeners(
335 : (aEventMessage == eLegacySubtreeModified) ?
336 0 : kAllMutationBits : MutationBitForEventType(aEventMessage));
337 0 : }
338 1914 : } else if (aTypeAtom == nsGkAtoms::ondeviceorientation) {
339 0 : EnableDevice(eDeviceOrientation);
340 1914 : } else if (aTypeAtom == nsGkAtoms::onabsolutedeviceorientation) {
341 0 : EnableDevice(eAbsoluteDeviceOrientation);
342 1914 : } else if (aTypeAtom == nsGkAtoms::ondeviceproximity || aTypeAtom == nsGkAtoms::onuserproximity) {
343 0 : EnableDevice(eDeviceProximity);
344 1914 : } else if (aTypeAtom == nsGkAtoms::ondevicelight) {
345 0 : EnableDevice(eDeviceLight);
346 1914 : } else if (aTypeAtom == nsGkAtoms::ondevicemotion) {
347 0 : EnableDevice(eDeviceMotion);
348 : #if defined(MOZ_WIDGET_ANDROID) || defined(MOZ_WIDGET_GONK)
349 : } else if (aTypeAtom == nsGkAtoms::onorientationchange) {
350 : EnableDevice(eOrientationChange);
351 : #endif
352 : #ifdef MOZ_B2G
353 : } else if (aTypeAtom == nsGkAtoms::onmoztimechange) {
354 : EnableDevice(eTimeChange);
355 : } else if (aTypeAtom == nsGkAtoms::onmoznetworkupload) {
356 : EnableDevice(eNetworkUpload);
357 : } else if (aTypeAtom == nsGkAtoms::onmoznetworkdownload) {
358 : EnableDevice(eNetworkDownload);
359 : #endif // MOZ_B2G
360 3823 : } else if (aTypeAtom == nsGkAtoms::ontouchstart ||
361 3817 : aTypeAtom == nsGkAtoms::ontouchend ||
362 3815 : aTypeAtom == nsGkAtoms::ontouchmove ||
363 1907 : aTypeAtom == nsGkAtoms::ontouchcancel) {
364 7 : mMayHaveTouchEventListener = true;
365 7 : nsPIDOMWindowInner* window = GetInnerWindowForTarget();
366 : // we don't want touchevent listeners added by scrollbars to flip this flag
367 : // so we ignore listeners created with system event flag
368 7 : if (window && !aFlags.mInSystemGroup) {
369 3 : window->SetHasTouchEventListeners();
370 7 : }
371 3274 : } else if (aEventMessage >= ePointerEventFirst &&
372 1367 : aEventMessage <= ePointerEventLast) {
373 0 : nsPIDOMWindowInner* window = GetInnerWindowForTarget();
374 0 : if (aTypeAtom == nsGkAtoms::onpointerenter ||
375 0 : aTypeAtom == nsGkAtoms::onpointerleave) {
376 0 : mMayHavePointerEnterLeaveEventListener = true;
377 0 : if (window) {
378 : #ifdef DEBUG
379 0 : nsCOMPtr<nsIDocument> d = window->GetExtantDoc();
380 0 : NS_WARNING_ASSERTION(
381 : !nsContentUtils::IsChromeDoc(d),
382 : "Please do not use pointerenter/leave events in chrome. "
383 : "They are slower than pointerover/out!");
384 : #endif
385 0 : window->SetHasPointerEnterLeaveEventListeners();
386 : }
387 0 : }
388 3814 : } else if (aTypeAtom == nsGkAtoms::onmouseenter ||
389 1907 : aTypeAtom == nsGkAtoms::onmouseleave) {
390 0 : mMayHaveMouseEnterLeaveEventListener = true;
391 0 : if (nsPIDOMWindowInner* window = GetInnerWindowForTarget()) {
392 : #ifdef DEBUG
393 0 : nsCOMPtr<nsIDocument> d = window->GetExtantDoc();
394 0 : NS_WARNING_ASSERTION(
395 : !nsContentUtils::IsChromeDoc(d),
396 : "Please do not use mouseenter/leave events in chrome. "
397 : "They are slower than mouseover/out!");
398 : #endif
399 0 : window->SetHasMouseEnterLeaveEventListeners();
400 0 : }
401 1915 : } else if (aEventMessage >= eGamepadEventFirst &&
402 8 : aEventMessage <= eGamepadEventLast) {
403 0 : if (nsPIDOMWindowInner* window = GetInnerWindowForTarget()) {
404 0 : window->SetHasGamepadEventListener();
405 0 : }
406 3782 : } else if (aTypeAtom == nsGkAtoms::onkeydown ||
407 3675 : aTypeAtom == nsGkAtoms::onkeypress ||
408 1800 : aTypeAtom == nsGkAtoms::onkeyup) {
409 268 : if (!aFlags.mInSystemGroup) {
410 62 : mMayHaveKeyEventListener = true;
411 : }
412 3541 : } else if (aTypeAtom == nsGkAtoms::oncompositionend ||
413 3531 : aTypeAtom == nsGkAtoms::oncompositionstart ||
414 3526 : aTypeAtom == nsGkAtoms::oncompositionupdate ||
415 1763 : aTypeAtom == nsGkAtoms::oninput) {
416 34 : if (!aFlags.mInSystemGroup) {
417 13 : mMayHaveInputOrCompositionEventListener = true;
418 : }
419 1756 : } else if (aEventMessage == eSelectionChange) {
420 0 : mMayHaveSelectionChangeEventListener = true;
421 0 : if (nsPIDOMWindowInner* window = GetInnerWindowForTarget()) {
422 0 : window->SetHasSelectionChangeEventListeners();
423 : }
424 : }
425 :
426 1918 : if (IsApzAwareListener(listener)) {
427 3 : ProcessApzAwareEventListenerAdd();
428 : }
429 :
430 1918 : if (mTarget) {
431 1918 : if (aTypeAtom) {
432 1918 : mTarget->EventListenerAdded(aTypeAtom);
433 0 : } else if (!aTypeString.IsEmpty()) {
434 0 : mTarget->EventListenerAdded(aTypeString);
435 : }
436 : }
437 :
438 1918 : if (mIsMainThreadELM && mTarget) {
439 1918 : EventListenerService::NotifyAboutMainThreadListenerChange(mTarget,
440 1918 : aTypeAtom);
441 : }
442 : }
443 :
444 : void
445 3 : EventListenerManager::ProcessApzAwareEventListenerAdd()
446 : {
447 : // Mark the node as having apz aware listeners
448 6 : nsCOMPtr<nsINode> node = do_QueryInterface(mTarget);
449 3 : if (node) {
450 3 : node->SetMayBeApzAware();
451 : }
452 :
453 : // Schedule a paint so event regions on the layer tree gets updated
454 3 : nsIDocument* doc = nullptr;
455 3 : if (node) {
456 3 : doc = node->OwnerDoc();
457 : }
458 3 : if (!doc) {
459 0 : if (nsCOMPtr<nsPIDOMWindowInner> window = GetTargetAsInnerWindow()) {
460 0 : doc = window->GetExtantDoc();
461 : }
462 : }
463 3 : if (!doc) {
464 0 : if (nsCOMPtr<DOMEventTargetHelper> helper = do_QueryInterface(mTarget)) {
465 0 : if (nsPIDOMWindowInner* window = helper->GetOwner()) {
466 0 : doc = window->GetExtantDoc();
467 : }
468 : }
469 : }
470 :
471 3 : if (doc && nsDisplayListBuilder::LayerEventRegionsEnabled()) {
472 3 : nsIPresShell* ps = doc->GetShell();
473 3 : if (ps) {
474 3 : nsIFrame* f = ps->GetRootFrame();
475 3 : if (f) {
476 3 : f->SchedulePaint();
477 : }
478 : }
479 : }
480 3 : }
481 :
482 : bool
483 179 : EventListenerManager::IsDeviceType(EventMessage aEventMessage)
484 : {
485 179 : switch (aEventMessage) {
486 : case eDeviceOrientation:
487 : case eAbsoluteDeviceOrientation:
488 : case eDeviceMotion:
489 : case eDeviceLight:
490 : case eDeviceProximity:
491 : case eUserProximity:
492 : #if defined(MOZ_WIDGET_ANDROID) || defined(MOZ_WIDGET_GONK)
493 : case eOrientationChange:
494 : #endif
495 : #ifdef MOZ_B2G
496 : case eTimeChange:
497 : case eNetworkUpload:
498 : case eNetworkDownload:
499 : #endif
500 0 : return true;
501 : default:
502 179 : break;
503 : }
504 179 : return false;
505 : }
506 :
507 : void
508 0 : EventListenerManager::EnableDevice(EventMessage aEventMessage)
509 : {
510 0 : nsCOMPtr<nsPIDOMWindowInner> window = GetTargetAsInnerWindow();
511 0 : if (!window) {
512 0 : return;
513 : }
514 :
515 0 : switch (aEventMessage) {
516 : case eDeviceOrientation:
517 : #ifdef MOZ_WIDGET_ANDROID
518 : // Falls back to SENSOR_ROTATION_VECTOR and SENSOR_ORIENTATION if
519 : // unavailable on device.
520 : window->EnableDeviceSensor(SENSOR_GAME_ROTATION_VECTOR);
521 : window->EnableDeviceSensor(SENSOR_ROTATION_VECTOR);
522 : #else
523 0 : window->EnableDeviceSensor(SENSOR_ORIENTATION);
524 : #endif
525 0 : break;
526 : case eAbsoluteDeviceOrientation:
527 : #ifdef MOZ_WIDGET_ANDROID
528 : // Falls back to SENSOR_ORIENTATION if unavailable on device.
529 : window->EnableDeviceSensor(SENSOR_ROTATION_VECTOR);
530 : #else
531 0 : window->EnableDeviceSensor(SENSOR_ORIENTATION);
532 : #endif
533 0 : break;
534 : case eDeviceProximity:
535 : case eUserProximity:
536 0 : window->EnableDeviceSensor(SENSOR_PROXIMITY);
537 0 : break;
538 : case eDeviceLight:
539 0 : window->EnableDeviceSensor(SENSOR_LIGHT);
540 0 : break;
541 : case eDeviceMotion:
542 0 : window->EnableDeviceSensor(SENSOR_ACCELERATION);
543 0 : window->EnableDeviceSensor(SENSOR_LINEAR_ACCELERATION);
544 0 : window->EnableDeviceSensor(SENSOR_GYROSCOPE);
545 0 : break;
546 : #if defined(MOZ_WIDGET_ANDROID) || defined(MOZ_WIDGET_GONK)
547 : case eOrientationChange:
548 : window->EnableOrientationChangeListener();
549 : break;
550 : #endif
551 : #ifdef MOZ_B2G
552 : case eTimeChange:
553 : window->EnableTimeChangeNotifications();
554 : break;
555 : case eNetworkUpload:
556 : case eNetworkDownload:
557 : window->EnableNetworkEvent(aEventMessage);
558 : break;
559 : #endif
560 : default:
561 0 : NS_WARNING("Enabling an unknown device sensor.");
562 0 : break;
563 : }
564 : }
565 :
566 : void
567 0 : EventListenerManager::DisableDevice(EventMessage aEventMessage)
568 : {
569 0 : nsCOMPtr<nsPIDOMWindowInner> window = GetTargetAsInnerWindow();
570 0 : if (!window) {
571 0 : return;
572 : }
573 :
574 0 : switch (aEventMessage) {
575 : case eDeviceOrientation:
576 : #ifdef MOZ_WIDGET_ANDROID
577 : // Disable all potential fallback sensors.
578 : window->DisableDeviceSensor(SENSOR_GAME_ROTATION_VECTOR);
579 : window->DisableDeviceSensor(SENSOR_ROTATION_VECTOR);
580 : #endif
581 0 : window->DisableDeviceSensor(SENSOR_ORIENTATION);
582 0 : break;
583 : case eAbsoluteDeviceOrientation:
584 : #ifdef MOZ_WIDGET_ANDROID
585 : window->DisableDeviceSensor(SENSOR_ROTATION_VECTOR);
586 : #endif
587 0 : window->DisableDeviceSensor(SENSOR_ORIENTATION);
588 0 : break;
589 : case eDeviceMotion:
590 0 : window->DisableDeviceSensor(SENSOR_ACCELERATION);
591 0 : window->DisableDeviceSensor(SENSOR_LINEAR_ACCELERATION);
592 0 : window->DisableDeviceSensor(SENSOR_GYROSCOPE);
593 0 : break;
594 : case eDeviceProximity:
595 : case eUserProximity:
596 0 : window->DisableDeviceSensor(SENSOR_PROXIMITY);
597 0 : break;
598 : case eDeviceLight:
599 0 : window->DisableDeviceSensor(SENSOR_LIGHT);
600 0 : break;
601 : #if defined(MOZ_WIDGET_ANDROID) || defined(MOZ_WIDGET_GONK)
602 : case eOrientationChange:
603 : window->DisableOrientationChangeListener();
604 : break;
605 : #endif
606 : #ifdef MOZ_B2G
607 : case eTimeChange:
608 : window->DisableTimeChangeNotifications();
609 : break;
610 : case eNetworkUpload:
611 : case eNetworkDownload:
612 : window->DisableNetworkEvent(aEventMessage);
613 : break;
614 : #endif // MOZ_B2G
615 : default:
616 0 : NS_WARNING("Disabling an unknown device sensor.");
617 0 : break;
618 : }
619 : }
620 :
621 : void
622 169 : EventListenerManager::NotifyEventListenerRemoved(nsIAtom* aUserType,
623 : const nsAString& aTypeString)
624 : {
625 : // If the following code is changed, other callsites of EventListenerRemoved
626 : // and NotifyAboutMainThreadListenerChange should be changed too.
627 169 : mNoListenerForEvent = eVoidEvent;
628 169 : mNoListenerForEventAtom = nullptr;
629 169 : if (mTarget) {
630 169 : if (aUserType) {
631 169 : mTarget->EventListenerRemoved(aUserType);
632 0 : } else if (!aTypeString.IsEmpty()) {
633 0 : mTarget->EventListenerRemoved(aTypeString);
634 : }
635 : }
636 169 : if (mIsMainThreadELM && mTarget) {
637 169 : EventListenerService::NotifyAboutMainThreadListenerChange(mTarget,
638 169 : aUserType);
639 : }
640 169 : }
641 :
642 : void
643 178 : EventListenerManager::RemoveEventListenerInternal(
644 : EventListenerHolder aListenerHolder,
645 : EventMessage aEventMessage,
646 : nsIAtom* aUserType,
647 : const nsAString& aTypeString,
648 : const EventListenerFlags& aFlags,
649 : bool aAllEvents)
650 : {
651 178 : if (!aListenerHolder || !aEventMessage || mClearingListeners) {
652 168 : return;
653 : }
654 :
655 : Listener* listener;
656 :
657 178 : uint32_t count = mListeners.Length();
658 178 : bool deviceType = IsDeviceType(aEventMessage);
659 :
660 188 : RefPtr<EventListenerManager> kungFuDeathGrip(this);
661 :
662 2199 : for (uint32_t i = 0; i < count; ++i) {
663 2189 : listener = &mListeners.ElementAt(i);
664 2189 : if (EVENT_TYPE_EQUALS(listener, aEventMessage, aUserType, aTypeString,
665 : aAllEvents)) {
666 486 : if (listener->mListener == aListenerHolder &&
667 173 : listener->mFlags.EqualsForRemoval(aFlags)) {
668 168 : mListeners.RemoveElementAt(i);
669 168 : NotifyEventListenerRemoved(aUserType, aTypeString);
670 168 : if (!aAllEvents && deviceType) {
671 0 : DisableDevice(aEventMessage);
672 : }
673 168 : return;
674 : }
675 : }
676 : }
677 :
678 : }
679 :
680 : bool
681 21000 : EventListenerManager::ListenerCanHandle(const Listener* aListener,
682 : const WidgetEvent* aEvent,
683 : EventMessage aEventMessage) const
684 :
685 : {
686 21000 : MOZ_ASSERT(aEventMessage == aEvent->mMessage ||
687 : aEventMessage == GetLegacyEventMessage(aEvent->mMessage),
688 : "aEvent and aEventMessage should agree, modulo legacyness");
689 :
690 : // The listener has been removed, it cannot handle anything.
691 21000 : if (aListener->mListenerType == Listener::eNoListener) {
692 3 : return false;
693 : }
694 : // This is slightly different from EVENT_TYPE_EQUALS in that it returns
695 : // true even when aEvent->mMessage == eUnidentifiedEvent and
696 : // aListener=>mEventMessage != eUnidentifiedEvent as long as the atoms are
697 : // the same
698 20997 : if (MOZ_UNLIKELY(aListener->mAllEvents)) {
699 0 : return true;
700 : }
701 20997 : if (aEvent->mMessage == eUnidentifiedEvent) {
702 7297 : if (mIsMainThreadELM) {
703 7297 : return aListener->mTypeAtom == aEvent->mSpecifiedEventType;
704 : }
705 0 : return aListener->mTypeString.Equals(aEvent->mSpecifiedEventTypeString);
706 : }
707 13700 : if (MOZ_UNLIKELY(!nsContentUtils::IsUnprefixedFullscreenApiEnabled() &&
708 : aEvent->IsTrusted() && (aEventMessage == eFullscreenChange ||
709 : aEventMessage == eFullscreenError))) {
710 : // If unprefixed Fullscreen API is not enabled, don't dispatch it
711 : // to the content.
712 0 : if (!aEvent->mFlags.mInSystemGroup && !aListener->mIsChrome) {
713 0 : return false;
714 : }
715 : }
716 13700 : MOZ_ASSERT(mIsMainThreadELM);
717 13700 : return aListener->mEventMessage == aEventMessage;
718 : }
719 :
720 : void
721 1542 : EventListenerManager::AddEventListenerByType(
722 : EventListenerHolder aListenerHolder,
723 : const nsAString& aType,
724 : const EventListenerFlags& aFlags)
725 : {
726 3084 : nsCOMPtr<nsIAtom> atom;
727 4626 : EventMessage message = mIsMainThreadELM ?
728 1542 : nsContentUtils::GetEventMessageAndAtomForListener(aType,
729 4626 : getter_AddRefs(atom)) :
730 3084 : eUnidentifiedEvent;
731 3084 : AddEventListenerInternal(Move(aListenerHolder),
732 1542 : message, atom, aType, aFlags);
733 1542 : }
734 :
735 : void
736 178 : EventListenerManager::RemoveEventListenerByType(
737 : EventListenerHolder aListenerHolder,
738 : const nsAString& aType,
739 : const EventListenerFlags& aFlags)
740 : {
741 356 : nsCOMPtr<nsIAtom> atom;
742 534 : EventMessage message = mIsMainThreadELM ?
743 178 : nsContentUtils::GetEventMessageAndAtomForListener(aType,
744 534 : getter_AddRefs(atom)) :
745 356 : eUnidentifiedEvent;
746 356 : RemoveEventListenerInternal(Move(aListenerHolder),
747 178 : message, atom, aType, aFlags);
748 178 : }
749 :
750 : EventListenerManager::Listener*
751 1107 : EventListenerManager::FindEventHandler(EventMessage aEventMessage,
752 : nsIAtom* aTypeAtom,
753 : const nsAString& aTypeString)
754 : {
755 : // Run through the listeners for this type and see if a script
756 : // listener is registered
757 : Listener* listener;
758 1107 : uint32_t count = mListeners.Length();
759 1521 : for (uint32_t i = 0; i < count; ++i) {
760 970 : listener = &mListeners.ElementAt(i);
761 2430 : if (listener->mListenerIsHandler &&
762 1460 : EVENT_TYPE_EQUALS(listener, aEventMessage, aTypeAtom, aTypeString,
763 : false)) {
764 556 : return listener;
765 : }
766 : }
767 551 : return nullptr;
768 : }
769 :
770 : EventListenerManager::Listener*
771 556 : EventListenerManager::SetEventHandlerInternal(
772 : nsIAtom* aName,
773 : const nsAString& aTypeString,
774 : const TypedEventHandler& aTypedHandler,
775 : bool aPermitUntrustedEvents)
776 : {
777 556 : MOZ_ASSERT(aName || !aTypeString.IsEmpty());
778 :
779 556 : EventMessage eventMessage = nsContentUtils::GetEventMessage(aName);
780 556 : Listener* listener = FindEventHandler(eventMessage, aName, aTypeString);
781 :
782 556 : if (!listener) {
783 : // If we didn't find a script listener or no listeners existed
784 : // create and add a new one.
785 551 : EventListenerFlags flags;
786 551 : flags.mListenerIsJSListener = true;
787 :
788 1102 : nsCOMPtr<JSEventHandler> jsEventHandler;
789 551 : NS_NewJSEventHandler(mTarget, aName,
790 1102 : aTypedHandler, getter_AddRefs(jsEventHandler));
791 1102 : AddEventListenerInternal(EventListenerHolder(jsEventHandler),
792 551 : eventMessage, aName, aTypeString, flags, true);
793 :
794 551 : listener = FindEventHandler(eventMessage, aName, aTypeString);
795 : } else {
796 5 : JSEventHandler* jsEventHandler = listener->GetJSEventHandler();
797 5 : MOZ_ASSERT(jsEventHandler,
798 : "How can we have an event handler with no JSEventHandler?");
799 :
800 5 : bool same = jsEventHandler->GetTypedEventHandler() == aTypedHandler;
801 : // Possibly the same listener, but update still the context and scope.
802 5 : jsEventHandler->SetHandler(aTypedHandler);
803 5 : if (mTarget && !same) {
804 5 : if (aName) {
805 5 : mTarget->EventListenerRemoved(aName);
806 5 : mTarget->EventListenerAdded(aName);
807 0 : } else if (!aTypeString.IsEmpty()) {
808 0 : mTarget->EventListenerRemoved(aTypeString);
809 0 : mTarget->EventListenerAdded(aTypeString);
810 : }
811 : }
812 5 : if (mIsMainThreadELM && mTarget) {
813 5 : EventListenerService::NotifyAboutMainThreadListenerChange(mTarget, aName);
814 : }
815 : }
816 :
817 : // Set flag to indicate possible need for compilation later
818 556 : listener->mHandlerIsString = !aTypedHandler.HasEventHandler();
819 556 : if (aPermitUntrustedEvents) {
820 0 : listener->mFlags.mAllowUntrustedEvents = true;
821 : }
822 :
823 556 : return listener;
824 : }
825 :
826 : nsresult
827 554 : EventListenerManager::SetEventHandler(nsIAtom* aName,
828 : const nsAString& aBody,
829 : bool aDeferCompilation,
830 : bool aPermitUntrustedEvents,
831 : Element* aElement)
832 : {
833 1108 : nsCOMPtr<nsIDocument> doc;
834 : nsCOMPtr<nsIScriptGlobalObject> global =
835 1108 : GetScriptGlobalAndDocument(getter_AddRefs(doc));
836 :
837 554 : if (!global) {
838 : // This can happen; for example this document might have been
839 : // loaded as data.
840 0 : return NS_OK;
841 : }
842 :
843 : #ifdef DEBUG
844 1108 : if (nsCOMPtr<nsPIDOMWindowInner> win = do_QueryInterface(global)) {
845 554 : MOZ_ASSERT(win->IsInnerWindow(), "We should not have an outer window here!");
846 : }
847 : #endif
848 :
849 554 : nsresult rv = NS_OK;
850 : // return early preventing the event listener from being added
851 : // 'doc' is fetched above
852 554 : if (doc) {
853 : // Don't allow adding an event listener if the document is sandboxed
854 : // without 'allow-scripts'.
855 554 : if (doc->HasScriptsBlockedBySandbox()) {
856 0 : return NS_ERROR_DOM_SECURITY_ERR;
857 : }
858 :
859 : // Perform CSP check
860 1108 : nsCOMPtr<nsIContentSecurityPolicy> csp;
861 554 : rv = doc->NodePrincipal()->GetCsp(getter_AddRefs(csp));
862 554 : NS_ENSURE_SUCCESS(rv, rv);
863 :
864 554 : if (csp) {
865 : // let's generate a script sample and pass it as aContent,
866 : // it will not match the hash, but allows us to pass
867 : // the script sample in aContent.
868 0 : nsAutoString scriptSample, attr, tagName(NS_LITERAL_STRING("UNKNOWN"));
869 0 : aName->ToString(attr);
870 0 : nsCOMPtr<nsIDOMNode> domNode(do_QueryInterface(mTarget));
871 0 : if (domNode) {
872 0 : domNode->GetNodeName(tagName);
873 : }
874 : // build a "script sample" based on what we know about this element
875 0 : scriptSample.Assign(attr);
876 0 : scriptSample.AppendLiteral(" attribute on ");
877 0 : scriptSample.Append(tagName);
878 0 : scriptSample.AppendLiteral(" element");
879 :
880 0 : bool allowsInlineScript = true;
881 0 : rv = csp->GetAllowsInline(nsIContentPolicy::TYPE_SCRIPT,
882 0 : EmptyString(), // aNonce
883 : true, // aParserCreated (true because attribute event handler)
884 : scriptSample,
885 : 0, // aLineNumber
886 0 : &allowsInlineScript);
887 0 : NS_ENSURE_SUCCESS(rv, rv);
888 :
889 : // return early if CSP wants us to block inline scripts
890 0 : if (!allowsInlineScript) {
891 0 : return NS_OK;
892 : }
893 : }
894 : }
895 :
896 : // This might be the first reference to this language in the global
897 : // We must init the language before we attempt to fetch its context.
898 554 : if (NS_FAILED(global->EnsureScriptEnvironment())) {
899 0 : NS_WARNING("Failed to setup script environment for this language");
900 : // but fall through and let the inevitable failure below handle it.
901 : }
902 :
903 554 : nsIScriptContext* context = global->GetScriptContext();
904 554 : NS_ENSURE_TRUE(context, NS_ERROR_FAILURE);
905 554 : NS_ENSURE_STATE(global->GetGlobalJSObject());
906 :
907 1108 : Listener* listener = SetEventHandlerInternal(aName,
908 554 : EmptyString(),
909 1108 : TypedEventHandler(),
910 554 : aPermitUntrustedEvents);
911 :
912 554 : if (!aDeferCompilation) {
913 3 : return CompileEventHandlerInternal(listener, &aBody, aElement);
914 : }
915 :
916 551 : return NS_OK;
917 : }
918 :
919 : void
920 0 : EventListenerManager::RemoveEventHandler(nsIAtom* aName,
921 : const nsAString& aTypeString)
922 : {
923 0 : if (mClearingListeners) {
924 0 : return;
925 : }
926 :
927 0 : EventMessage eventMessage = nsContentUtils::GetEventMessage(aName);
928 0 : Listener* listener = FindEventHandler(eventMessage, aName, aTypeString);
929 :
930 0 : if (listener) {
931 0 : mListeners.RemoveElementAt(uint32_t(listener - &mListeners.ElementAt(0)));
932 0 : NotifyEventListenerRemoved(aName, aTypeString);
933 0 : if (IsDeviceType(eventMessage)) {
934 0 : DisableDevice(eventMessage);
935 : }
936 : }
937 : }
938 :
939 : nsresult
940 7 : EventListenerManager::CompileEventHandlerInternal(Listener* aListener,
941 : const nsAString* aBody,
942 : Element* aElement)
943 : {
944 7 : MOZ_ASSERT(aListener->GetJSEventHandler());
945 7 : MOZ_ASSERT(aListener->mHandlerIsString, "Why are we compiling a non-string JS listener?");
946 7 : JSEventHandler* jsEventHandler = aListener->GetJSEventHandler();
947 7 : MOZ_ASSERT(!jsEventHandler->GetTypedEventHandler().HasEventHandler(),
948 : "What is there to compile?");
949 :
950 7 : nsresult result = NS_OK;
951 14 : nsCOMPtr<nsIDocument> doc;
952 : nsCOMPtr<nsIScriptGlobalObject> global =
953 14 : GetScriptGlobalAndDocument(getter_AddRefs(doc));
954 7 : NS_ENSURE_STATE(global);
955 :
956 : // Activate JSAPI, and make sure that exceptions are reported on the right
957 : // Window.
958 14 : AutoJSAPI jsapi;
959 7 : if (NS_WARN_IF(!jsapi.Init(global))) {
960 0 : return NS_ERROR_UNEXPECTED;
961 : }
962 7 : JSContext* cx = jsapi.cx();
963 :
964 14 : nsCOMPtr<nsIAtom> typeAtom = aListener->mTypeAtom;
965 7 : nsIAtom* attrName = typeAtom;
966 :
967 : // Flag us as not a string so we don't keep trying to compile strings which
968 : // can't be compiled.
969 7 : aListener->mHandlerIsString = false;
970 :
971 : // mTarget may not be an Element if it's a window and we're
972 : // getting an inline event listener forwarded from <html:body> or
973 : // <html:frameset> or <xul:window> or the like.
974 : // XXX I don't like that we have to reference content from
975 : // here. The alternative is to store the event handler string on
976 : // the JSEventHandler itself, and that still doesn't address
977 : // the arg names issue.
978 14 : nsCOMPtr<Element> element = do_QueryInterface(mTarget);
979 7 : MOZ_ASSERT(element || aBody, "Where will we get our body?");
980 14 : nsAutoString handlerBody;
981 7 : const nsAString* body = aBody;
982 7 : if (!aBody) {
983 4 : if (aListener->mTypeAtom == nsGkAtoms::onSVGLoad) {
984 0 : attrName = nsGkAtoms::onload;
985 4 : } else if (aListener->mTypeAtom == nsGkAtoms::onSVGUnload) {
986 0 : attrName = nsGkAtoms::onunload;
987 4 : } else if (aListener->mTypeAtom == nsGkAtoms::onSVGResize) {
988 0 : attrName = nsGkAtoms::onresize;
989 4 : } else if (aListener->mTypeAtom == nsGkAtoms::onSVGScroll) {
990 0 : attrName = nsGkAtoms::onscroll;
991 4 : } else if (aListener->mTypeAtom == nsGkAtoms::onSVGZoom) {
992 0 : attrName = nsGkAtoms::onzoom;
993 4 : } else if (aListener->mTypeAtom == nsGkAtoms::onbeginEvent) {
994 0 : attrName = nsGkAtoms::onbegin;
995 4 : } else if (aListener->mTypeAtom == nsGkAtoms::onrepeatEvent) {
996 0 : attrName = nsGkAtoms::onrepeat;
997 4 : } else if (aListener->mTypeAtom == nsGkAtoms::onendEvent) {
998 0 : attrName = nsGkAtoms::onend;
999 : }
1000 :
1001 4 : element->GetAttr(kNameSpaceID_None, attrName, handlerBody);
1002 4 : body = &handlerBody;
1003 4 : aElement = element;
1004 : }
1005 7 : aListener = nullptr;
1006 :
1007 14 : nsAutoCString url (NS_LITERAL_CSTRING("-moz-evil:lying-event-listener"));
1008 7 : MOZ_ASSERT(body);
1009 7 : MOZ_ASSERT(aElement);
1010 7 : nsIURI *uri = aElement->OwnerDoc()->GetDocumentURI();
1011 7 : if (uri) {
1012 7 : uri->GetSpec(url);
1013 : }
1014 :
1015 14 : nsCOMPtr<nsPIDOMWindowInner> win = do_QueryInterface(mTarget);
1016 : uint32_t argCount;
1017 : const char **argNames;
1018 7 : nsContentUtils::GetEventArgNames(aElement->GetNameSpaceID(),
1019 : typeAtom, win,
1020 14 : &argCount, &argNames);
1021 :
1022 7 : JSAddonId *addonId = MapURIToAddonID(uri);
1023 :
1024 : // Wrap the event target, so that we can use it as the scope for the event
1025 : // handler. Note that mTarget is different from aElement in the <body> case,
1026 : // where mTarget is a Window.
1027 : //
1028 : // The wrapScope doesn't really matter here, because the target will create
1029 : // its reflector in the proper scope, and then we'll enter that compartment.
1030 14 : JS::Rooted<JSObject*> wrapScope(cx, global->GetGlobalJSObject());
1031 14 : JS::Rooted<JS::Value> v(cx);
1032 : {
1033 14 : JSAutoCompartment ac(cx, wrapScope);
1034 14 : nsresult rv = nsContentUtils::WrapNative(cx, mTarget, &v,
1035 7 : /* aAllowWrapping = */ false);
1036 7 : if (NS_WARN_IF(NS_FAILED(rv))) {
1037 0 : return rv;
1038 : }
1039 : }
1040 :
1041 7 : if (addonId) {
1042 0 : JS::Rooted<JSObject*> vObj(cx, &v.toObject());
1043 0 : JS::Rooted<JSObject*> addonScope(cx, xpc::GetAddonScope(cx, vObj, addonId));
1044 0 : if (!addonScope) {
1045 0 : return NS_ERROR_FAILURE;
1046 : }
1047 0 : JSAutoCompartment ac(cx, addonScope);
1048 :
1049 : // Wrap our event target into the addon scope, since that's where we want to
1050 : // do all our work.
1051 0 : if (!JS_WrapValue(cx, &v)) {
1052 0 : return NS_ERROR_FAILURE;
1053 : }
1054 : }
1055 14 : JS::Rooted<JSObject*> target(cx, &v.toObject());
1056 14 : JSAutoCompartment ac(cx, target);
1057 :
1058 : // Now that we've entered the compartment we actually care about, create our
1059 : // scope chain. Note that we start with |element|, not aElement, because
1060 : // mTarget is different from aElement in the <body> case, where mTarget is a
1061 : // Window, and in that case we do not want the scope chain to include the body
1062 : // or the document.
1063 14 : JS::AutoObjectVector scopeChain(cx);
1064 7 : if (!nsJSUtils::GetScopeChainForElement(cx, element, scopeChain)) {
1065 0 : return NS_ERROR_OUT_OF_MEMORY;
1066 : }
1067 :
1068 14 : nsDependentAtomString str(attrName);
1069 : // Most of our names are short enough that we don't even have to malloc
1070 : // the JS string stuff, so don't worry about playing games with
1071 : // refcounting XPCOM stringbuffers.
1072 14 : JS::Rooted<JSString*> jsStr(cx, JS_NewUCStringCopyN(cx,
1073 : str.BeginReading(),
1074 21 : str.Length()));
1075 7 : NS_ENSURE_TRUE(jsStr, NS_ERROR_OUT_OF_MEMORY);
1076 :
1077 : // Get the reflector for |aElement|, so that we can pass to setElement.
1078 7 : if (NS_WARN_IF(!GetOrCreateDOMReflector(cx, aElement, &v))) {
1079 0 : return NS_ERROR_FAILURE;
1080 : }
1081 14 : JS::CompileOptions options(cx);
1082 : // Use line 0 to make the function body starts from line 1.
1083 7 : options.setIntroductionType("eventHandler")
1084 14 : .setFileAndLine(url.get(), 0)
1085 7 : .setVersion(JSVERSION_DEFAULT)
1086 14 : .setElement(&v.toObject())
1087 14 : .setElementAttributeName(jsStr);
1088 :
1089 14 : JS::Rooted<JSObject*> handler(cx);
1090 7 : result = nsJSUtils::CompileFunction(jsapi, scopeChain, options,
1091 14 : nsAtomCString(typeAtom),
1092 7 : argCount, argNames, *body, handler.address());
1093 7 : NS_ENSURE_SUCCESS(result, result);
1094 7 : NS_ENSURE_TRUE(handler, NS_ERROR_FAILURE);
1095 :
1096 7 : if (jsEventHandler->EventName() == nsGkAtoms::onerror && win) {
1097 : RefPtr<OnErrorEventHandlerNonNull> handlerCallback =
1098 0 : new OnErrorEventHandlerNonNull(nullptr, handler, /* aIncumbentGlobal = */ nullptr);
1099 0 : jsEventHandler->SetHandler(handlerCallback);
1100 7 : } else if (jsEventHandler->EventName() == nsGkAtoms::onbeforeunload && win) {
1101 : RefPtr<OnBeforeUnloadEventHandlerNonNull> handlerCallback =
1102 0 : new OnBeforeUnloadEventHandlerNonNull(nullptr, handler, /* aIncumbentGlobal = */ nullptr);
1103 0 : jsEventHandler->SetHandler(handlerCallback);
1104 : } else {
1105 : RefPtr<EventHandlerNonNull> handlerCallback =
1106 21 : new EventHandlerNonNull(nullptr, handler, /* aIncumbentGlobal = */ nullptr);
1107 7 : jsEventHandler->SetHandler(handlerCallback);
1108 : }
1109 :
1110 7 : return result;
1111 : }
1112 :
1113 : nsresult
1114 146 : EventListenerManager::HandleEventSubType(Listener* aListener,
1115 : nsIDOMEvent* aDOMEvent,
1116 : EventTarget* aCurrentTarget)
1117 : {
1118 146 : nsresult result = NS_OK;
1119 : // strong ref
1120 292 : EventListenerHolder listenerHolder(aListener->mListener.Clone());
1121 :
1122 : // If this is a script handler and we haven't yet
1123 : // compiled the event handler itself
1124 155 : if ((aListener->mListenerType == Listener::eJSEventListener) &&
1125 9 : aListener->mHandlerIsString) {
1126 4 : result = CompileEventHandlerInternal(aListener, nullptr, nullptr);
1127 4 : aListener = nullptr;
1128 : }
1129 :
1130 146 : if (NS_SUCCEEDED(result)) {
1131 146 : if (mIsMainThreadELM) {
1132 146 : nsContentUtils::EnterMicroTask();
1133 : }
1134 : // nsIDOMEvent::currentTarget is set in EventDispatcher.
1135 146 : if (listenerHolder.HasWebIDLCallback()) {
1136 64 : ErrorResult rv;
1137 : listenerHolder.GetWebIDLCallback()->
1138 32 : HandleEvent(aCurrentTarget, *(aDOMEvent->InternalDOMEvent()), rv);
1139 32 : result = rv.StealNSResult();
1140 : } else {
1141 114 : result = listenerHolder.GetXPCOMCallback()->HandleEvent(aDOMEvent);
1142 : }
1143 146 : if (mIsMainThreadELM) {
1144 146 : nsContentUtils::LeaveMicroTask();
1145 : }
1146 : }
1147 :
1148 292 : return result;
1149 : }
1150 :
1151 : EventMessage
1152 941 : EventListenerManager::GetLegacyEventMessage(EventMessage aEventMessage) const
1153 : {
1154 : // (If we're off-main-thread, we can't check the pref; so we just behave as
1155 : // if it's disabled.)
1156 941 : if (mIsMainThreadELM) {
1157 941 : if (IsWebkitPrefixSupportEnabled()) {
1158 : // webkit-prefixed legacy events:
1159 941 : if (aEventMessage == eTransitionEnd) {
1160 282 : return eWebkitTransitionEnd;
1161 : }
1162 659 : if (aEventMessage == eAnimationStart) {
1163 0 : return eWebkitAnimationStart;
1164 : }
1165 659 : if (aEventMessage == eAnimationEnd) {
1166 0 : return eWebkitAnimationEnd;
1167 : }
1168 659 : if (aEventMessage == eAnimationIteration) {
1169 0 : return eWebkitAnimationIteration;
1170 : }
1171 : }
1172 : }
1173 :
1174 659 : switch (aEventMessage) {
1175 : case eFullscreenChange:
1176 0 : return eMozFullscreenChange;
1177 : case eFullscreenError:
1178 0 : return eMozFullscreenError;
1179 : default:
1180 659 : return aEventMessage;
1181 : }
1182 : }
1183 :
1184 : /**
1185 : * Causes a check for event listeners and processing by them if they exist.
1186 : * @param an event listener
1187 : */
1188 :
1189 : void
1190 800 : EventListenerManager::HandleEventInternal(nsPresContext* aPresContext,
1191 : WidgetEvent* aEvent,
1192 : nsIDOMEvent** aDOMEvent,
1193 : EventTarget* aCurrentTarget,
1194 : nsEventStatus* aEventStatus)
1195 : {
1196 : //Set the value of the internal PreventDefault flag properly based on aEventStatus
1197 1600 : if (!aEvent->DefaultPrevented() &&
1198 800 : *aEventStatus == nsEventStatus_eConsumeNoDefault) {
1199 : // Assume that if only aEventStatus claims that the event has already been
1200 : // consumed, the consumer is default event handler.
1201 0 : aEvent->PreventDefault();
1202 : }
1203 :
1204 1600 : Maybe<nsAutoPopupStatePusher> popupStatePusher;
1205 800 : if (mIsMainThreadELM) {
1206 800 : popupStatePusher.emplace(Event::GetEventPopupControlState(aEvent, *aDOMEvent));
1207 : }
1208 :
1209 800 : bool hasListener = false;
1210 800 : bool hasListenerForCurrentGroup = false;
1211 800 : bool usingLegacyMessage = false;
1212 800 : bool hasRemovedListener = false;
1213 800 : EventMessage eventMessage = aEvent->mMessage;
1214 :
1215 : while (true) {
1216 820 : nsAutoTObserverArray<Listener, 2>::EndLimitedIterator iter(mListeners);
1217 820 : Maybe<EventMessageAutoOverride> legacyAutoOverride;
1218 42810 : while (iter.HasMore()) {
1219 21000 : if (aEvent->mFlags.mImmediatePropagationStopped) {
1220 0 : break;
1221 : }
1222 21000 : Listener* listener = &iter.GetNext();
1223 : // Check that the phase is same in event and event listener.
1224 : // Handle only trusted events, except when listener permits untrusted events.
1225 21000 : if (ListenerCanHandle(listener, aEvent, eventMessage)) {
1226 347 : hasListener = true;
1227 614 : hasListenerForCurrentGroup = hasListenerForCurrentGroup ||
1228 267 : listener->mFlags.mInSystemGroup == aEvent->mFlags.mInSystemGroup;
1229 639 : if (listener->IsListening(aEvent) &&
1230 146 : (aEvent->IsTrusted() || listener->mFlags.mAllowUntrustedEvents)) {
1231 146 : if (!*aDOMEvent) {
1232 : // This is tiny bit slow, but happens only once per event.
1233 : nsCOMPtr<EventTarget> et =
1234 62 : do_QueryInterface(aEvent->mOriginalTarget);
1235 62 : RefPtr<Event> event = EventDispatcher::CreateEvent(et, aPresContext,
1236 : aEvent,
1237 93 : EmptyString());
1238 31 : event.forget(aDOMEvent);
1239 : }
1240 146 : if (*aDOMEvent) {
1241 146 : if (!aEvent->mCurrentTarget) {
1242 113 : aEvent->mCurrentTarget = aCurrentTarget->GetTargetForDOMEvent();
1243 113 : if (!aEvent->mCurrentTarget) {
1244 0 : break;
1245 : }
1246 : }
1247 146 : if (usingLegacyMessage && !legacyAutoOverride) {
1248 : // Override the aDOMEvent's event-message (its .type) until we
1249 : // finish traversing listeners (when legacyAutoOverride destructs)
1250 0 : legacyAutoOverride.emplace(*aDOMEvent, eventMessage);
1251 : }
1252 :
1253 : // Maybe add a marker to the docshell's timeline, but only
1254 : // bother with all the logic if some docshell is recording.
1255 292 : nsCOMPtr<nsIDocShell> docShell;
1256 292 : RefPtr<TimelineConsumers> timelines = TimelineConsumers::Get();
1257 146 : bool needsEndEventMarker = false;
1258 :
1259 292 : if (mIsMainThreadELM &&
1260 292 : listener->mListenerType != Listener::eNativeListener) {
1261 81 : docShell = nsContentUtils::GetDocShellForEventTarget(mTarget);
1262 81 : if (docShell) {
1263 41 : if (timelines && timelines->HasConsumer(docShell)) {
1264 0 : needsEndEventMarker = true;
1265 0 : nsAutoString typeStr;
1266 0 : (*aDOMEvent)->GetType(typeStr);
1267 : uint16_t phase;
1268 0 : (*aDOMEvent)->GetEventPhase(&phase);
1269 0 : timelines->AddMarkerForDocShell(docShell, Move(
1270 0 : MakeUnique<EventTimelineMarker>(
1271 0 : typeStr, phase, MarkerTracingType::START)));
1272 : }
1273 : }
1274 : }
1275 :
1276 146 : aEvent->mFlags.mInPassiveListener = listener->mFlags.mPassive;
1277 292 : Maybe<Listener> listenerHolder;
1278 146 : if (listener->mFlags.mOnce) {
1279 : // Move the listener to the stack before handling the event.
1280 : // The order is important, otherwise the listener could be
1281 : // called again inside the listener.
1282 1 : listenerHolder.emplace(Move(*listener));
1283 1 : listener = listenerHolder.ptr();
1284 1 : hasRemovedListener = true;
1285 : }
1286 :
1287 146 : nsresult rv = NS_OK;
1288 146 : if (profiler_is_active()) {
1289 : // Add a profiler label and a profiler marker for the actual
1290 : // dispatch of the event.
1291 : // This is a very hot code path, so we need to make sure not to
1292 : // do this extra work when we're not profiling.
1293 0 : nsAutoString typeStr;
1294 0 : (*aDOMEvent)->GetType(typeStr);
1295 0 : NS_LossyConvertUTF16toASCII typeCStr(typeStr);
1296 0 : AUTO_PROFILER_LABEL_DYNAMIC(
1297 : "EventListenerManager::HandleEventInternal", EVENTS,
1298 : typeCStr.get());
1299 0 : TimeStamp startTime = TimeStamp::Now();
1300 :
1301 0 : rv = HandleEventSubType(listener, *aDOMEvent, aCurrentTarget);
1302 :
1303 0 : TimeStamp endTime = TimeStamp::Now();
1304 : uint16_t phase;
1305 0 : (*aDOMEvent)->GetEventPhase(&phase);
1306 0 : profiler_add_marker(
1307 : "DOMEvent",
1308 0 : MakeUnique<DOMEventMarkerPayload>(typeStr, phase,
1309 0 : startTime, endTime));
1310 : } else {
1311 146 : rv = HandleEventSubType(listener, *aDOMEvent, aCurrentTarget);
1312 : }
1313 :
1314 146 : if (NS_FAILED(rv)) {
1315 0 : aEvent->mFlags.mExceptionWasRaised = true;
1316 : }
1317 146 : aEvent->mFlags.mInPassiveListener = false;
1318 :
1319 146 : if (needsEndEventMarker) {
1320 0 : timelines->AddMarkerForDocShell(
1321 0 : docShell, "DOMEvent", MarkerTracingType::END);
1322 : }
1323 : }
1324 : }
1325 : }
1326 : }
1327 :
1328 : // If we didn't find any matching listeners, and our event has a legacy
1329 : // version, we'll now switch to looking for that legacy version and we'll
1330 : // recheck our listeners.
1331 1479 : if (hasListenerForCurrentGroup ||
1332 1469 : usingLegacyMessage || !aEvent->IsTrusted()) {
1333 : // No need to recheck listeners, because we already found a match, we
1334 : // already rechecked them, or it is not a trusted event.
1335 151 : break;
1336 : }
1337 659 : EventMessage legacyEventMessage = GetLegacyEventMessage(eventMessage);
1338 659 : if (legacyEventMessage == eventMessage) {
1339 649 : break; // There's no legacy version of our event; no need to recheck.
1340 : }
1341 10 : MOZ_ASSERT(GetLegacyEventMessage(legacyEventMessage) == legacyEventMessage,
1342 : "Legacy event messages should not themselves have legacy versions");
1343 :
1344 : // Recheck our listeners, using the legacy event message we just looked up:
1345 10 : eventMessage = legacyEventMessage;
1346 10 : usingLegacyMessage = true;
1347 10 : }
1348 :
1349 800 : aEvent->mCurrentTarget = nullptr;
1350 :
1351 800 : if (hasRemovedListener) {
1352 : // If there are any once listeners replaced with a placeholder in
1353 : // the loop above, we need to clean up them here. Note that, this
1354 : // could clear once listeners handled in some outer level as well,
1355 : // but that should not affect the result.
1356 13 : mListeners.RemoveElementsBy([](const Listener& aListener) {
1357 11 : return aListener.mListenerType == Listener::eNoListener;
1358 12 : });
1359 1 : NotifyEventListenerRemoved(aEvent->mSpecifiedEventType,
1360 1 : aEvent->mSpecifiedEventTypeString);
1361 1 : if (IsDeviceType(aEvent->mMessage)) {
1362 : // This is a device-type event, we need to check whether we can
1363 : // disable device after removing the once listeners.
1364 0 : bool hasAnyListener = false;
1365 0 : nsAutoTObserverArray<Listener, 2>::ForwardIterator iter(mListeners);
1366 0 : while (iter.HasMore()) {
1367 0 : Listener* listener = &iter.GetNext();
1368 0 : if (EVENT_TYPE_EQUALS(listener, aEvent->mMessage,
1369 : aEvent->mSpecifiedEventType,
1370 : aEvent->mSpecifiedEventTypeString,
1371 : /* all events */ false)) {
1372 0 : hasAnyListener = true;
1373 0 : break;
1374 : }
1375 : }
1376 0 : if (!hasAnyListener) {
1377 0 : DisableDevice(aEvent->mMessage);
1378 : }
1379 : }
1380 : }
1381 :
1382 800 : if (mIsMainThreadELM && !hasListener) {
1383 597 : mNoListenerForEvent = aEvent->mMessage;
1384 597 : mNoListenerForEventAtom = aEvent->mSpecifiedEventType;
1385 : }
1386 :
1387 800 : if (aEvent->DefaultPrevented()) {
1388 0 : *aEventStatus = nsEventStatus_eConsumeNoDefault;
1389 : }
1390 800 : }
1391 :
1392 : void
1393 4 : EventListenerManager::Disconnect()
1394 : {
1395 4 : mTarget = nullptr;
1396 4 : RemoveAllListeners();
1397 4 : }
1398 :
1399 : void
1400 343 : EventListenerManager::AddEventListener(
1401 : const nsAString& aType,
1402 : EventListenerHolder aListenerHolder,
1403 : bool aUseCapture,
1404 : bool aWantsUntrusted)
1405 : {
1406 343 : EventListenerFlags flags;
1407 343 : flags.mCapture = aUseCapture;
1408 343 : flags.mAllowUntrustedEvents = aWantsUntrusted;
1409 343 : return AddEventListenerByType(Move(aListenerHolder), aType, flags);
1410 : }
1411 :
1412 : void
1413 177 : EventListenerManager::AddEventListener(
1414 : const nsAString& aType,
1415 : EventListenerHolder aListenerHolder,
1416 : const dom::AddEventListenerOptionsOrBoolean& aOptions,
1417 : bool aWantsUntrusted)
1418 : {
1419 177 : EventListenerFlags flags;
1420 177 : if (aOptions.IsBoolean()) {
1421 42 : flags.mCapture = aOptions.GetAsBoolean();
1422 : } else {
1423 135 : const auto& options = aOptions.GetAsAddEventListenerOptions();
1424 135 : flags.mCapture = options.mCapture;
1425 135 : flags.mInSystemGroup = options.mMozSystemGroup;
1426 135 : flags.mPassive = options.mPassive;
1427 135 : flags.mOnce = options.mOnce;
1428 : }
1429 177 : flags.mAllowUntrustedEvents = aWantsUntrusted;
1430 177 : return AddEventListenerByType(Move(aListenerHolder), aType, flags);
1431 : }
1432 :
1433 : void
1434 100 : EventListenerManager::RemoveEventListener(
1435 : const nsAString& aType,
1436 : EventListenerHolder aListenerHolder,
1437 : bool aUseCapture)
1438 : {
1439 100 : EventListenerFlags flags;
1440 100 : flags.mCapture = aUseCapture;
1441 100 : RemoveEventListenerByType(Move(aListenerHolder), aType, flags);
1442 100 : }
1443 :
1444 : void
1445 15 : EventListenerManager::RemoveEventListener(
1446 : const nsAString& aType,
1447 : EventListenerHolder aListenerHolder,
1448 : const dom::EventListenerOptionsOrBoolean& aOptions)
1449 : {
1450 15 : EventListenerFlags flags;
1451 15 : if (aOptions.IsBoolean()) {
1452 7 : flags.mCapture = aOptions.GetAsBoolean();
1453 : } else {
1454 8 : const auto& options = aOptions.GetAsEventListenerOptions();
1455 8 : flags.mCapture = options.mCapture;
1456 8 : flags.mInSystemGroup = options.mMozSystemGroup;
1457 : }
1458 15 : RemoveEventListenerByType(Move(aListenerHolder), aType, flags);
1459 15 : }
1460 :
1461 : void
1462 0 : EventListenerManager::AddListenerForAllEvents(nsIDOMEventListener* aDOMListener,
1463 : bool aUseCapture,
1464 : bool aWantsUntrusted,
1465 : bool aSystemEventGroup)
1466 : {
1467 0 : EventListenerFlags flags;
1468 0 : flags.mCapture = aUseCapture;
1469 0 : flags.mAllowUntrustedEvents = aWantsUntrusted;
1470 0 : flags.mInSystemGroup = aSystemEventGroup;
1471 0 : AddEventListenerInternal(EventListenerHolder(aDOMListener), eAllEvents,
1472 0 : nullptr, EmptyString(), flags, false, true);
1473 0 : }
1474 :
1475 : void
1476 0 : EventListenerManager::RemoveListenerForAllEvents(
1477 : nsIDOMEventListener* aDOMListener,
1478 : bool aUseCapture,
1479 : bool aSystemEventGroup)
1480 : {
1481 0 : EventListenerFlags flags;
1482 0 : flags.mCapture = aUseCapture;
1483 0 : flags.mInSystemGroup = aSystemEventGroup;
1484 0 : RemoveEventListenerInternal(EventListenerHolder(aDOMListener), eAllEvents,
1485 0 : nullptr, EmptyString(), flags, true);
1486 0 : }
1487 :
1488 : bool
1489 21 : EventListenerManager::HasMutationListeners()
1490 : {
1491 21 : if (mMayHaveMutationListeners) {
1492 0 : uint32_t count = mListeners.Length();
1493 0 : for (uint32_t i = 0; i < count; ++i) {
1494 0 : Listener* listener = &mListeners.ElementAt(i);
1495 0 : if (listener->mEventMessage >= eLegacyMutationEventFirst &&
1496 0 : listener->mEventMessage <= eLegacyMutationEventLast) {
1497 0 : return true;
1498 : }
1499 : }
1500 : }
1501 :
1502 21 : return false;
1503 : }
1504 :
1505 : uint32_t
1506 0 : EventListenerManager::MutationListenerBits()
1507 : {
1508 0 : uint32_t bits = 0;
1509 0 : if (mMayHaveMutationListeners) {
1510 0 : uint32_t count = mListeners.Length();
1511 0 : for (uint32_t i = 0; i < count; ++i) {
1512 0 : Listener* listener = &mListeners.ElementAt(i);
1513 0 : if (listener->mEventMessage >= eLegacyMutationEventFirst &&
1514 0 : listener->mEventMessage <= eLegacyMutationEventLast) {
1515 0 : if (listener->mEventMessage == eLegacySubtreeModified) {
1516 0 : return kAllMutationBits;
1517 : }
1518 0 : bits |= MutationBitForEventType(listener->mEventMessage);
1519 : }
1520 : }
1521 : }
1522 0 : return bits;
1523 : }
1524 :
1525 : bool
1526 2 : EventListenerManager::HasListenersFor(const nsAString& aEventName)
1527 : {
1528 2 : if (mIsMainThreadELM) {
1529 4 : nsCOMPtr<nsIAtom> atom = NS_Atomize(NS_LITERAL_STRING("on") + aEventName);
1530 2 : return HasListenersFor(atom);
1531 : }
1532 :
1533 0 : uint32_t count = mListeners.Length();
1534 0 : for (uint32_t i = 0; i < count; ++i) {
1535 0 : Listener* listener = &mListeners.ElementAt(i);
1536 0 : if (listener->mTypeString == aEventName) {
1537 0 : return true;
1538 : }
1539 : }
1540 0 : return false;
1541 : }
1542 :
1543 : bool
1544 6 : EventListenerManager::HasListenersFor(nsIAtom* aEventNameWithOn)
1545 : {
1546 : #ifdef DEBUG
1547 12 : nsAutoString name;
1548 6 : aEventNameWithOn->ToString(name);
1549 : #endif
1550 6 : NS_ASSERTION(StringBeginsWith(name, NS_LITERAL_STRING("on")),
1551 : "Event name does not start with 'on'");
1552 6 : uint32_t count = mListeners.Length();
1553 22 : for (uint32_t i = 0; i < count; ++i) {
1554 22 : Listener* listener = &mListeners.ElementAt(i);
1555 22 : if (listener->mTypeAtom == aEventNameWithOn) {
1556 6 : return true;
1557 : }
1558 : }
1559 0 : return false;
1560 : }
1561 :
1562 : bool
1563 0 : EventListenerManager::HasListeners()
1564 : {
1565 0 : return !mListeners.IsEmpty();
1566 : }
1567 :
1568 : nsresult
1569 0 : EventListenerManager::GetListenerInfo(nsCOMArray<nsIEventListenerInfo>* aList)
1570 : {
1571 0 : nsCOMPtr<EventTarget> target = do_QueryInterface(mTarget);
1572 0 : NS_ENSURE_STATE(target);
1573 0 : aList->Clear();
1574 0 : nsAutoTObserverArray<Listener, 2>::ForwardIterator iter(mListeners);
1575 0 : while (iter.HasMore()) {
1576 0 : const Listener& listener = iter.GetNext();
1577 : // If this is a script handler and we haven't yet
1578 : // compiled the event handler itself go ahead and compile it
1579 0 : if (listener.mListenerType == Listener::eJSEventListener &&
1580 0 : listener.mHandlerIsString) {
1581 : CompileEventHandlerInternal(const_cast<Listener*>(&listener), nullptr,
1582 0 : nullptr);
1583 : }
1584 0 : nsAutoString eventType;
1585 0 : if (listener.mAllEvents) {
1586 0 : eventType.SetIsVoid(true);
1587 0 : } else if (listener.mListenerType == Listener::eNoListener) {
1588 0 : continue;
1589 : } else {
1590 0 : eventType.Assign(Substring(nsDependentAtomString(listener.mTypeAtom), 2));
1591 : }
1592 0 : nsCOMPtr<nsIDOMEventListener> callback = listener.mListener.ToXPCOMCallback();
1593 0 : if (!callback) {
1594 : // This will be null for cross-compartment event listeners which have been
1595 : // destroyed.
1596 0 : continue;
1597 : }
1598 : // EventListenerInfo is defined in XPCOM, so we have to go ahead
1599 : // and convert to an XPCOM callback here...
1600 : RefPtr<EventListenerInfo> info =
1601 0 : new EventListenerInfo(eventType, callback.forget(),
1602 0 : listener.mFlags.mCapture,
1603 0 : listener.mFlags.mAllowUntrustedEvents,
1604 0 : listener.mFlags.mInSystemGroup);
1605 0 : aList->AppendElement(info.forget());
1606 : }
1607 0 : return NS_OK;
1608 : }
1609 :
1610 : bool
1611 0 : EventListenerManager::HasUnloadListeners()
1612 : {
1613 0 : uint32_t count = mListeners.Length();
1614 0 : for (uint32_t i = 0; i < count; ++i) {
1615 0 : Listener* listener = &mListeners.ElementAt(i);
1616 0 : if (listener->mEventMessage == eUnload ||
1617 0 : listener->mEventMessage == eBeforeUnload) {
1618 0 : return true;
1619 : }
1620 : }
1621 0 : return false;
1622 : }
1623 :
1624 : void
1625 2 : EventListenerManager::SetEventHandler(nsIAtom* aEventName,
1626 : const nsAString& aTypeString,
1627 : EventHandlerNonNull* aHandler)
1628 : {
1629 2 : if (!aHandler) {
1630 0 : RemoveEventHandler(aEventName, aTypeString);
1631 0 : return;
1632 : }
1633 :
1634 : // Untrusted events are always permitted for non-chrome script
1635 : // handlers.
1636 4 : SetEventHandlerInternal(aEventName, aTypeString, TypedEventHandler(aHandler),
1637 4 : !mIsMainThreadELM ||
1638 4 : !nsContentUtils::IsCallerChrome());
1639 : }
1640 :
1641 : void
1642 0 : EventListenerManager::SetEventHandler(OnErrorEventHandlerNonNull* aHandler)
1643 : {
1644 0 : if (mIsMainThreadELM) {
1645 0 : if (!aHandler) {
1646 0 : RemoveEventHandler(nsGkAtoms::onerror, EmptyString());
1647 0 : return;
1648 : }
1649 :
1650 : // Untrusted events are always permitted for non-chrome script
1651 : // handlers.
1652 0 : SetEventHandlerInternal(nsGkAtoms::onerror, EmptyString(),
1653 0 : TypedEventHandler(aHandler),
1654 0 : !nsContentUtils::IsCallerChrome());
1655 : } else {
1656 0 : if (!aHandler) {
1657 0 : RemoveEventHandler(nullptr, NS_LITERAL_STRING("error"));
1658 0 : return;
1659 : }
1660 :
1661 : // Untrusted events are always permitted.
1662 0 : SetEventHandlerInternal(nullptr, NS_LITERAL_STRING("error"),
1663 0 : TypedEventHandler(aHandler), true);
1664 : }
1665 : }
1666 :
1667 : void
1668 0 : EventListenerManager::SetEventHandler(
1669 : OnBeforeUnloadEventHandlerNonNull* aHandler)
1670 : {
1671 0 : if (!aHandler) {
1672 0 : RemoveEventHandler(nsGkAtoms::onbeforeunload, EmptyString());
1673 0 : return;
1674 : }
1675 :
1676 : // Untrusted events are always permitted for non-chrome script
1677 : // handlers.
1678 0 : SetEventHandlerInternal(nsGkAtoms::onbeforeunload, EmptyString(),
1679 0 : TypedEventHandler(aHandler),
1680 0 : !mIsMainThreadELM ||
1681 0 : !nsContentUtils::IsCallerChrome());
1682 : }
1683 :
1684 : const TypedEventHandler*
1685 0 : EventListenerManager::GetTypedEventHandler(nsIAtom* aEventName,
1686 : const nsAString& aTypeString)
1687 : {
1688 0 : EventMessage eventMessage = nsContentUtils::GetEventMessage(aEventName);
1689 0 : Listener* listener = FindEventHandler(eventMessage, aEventName, aTypeString);
1690 :
1691 0 : if (!listener) {
1692 0 : return nullptr;
1693 : }
1694 :
1695 0 : JSEventHandler* jsEventHandler = listener->GetJSEventHandler();
1696 :
1697 0 : if (listener->mHandlerIsString) {
1698 0 : CompileEventHandlerInternal(listener, nullptr, nullptr);
1699 : }
1700 :
1701 : const TypedEventHandler& typedHandler =
1702 0 : jsEventHandler->GetTypedEventHandler();
1703 0 : return typedHandler.HasEventHandler() ? &typedHandler : nullptr;
1704 : }
1705 :
1706 : size_t
1707 21 : EventListenerManager::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const
1708 : {
1709 21 : size_t n = aMallocSizeOf(this);
1710 21 : n += mListeners.ShallowSizeOfExcludingThis(aMallocSizeOf);
1711 21 : uint32_t count = mListeners.Length();
1712 126 : for (uint32_t i = 0; i < count; ++i) {
1713 : JSEventHandler* jsEventHandler =
1714 105 : mListeners.ElementAt(i).GetJSEventHandler();
1715 105 : if (jsEventHandler) {
1716 0 : n += jsEventHandler->SizeOfIncludingThis(aMallocSizeOf);
1717 : }
1718 : }
1719 21 : return n;
1720 : }
1721 :
1722 : void
1723 0 : EventListenerManager::MarkForCC()
1724 : {
1725 0 : uint32_t count = mListeners.Length();
1726 0 : for (uint32_t i = 0; i < count; ++i) {
1727 0 : const Listener& listener = mListeners.ElementAt(i);
1728 0 : JSEventHandler* jsEventHandler = listener.GetJSEventHandler();
1729 0 : if (jsEventHandler) {
1730 : const TypedEventHandler& typedHandler =
1731 0 : jsEventHandler->GetTypedEventHandler();
1732 0 : if (typedHandler.HasEventHandler()) {
1733 0 : typedHandler.Ptr()->MarkForCC();
1734 : }
1735 0 : } else if (listener.mListenerType == Listener::eWrappedJSListener) {
1736 0 : xpc_TryUnmarkWrappedGrayObject(listener.mListener.GetXPCOMCallback());
1737 0 : } else if (listener.mListenerType == Listener::eWebIDLListener) {
1738 0 : listener.mListener.GetWebIDLCallback()->MarkForCC();
1739 : }
1740 : }
1741 0 : if (mRefCnt.IsPurple()) {
1742 0 : mRefCnt.RemovePurple();
1743 : }
1744 0 : }
1745 :
1746 : void
1747 1 : EventListenerManager::TraceListeners(JSTracer* aTrc)
1748 : {
1749 1 : uint32_t count = mListeners.Length();
1750 47 : for (uint32_t i = 0; i < count; ++i) {
1751 46 : const Listener& listener = mListeners.ElementAt(i);
1752 46 : JSEventHandler* jsEventHandler = listener.GetJSEventHandler();
1753 46 : if (jsEventHandler) {
1754 : const TypedEventHandler& typedHandler =
1755 3 : jsEventHandler->GetTypedEventHandler();
1756 3 : if (typedHandler.HasEventHandler()) {
1757 3 : mozilla::TraceScriptHolder(typedHandler.Ptr(), aTrc);
1758 : }
1759 43 : } else if (listener.mListenerType == Listener::eWebIDLListener) {
1760 43 : mozilla::TraceScriptHolder(listener.mListener.GetWebIDLCallback(), aTrc);
1761 : }
1762 : // We might have eWrappedJSListener, but that is the legacy type for
1763 : // JS implemented event listeners, and trickier to handle here.
1764 : }
1765 1 : }
1766 :
1767 : bool
1768 0 : EventListenerManager::HasUntrustedOrNonSystemGroupKeyEventListeners()
1769 : {
1770 0 : uint32_t count = mListeners.Length();
1771 0 : for (uint32_t i = 0; i < count; ++i) {
1772 0 : Listener* listener = &mListeners.ElementAt(i);
1773 0 : if (!listener->mFlags.mInSystemGroup &&
1774 0 : listener->mFlags.mAllowUntrustedEvents &&
1775 0 : (listener->mTypeAtom == nsGkAtoms::onkeydown ||
1776 0 : listener->mTypeAtom == nsGkAtoms::onkeypress ||
1777 0 : listener->mTypeAtom == nsGkAtoms::onkeyup)) {
1778 0 : return true;
1779 : }
1780 : }
1781 0 : return false;
1782 : }
1783 :
1784 : bool
1785 174 : EventListenerManager::HasApzAwareListeners()
1786 : {
1787 174 : uint32_t count = mListeners.Length();
1788 3732 : for (uint32_t i = 0; i < count; ++i) {
1789 3630 : Listener* listener = &mListeners.ElementAt(i);
1790 3630 : if (IsApzAwareListener(listener)) {
1791 72 : return true;
1792 : }
1793 : }
1794 102 : return false;
1795 : }
1796 :
1797 : bool
1798 5548 : EventListenerManager::IsApzAwareListener(Listener* aListener)
1799 : {
1800 5548 : return !aListener->mFlags.mPassive && IsApzAwareEvent(aListener->mTypeAtom);
1801 : }
1802 :
1803 : bool
1804 5548 : EventListenerManager::IsApzAwareEvent(nsIAtom* aEvent)
1805 : {
1806 11021 : if (aEvent == nsGkAtoms::onwheel || aEvent == nsGkAtoms::onDOMMouseScroll ||
1807 10946 : aEvent == nsGkAtoms::onmousewheel ||
1808 5473 : aEvent == nsGkAtoms::onMozMousePixelScroll) {
1809 75 : return true;
1810 : }
1811 : // In theory we should schedule a repaint if the touch event pref changes,
1812 : // because the event regions might be out of date. In practice that seems like
1813 : // overkill because users generally shouldn't be flipping this pref, much
1814 : // less expecting touch listeners on the page to immediately start preventing
1815 : // scrolling without so much as a repaint. Tests that we write can work
1816 : // around this constraint easily enough.
1817 10941 : if (aEvent == nsGkAtoms::ontouchstart ||
1818 5468 : aEvent == nsGkAtoms::ontouchmove) {
1819 6 : return TouchEvent::PrefEnabled(
1820 6 : nsContentUtils::GetDocShellForEventTarget(mTarget));
1821 : }
1822 5467 : return false;
1823 : }
1824 :
1825 : already_AddRefed<nsIScriptGlobalObject>
1826 561 : EventListenerManager::GetScriptGlobalAndDocument(nsIDocument** aDoc)
1827 : {
1828 1122 : nsCOMPtr<nsINode> node(do_QueryInterface(mTarget));
1829 1122 : nsCOMPtr<nsIDocument> doc;
1830 1122 : nsCOMPtr<nsIScriptGlobalObject> global;
1831 561 : if (node) {
1832 : // Try to get context from doc
1833 : // XXX sXBL/XBL2 issue -- do we really want the owner here? What
1834 : // if that's the XBL document?
1835 555 : doc = node->OwnerDoc();
1836 555 : if (doc->IsLoadedAsData()) {
1837 0 : return nullptr;
1838 : }
1839 :
1840 : // We want to allow compiling an event handler even in an unloaded
1841 : // document, so use GetScopeObject here, not GetScriptHandlingObject.
1842 555 : global = do_QueryInterface(doc->GetScopeObject());
1843 : } else {
1844 12 : if (nsCOMPtr<nsPIDOMWindowInner> win = GetTargetAsInnerWindow()) {
1845 6 : doc = win->GetExtantDoc();
1846 6 : global = do_QueryInterface(win);
1847 : } else {
1848 0 : global = do_QueryInterface(mTarget);
1849 : }
1850 : }
1851 :
1852 561 : doc.forget(aDoc);
1853 561 : return global.forget();
1854 : }
1855 :
1856 : } // namespace mozilla
|
