path: root/dom/events/EventListenerManager.cpp

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

// Microsoft's API Name hackery sucks
#undef CreateEvent

#include "js/ColumnNumber.h"  // JS::ColumnNumberOneOrigin
#include "js/loader/LoadedScript.h"
#include "js/loader/ScriptFetchOptions.h"
#include "mozilla/BasicEvents.h"
#include "mozilla/BinarySearch.h"
#include "mozilla/CycleCollectedJSRuntime.h"
#include "mozilla/DOMEventTargetHelper.h"
#include "mozilla/EventDispatcher.h"
#include "mozilla/EventListenerManager.h"
#include "mozilla/HalSensor.h"
#include "mozilla/InternalMutationEvent.h"
#include "mozilla/JSEventHandler.h"
#include "mozilla/Maybe.h"
#include "mozilla/MemoryReporting.h"
#include "mozilla/Preferences.h"
#include "mozilla/PresShell.h"
#include "mozilla/dom/AbortSignal.h"
#include "mozilla/dom/BindingUtils.h"
#include "mozilla/dom/EventCallbackDebuggerNotification.h"
#include "mozilla/dom/Element.h"
#include "mozilla/dom/Event.h"
#include "mozilla/dom/EventTargetBinding.h"
#include "mozilla/dom/PopupBlocker.h"
#include "mozilla/dom/RequestBinding.h"
#include "mozilla/dom/ScriptLoader.h"
#include "mozilla/dom/ScriptSettings.h"
#include "mozilla/dom/TouchEvent.h"
#include "mozilla/dom/UserActivation.h"
#include "mozilla/ScopeExit.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/dom/ChromeUtils.h"

#include "EventListenerService.h"
#include "nsCOMPtr.h"
#include "nsContentUtils.h"
#include "nsDOMCID.h"
#include "nsError.h"
#include "nsGenericHTMLElement.h"
#include "nsGkAtoms.h"
#include "nsIContent.h"
#include "nsIContentSecurityPolicy.h"
#include "mozilla/dom/Document.h"
#include "nsIScriptGlobalObject.h"
#include "nsISupports.h"
#include "nsJSUtils.h"
#include "nsNameSpaceManager.h"
#include "nsPIDOMWindow.h"
#include "nsPrintfCString.h"
#include "nsSandboxFlags.h"
#include "xpcpublic.h"
#include "nsIFrame.h"
#include "nsDisplayList.h"
#include "nsPIWindowRoot.h"

namespace mozilla {

using namespace dom;
using namespace hal;

static uint32_t MutationBitForEventType(EventMessage aEventType) {
  switch (aEventType) {
    case eLegacySubtreeModified:
      return NS_EVENT_BITS_MUTATION_SUBTREEMODIFIED;
    case eLegacyNodeInserted:
      return NS_EVENT_BITS_MUTATION_NODEINSERTED;
    case eLegacyNodeRemoved:
      return NS_EVENT_BITS_MUTATION_NODEREMOVED;
    case eLegacyNodeRemovedFromDocument:
      return NS_EVENT_BITS_MUTATION_NODEREMOVEDFROMDOCUMENT;
    case eLegacyNodeInsertedIntoDocument:
      return NS_EVENT_BITS_MUTATION_NODEINSERTEDINTODOCUMENT;
    case eLegacyAttrModified:
      return NS_EVENT_BITS_MUTATION_ATTRMODIFIED;
    case eLegacyCharacterDataModified:
      return NS_EVENT_BITS_MUTATION_CHARACTERDATAMODIFIED;
    default:
      break;
  }
  return 0;
}

class ListenerMapEntryComparator {
 public:
  explicit ListenerMapEntryComparator(nsAtom* aTarget)
      : mAddressOfEventType(reinterpret_cast<uintptr_t>(aTarget)) {}

  int operator()(
      const EventListenerManager::EventListenerMapEntry& aEntry) const {
    uintptr_t value = reinterpret_cast<uintptr_t>(aEntry.mTypeAtom.get());
    if (mAddressOfEventType == value) {
      return 0;
    }

    if (mAddressOfEventType < value) {
      return -1;
    }

    return 1;
  }

 private:
  const uintptr_t mAddressOfEventType;  // the address of the atom, can be 0
};

uint32_t EventListenerManager::sMainThreadCreatedCount = 0;

EventListenerManagerBase::EventListenerManagerBase()
    : mMayHaveDOMActivateEventListener(false),
      mMayHavePaintEventListener(false),
      mMayHaveMutationListeners(false),
      mMayHaveCapturingListeners(false),
      mMayHaveSystemGroupListeners(false),
      mMayHaveTouchEventListener(false),
      mMayHaveMouseEnterLeaveEventListener(false),
      mMayHavePointerEnterLeaveEventListener(false),
      mMayHaveSelectionChangeEventListener(false),
      mMayHaveFormSelectEventListener(false),
      mMayHaveTransitionEventListener(false),
      mClearingListeners(false),
      mIsMainThreadELM(NS_IsMainThread()),
      mMayHaveListenersForUntrustedEvents(false) {
  ClearNoListenersForEvents();
  static_assert(sizeof(EventListenerManagerBase) == sizeof(uint64_t),
                "Keep the size of EventListenerManagerBase size compact!");
}

EventListenerManager::EventListenerManager(EventTarget* aTarget)
    : mTarget(aTarget) {
  NS_ASSERTION(aTarget, "unexpected null pointer");

  if (mIsMainThreadELM) {
    mRefCnt.SetIsOnMainThread();
    ++sMainThreadCreatedCount;
  }
}

EventListenerManager::~EventListenerManager() {
  // If your code fails this assertion, a possible reason is that
  // a class did not call our Disconnect() manually. Note that
  // this class can have Disconnect called in one of two ways:
  // if it is part of a cycle, then in Unlink() (such a cycle
  // would be with one of the listeners, not mTarget which is weak).
  // If not part of a cycle, then Disconnect must be called manually,
  // typically from the destructor of the owner class (mTarget).
  // XXX azakai: Is there any reason to not just call Disconnect
  //             from right here, if not previously called?
  NS_ASSERTION(!mTarget, "didn't call Disconnect");
  RemoveAllListenersSilently();
}

void EventListenerManager::RemoveAllListenersSilently() {
  if (mClearingListeners) {
    return;
  }
  mClearingListeners = true;
  mListenerMap.Clear();
  mClearingListeners = false;
}

inline void ImplCycleCollectionTraverse(
    nsCycleCollectionTraversalCallback& aCallback,
    EventListenerManager::EventListenerMap& aField, const char* aName,
    uint32_t aFlags = 0) {
  if (MOZ_UNLIKELY(aCallback.WantDebugInfo())) {
    nsAutoCString name;
    name.AppendASCII(aName);
    name.AppendLiteral(" mEntries[i] event=");
    size_t entryPrefixLen = name.Length();
    for (const auto& entry : aField.mEntries) {
      if (entry.mTypeAtom) {
        name.Replace(entryPrefixLen, name.Length() - entryPrefixLen,
                     nsAtomCString(entry.mTypeAtom));
      } else {
        name.Replace(entryPrefixLen, name.Length() - entryPrefixLen,
                     "(all)"_ns);
      }
      ImplCycleCollectionTraverse(aCallback, *entry.mListeners, name.get());
    }
  } else {
    for (const auto& entry : aField.mEntries) {
      ImplCycleCollectionTraverse(aCallback, *entry.mListeners,
                                  ".mEntries[i].mListeners");
    }
  }
}

inline void ImplCycleCollectionTraverse(
    nsCycleCollectionTraversalCallback& aCallback,
    EventListenerManager::Listener& aField, const char* aName,
    unsigned aFlags) {
  if (MOZ_UNLIKELY(aCallback.WantDebugInfo())) {
    nsAutoCString name;
    name.AppendASCII(aName);
    name.AppendLiteral(" listenerType=");
    name.AppendInt(aField.mListenerType);
    name.AppendLiteral(" ");
    CycleCollectionNoteChild(aCallback, aField.mListener.GetISupports(),
                             name.get(), aFlags);
  } else {
    CycleCollectionNoteChild(aCallback, aField.mListener.GetISupports(), aName,
                             aFlags);
  }

  CycleCollectionNoteChild(aCallback, aField.mSignalFollower.get(),
                           "mSignalFollower", aFlags);
}

NS_IMPL_CYCLE_COLLECTION_CLASS(EventListenerManager)

NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(EventListenerManager)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mListenerMap);
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END

NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(EventListenerManager)
  tmp->Disconnect();
NS_IMPL_CYCLE_COLLECTION_UNLINK_END

nsPIDOMWindowInner* EventListenerManager::GetInnerWindowForTarget() {
  if (nsINode* node = nsINode::FromEventTargetOrNull(mTarget)) {
    // XXX sXBL/XBL2 issue -- do we really want the owner here?  What
    // if that's the XBL document?
    return node->OwnerDoc()->GetInnerWindow();
  }

  nsCOMPtr<nsPIDOMWindowInner> window = GetTargetAsInnerWindow();
  return window;
}

already_AddRefed<nsPIDOMWindowInner>
EventListenerManager::GetTargetAsInnerWindow() const {
  nsCOMPtr<nsPIDOMWindowInner> window =
      nsPIDOMWindowInner::FromEventTargetOrNull(mTarget);
  return window.forget();
}

void EventListenerManager::AddEventListenerInternal(
    EventListenerHolder aListenerHolder, EventMessage aEventMessage,
    nsAtom* aTypeAtom, const EventListenerFlags& aFlags, bool aHandler,
    bool aAllEvents, AbortSignal* aSignal) {
  MOZ_ASSERT((aEventMessage && aTypeAtom) || aAllEvents,  // all-events listener
             "Missing type");
  MOZ_ASSERT_IF(
      aEventMessage != eUnidentifiedEvent && !aAllEvents,
      aTypeAtom == nsContentUtils::GetEventTypeFromMessage(aEventMessage));

  if (!aListenerHolder || mClearingListeners) {
    return;
  }

  if (aSignal && aSignal->Aborted()) {
    return;
  }

  // Since there is no public API to call us with an EventListenerHolder, we
  // know that there's an EventListenerHolder on the stack holding a strong ref
  // to the listener.

  RefPtr<ListenerArray> listeners =
      aAllEvents ? mListenerMap.GetOrCreateListenersForAllEvents()
                 : mListenerMap.GetOrCreateListenersForType(aTypeAtom);

  for (const Listener& listener : listeners->NonObservingRange()) {
    // mListener == aListenerHolder is the last one, since it can be a bit slow.
    if (listener.mListenerIsHandler == aHandler &&
        listener.mFlags.EqualsForAddition(aFlags) &&
        listener.mListener == aListenerHolder) {
      return;
    }
  }

  ClearNoListenersForEvents();
  mNoListenerForEventAtom = nullptr;

  Listener* listener = listeners->AppendElement();
  listener->mFlags = aFlags;
  listener->mListenerIsHandler = aHandler;
  listener->mHandlerIsString = false;
  listener->mAllEvents = aAllEvents;

  if (listener->mFlags.mAllowUntrustedEvents) {
    mMayHaveListenersForUntrustedEvents = true;
  }

  // Detect the type of event listener.
  if (aFlags.mListenerIsJSListener) {
    MOZ_ASSERT(!aListenerHolder.HasWebIDLCallback());
    listener->mListenerType = Listener::eJSEventListener;
  } else if (aListenerHolder.HasWebIDLCallback()) {
    listener->mListenerType = Listener::eWebIDLListener;
  } else {
    listener->mListenerType = Listener::eNativeListener;
  }
  listener->mListener = std::move(aListenerHolder);

  if (aSignal) {
    listener->mSignalFollower =
        new ListenerSignalFollower(this, listener, aTypeAtom);
    listener->mSignalFollower->Follow(aSignal);
  }

  if (aFlags.mInSystemGroup) {
    mMayHaveSystemGroupListeners = true;
  }
  if (aFlags.mCapture) {
    mMayHaveCapturingListeners = true;
  }

  // Events which are not supported in the running environment is mapped to
  // eUnidentifiedEvent.  Then, we need to consider the proper event message
  // with comparing the atom.
  {
    EventMessage resolvedEventMessage = aEventMessage;
    if (resolvedEventMessage == eUnidentifiedEvent && aTypeAtom->IsStatic()) {
      // TouchEvents are registered only when
      // nsContentUtils::InitializeTouchEventTable() is called.
      if (aTypeAtom == nsGkAtoms::ontouchstart) {
        resolvedEventMessage = eTouchStart;
      } else if (aTypeAtom == nsGkAtoms::ontouchend) {
        resolvedEventMessage = eTouchEnd;
      } else if (aTypeAtom == nsGkAtoms::ontouchmove) {
        resolvedEventMessage = eTouchMove;
      } else if (aTypeAtom == nsGkAtoms::ontouchcancel) {
        resolvedEventMessage = eTouchCancel;
      }
    }

    switch (resolvedEventMessage) {
      case eAfterPaint:
        mMayHavePaintEventListener = true;
        if (nsPIDOMWindowInner* window = GetInnerWindowForTarget()) {
          window->SetHasPaintEventListeners();
        }
        break;
      case eLegacyDOMActivate:
        mMayHaveDOMActivateEventListener = true;
        if (nsPIDOMWindowInner* window = GetInnerWindowForTarget()) {
          window->SetHasDOMActivateEventListeners();
        }
        break;
      case eLegacySubtreeModified:
      case eLegacyNodeInserted:
      case eLegacyNodeRemoved:
      case eLegacyNodeRemovedFromDocument:
      case eLegacyNodeInsertedIntoDocument:
      case eLegacyAttrModified:
      case eLegacyCharacterDataModified:
#ifdef DEBUG
        MOZ_ASSERT(!aFlags.mInSystemGroup,
                   "Legacy mutation events shouldn't be handled by ourselves");
        MOZ_ASSERT(listener->mListenerType != Listener::eNativeListener,
                   "Legacy mutation events shouldn't be handled in C++ code");
        if (nsINode* targetNode = nsINode::FromEventTargetOrNull(mTarget)) {
          MOZ_ASSERT(!nsContentUtils::IsChromeDoc(targetNode->OwnerDoc()),
                     "Legacy mutation events shouldn't be handled in chrome "
                     "documents");
          MOZ_ASSERT(!targetNode->IsInNativeAnonymousSubtree(),
                     "Legacy mutation events shouldn't listen to mutations in "
                     "native anonymous subtrees");
        }
#endif  // #ifdef DEBUG
        // For mutation listeners, we need to update the global bit on the DOM
        // window. Otherwise we won't actually fire the mutation event.
        mMayHaveMutationListeners = true;
        // Go from our target to the nearest enclosing DOM window.
        if (nsPIDOMWindowInner* window = GetInnerWindowForTarget()) {
          if (Document* doc = window->GetExtantDoc()) {
            doc->WarnOnceAbout(DeprecatedOperations::eMutationEvent);
          }
          // If resolvedEventMessage is eLegacySubtreeModified, we need to
          // listen all mutations. nsContentUtils::HasMutationListeners relies
          // on this.
          window->SetMutationListeners(
              (resolvedEventMessage == eLegacySubtreeModified)
                  ? NS_EVENT_BITS_MUTATION_ALL
                  : MutationBitForEventType(resolvedEventMessage));
        }
        break;
      case ePointerEnter:
      case ePointerLeave:
        mMayHavePointerEnterLeaveEventListener = true;
        if (nsPIDOMWindowInner* window = GetInnerWindowForTarget()) {
          NS_WARNING_ASSERTION(
              !nsContentUtils::IsChromeDoc(window->GetExtantDoc()),
              "Please do not use pointerenter/leave events in chrome. "
              "They are slower than pointerover/out!");
          window->SetHasPointerEnterLeaveEventListeners();
        }
        break;
      case eGamepadButtonDown:
      case eGamepadButtonUp:
      case eGamepadAxisMove:
      case eGamepadConnected:
      case eGamepadDisconnected:
        if (nsPIDOMWindowInner* window = GetInnerWindowForTarget()) {
          window->SetHasGamepadEventListener();
        }
        break;
      case eDeviceOrientation:
      case eDeviceOrientationAbsolute:
      case eUserProximity:
      case eDeviceLight:
      case eDeviceMotion:
#if defined(MOZ_WIDGET_ANDROID)
      case eOrientationChange:
#endif  // #if defined(MOZ_WIDGET_ANDROID)
        EnableDevice(aTypeAtom);
        break;
      case eTouchStart:
      case eTouchEnd:
      case eTouchMove:
      case eTouchCancel:
        mMayHaveTouchEventListener = true;
        // we don't want touchevent listeners added by scrollbars to flip this
        // flag so we ignore listeners created with system event flag
        if (!aFlags.mInSystemGroup) {
          if (nsPIDOMWindowInner* window = GetInnerWindowForTarget()) {
            window->SetHasTouchEventListeners();
          }
        }
        break;
      case eMouseEnter:
      case eMouseLeave:
        mMayHaveMouseEnterLeaveEventListener = true;
        if (nsPIDOMWindowInner* window = GetInnerWindowForTarget()) {
          NS_WARNING_ASSERTION(
              !nsContentUtils::IsChromeDoc(window->GetExtantDoc()),
              "Please do not use mouseenter/leave events in chrome. "
              "They are slower than mouseover/out!");
          window->SetHasMouseEnterLeaveEventListeners();
        }
        break;
      case eEditorBeforeInput:
        if (nsPIDOMWindowInner* window = GetInnerWindowForTarget()) {
          window->SetHasBeforeInputEventListenersForTelemetry();
        }
        break;
      case eSelectionChange:
        mMayHaveSelectionChangeEventListener = true;
        if (nsPIDOMWindowInner* window = GetInnerWindowForTarget()) {
          window->SetHasSelectionChangeEventListeners();
        }
        break;
      case eFormSelect:
        mMayHaveFormSelectEventListener = true;
        if (nsPIDOMWindowInner* window = GetInnerWindowForTarget()) {
          window->SetHasFormSelectEventListeners();
        }
        break;
      case eScrollPortOverflow:
        if (nsPIDOMWindowInner* window = GetInnerWindowForTarget()) {
          if (Document* doc = window->GetExtantDoc()) {
            doc->SetUseCounter(eUseCounter_custom_onoverflow);
          }
        }
        break;
      case eScrollPortUnderflow:
        if (nsPIDOMWindowInner* window = GetInnerWindowForTarget()) {
          if (Document* doc = window->GetExtantDoc()) {
            doc->SetUseCounter(eUseCounter_custom_onunderflow);
          }
        }
        break;
      case eLegacyMouseLineOrPageScroll:
        if (nsPIDOMWindowInner* window = GetInnerWindowForTarget()) {
          if (Document* doc = window->GetExtantDoc()) {
            doc->SetUseCounter(eUseCounter_custom_ondommousescroll);
          }
        }
        break;
      case eLegacyMousePixelScroll:
        if (nsPIDOMWindowInner* window = GetInnerWindowForTarget()) {
          if (Document* doc = window->GetExtantDoc()) {
            doc->SetUseCounter(eUseCounter_custom_onmozmousepixelscroll);
          }
        }
        break;
      case eTransitionStart:
      case eTransitionRun:
      case eTransitionEnd:
      case eTransitionCancel:
      case eWebkitTransitionEnd:
        mMayHaveTransitionEventListener = true;
        if (nsPIDOMWindowInner* window = GetInnerWindowForTarget()) {
          window->SetHasTransitionEventListeners();
        }
        break;
      case eFormCheckboxStateChange:
        nsContentUtils::SetMayHaveFormCheckboxStateChangeListeners();
        break;
      case eFormRadioStateChange:
        nsContentUtils::SetMayHaveFormRadioStateChangeListeners();
        break;
      default:
        // XXX Use NS_ASSERTION here to print resolvedEventMessage since
        //     MOZ_ASSERT can take only string literal, not pointer to
        //     characters.
        NS_ASSERTION(
            resolvedEventMessage < eLegacyMutationEventFirst ||
                resolvedEventMessage > eLegacyMutationEventLast,
            nsPrintfCString("You added new mutation event, but it's not "
                            "handled above, resolvedEventMessage=%s",
                            ToChar(resolvedEventMessage))
                .get());
        NS_ASSERTION(aTypeAtom != nsGkAtoms::onpointerenter,
                     nsPrintfCString("resolvedEventMessage=%s",
                                     ToChar(resolvedEventMessage))
                         .get());
        NS_ASSERTION(aTypeAtom != nsGkAtoms::onpointerleave,
                     nsPrintfCString("resolvedEventMessage=%s",
                                     ToChar(resolvedEventMessage))
                         .get());
        NS_ASSERTION(
            resolvedEventMessage < eGamepadEventFirst ||
                resolvedEventMessage > eGamepadEventLast,
            nsPrintfCString("You added new gamepad event, but it's not "
                            "handled above, resolvedEventMessage=%s",
                            ToChar(resolvedEventMessage))
                .get());
        NS_ASSERTION(aTypeAtom != nsGkAtoms::ondeviceorientation,
                     nsPrintfCString("resolvedEventMessage=%s",
                                     ToChar(resolvedEventMessage))
                         .get());
        NS_ASSERTION(aTypeAtom != nsGkAtoms::ondeviceorientationabsolute,
                     nsPrintfCString("resolvedEventMessage=%s",
                                     ToChar(resolvedEventMessage))
                         .get());
        NS_ASSERTION(aTypeAtom != nsGkAtoms::onuserproximity,
                     nsPrintfCString("resolvedEventMessage=%s",
                                     ToChar(resolvedEventMessage))
                         .get());
        NS_ASSERTION(aTypeAtom != nsGkAtoms::ondevicelight,
                     nsPrintfCString("resolvedEventMessage=%s",
                                     ToChar(resolvedEventMessage))
                         .get());
        NS_ASSERTION(aTypeAtom != nsGkAtoms::ondevicemotion,
                     nsPrintfCString("resolvedEventMessage=%s",
                                     ToChar(resolvedEventMessage))
                         .get());
#if defined(MOZ_WIDGET_ANDROID)
        NS_ASSERTION(aTypeAtom != nsGkAtoms::onorientationchange,
                     nsPrintfCString("resolvedEventMessage=%s",
                                     ToChar(resolvedEventMessage))
                         .get());
#endif  // #if defined(MOZ_WIDGET_ANDROID)
        NS_ASSERTION(aTypeAtom != nsGkAtoms::ontouchstart,
                     nsPrintfCString("resolvedEventMessage=%s",
                                     ToChar(resolvedEventMessage))
                         .get());
        NS_ASSERTION(aTypeAtom != nsGkAtoms::ontouchend,
                     nsPrintfCString("resolvedEventMessage=%s",
                                     ToChar(resolvedEventMessage))
                         .get());
        NS_ASSERTION(aTypeAtom != nsGkAtoms::ontouchmove,
                     nsPrintfCString("resolvedEventMessage=%s",
                                     ToChar(resolvedEventMessage))
                         .get());
        NS_ASSERTION(aTypeAtom != nsGkAtoms::ontouchcancel,
                     nsPrintfCString("resolvedEventMessage=%s",
                                     ToChar(resolvedEventMessage))
                         .get());
        NS_ASSERTION(aTypeAtom != nsGkAtoms::onmouseenter,
                     nsPrintfCString("resolvedEventMessage=%s",
                                     ToChar(resolvedEventMessage))
                         .get());
        NS_ASSERTION(aTypeAtom != nsGkAtoms::onmouseleave,
                     nsPrintfCString("resolvedEventMessage=%s",
                                     ToChar(resolvedEventMessage))
                         .get());
        NS_ASSERTION(aTypeAtom != nsGkAtoms::onbeforeinput,
                     nsPrintfCString("resolvedEventMessage=%s",
                                     ToChar(resolvedEventMessage))
                         .get());
        NS_ASSERTION(aTypeAtom != nsGkAtoms::onselectionchange,
                     nsPrintfCString("resolvedEventMessage=%s",
                                     ToChar(resolvedEventMessage))
                         .get());
        NS_ASSERTION(aTypeAtom != nsGkAtoms::onselect,
                     nsPrintfCString("resolvedEventMessage=%s",
                                     ToChar(resolvedEventMessage))
                         .get());
        NS_ASSERTION(aTypeAtom != nsGkAtoms::onoverflow,
                     nsPrintfCString("resolvedEventMessage=%s",
                                     ToChar(resolvedEventMessage))
                         .get());
        NS_ASSERTION(aTypeAtom != nsGkAtoms::onunderflow,
                     nsPrintfCString("resolvedEventMessage=%s",
                                     ToChar(resolvedEventMessage))
                         .get());
        NS_ASSERTION(aTypeAtom != nsGkAtoms::onDOMMouseScroll,
                     nsPrintfCString("resolvedEventMessage=%s",
                                     ToChar(resolvedEventMessage))
                         .get());
        NS_ASSERTION(aTypeAtom != nsGkAtoms::onMozMousePixelScroll,
                     nsPrintfCString("resolvedEventMessage=%s",
                                     ToChar(resolvedEventMessage))
                         .get());
        break;
    }
  }

  if (mIsMainThreadELM && !aFlags.mPassive && IsApzAwareEvent(aTypeAtom)) {
    ProcessApzAwareEventListenerAdd();
  }

  if (mTarget) {
    mTarget->EventListenerAdded(aTypeAtom);
  }

  if (mIsMainThreadELM && mTarget) {
    EventListenerService::NotifyAboutMainThreadListenerChange(mTarget,
                                                              aTypeAtom);
  }
}

void EventListenerManager::ProcessApzAwareEventListenerAdd() {
  Document* doc = nullptr;

  // Mark the node as having apz aware listeners
  if (nsINode* node = nsINode::FromEventTargetOrNull(mTarget)) {
    node->SetMayBeApzAware();
    doc = node->OwnerDoc();
  }

  // Schedule a paint so event regions on the layer tree gets updated
  if (!doc) {
    if (nsCOMPtr<nsPIDOMWindowInner> window = GetTargetAsInnerWindow()) {
      doc = window->GetExtantDoc();
    }
  }
  if (!doc) {
    if (nsCOMPtr<DOMEventTargetHelper> helper = do_QueryInterface(mTarget)) {
      if (nsPIDOMWindowInner* window = helper->GetOwner()) {
        doc = window->GetExtantDoc();
      }
    }
  }

  if (doc && gfxPlatform::AsyncPanZoomEnabled()) {
    PresShell* presShell = doc->GetPresShell();
    if (presShell) {
      nsIFrame* f = presShell->GetRootFrame();
      if (f) {
        f->SchedulePaint();
      }
    }
  }
}

bool EventListenerManager::IsDeviceType(nsAtom* aTypeAtom) {
  return aTypeAtom == nsGkAtoms::ondeviceorientation ||
         aTypeAtom == nsGkAtoms::ondeviceorientationabsolute ||
         aTypeAtom == nsGkAtoms::ondevicemotion ||
         aTypeAtom == nsGkAtoms::ondevicelight
#if defined(MOZ_WIDGET_ANDROID)
         || aTypeAtom == nsGkAtoms::onorientationchange
#endif
         || aTypeAtom == nsGkAtoms::onuserproximity;
}

void EventListenerManager::EnableDevice(nsAtom* aTypeAtom) {
  nsCOMPtr<nsPIDOMWindowInner> window = GetTargetAsInnerWindow();
  if (!window) {
    return;
  }

  if (aTypeAtom == nsGkAtoms::ondeviceorientation) {
#ifdef MOZ_WIDGET_ANDROID
    // Falls back to SENSOR_ROTATION_VECTOR and SENSOR_ORIENTATION if
    // unavailable on device.
    window->EnableDeviceSensor(SENSOR_GAME_ROTATION_VECTOR);
    window->EnableDeviceSensor(SENSOR_ROTATION_VECTOR);
#else
    window->EnableDeviceSensor(SENSOR_ORIENTATION);
#endif
    return;
  }

  if (aTypeAtom == nsGkAtoms::ondeviceorientationabsolute) {
#ifdef MOZ_WIDGET_ANDROID
    // Falls back to SENSOR_ORIENTATION if unavailable on device.
    window->EnableDeviceSensor(SENSOR_ROTATION_VECTOR);
#else
    window->EnableDeviceSensor(SENSOR_ORIENTATION);
#endif
    return;
  }

  if (aTypeAtom == nsGkAtoms::onuserproximity) {
    window->EnableDeviceSensor(SENSOR_PROXIMITY);
    return;
  }

  if (aTypeAtom == nsGkAtoms::ondevicelight) {
    window->EnableDeviceSensor(SENSOR_LIGHT);
    return;
  }

  if (aTypeAtom == nsGkAtoms::ondevicemotion) {
    window->EnableDeviceSensor(SENSOR_ACCELERATION);
    window->EnableDeviceSensor(SENSOR_LINEAR_ACCELERATION);
    window->EnableDeviceSensor(SENSOR_GYROSCOPE);
    return;
  }

#if defined(MOZ_WIDGET_ANDROID)
  if (aTypeAtom == nsGkAtoms::onorientationchange) {
    window->EnableOrientationChangeListener();
    return;
  }
#endif

  NS_WARNING("Enabling an unknown device sensor.");
}

void EventListenerManager::DisableDevice(nsAtom* aTypeAtom) {
  nsCOMPtr<nsPIDOMWindowInner> window = GetTargetAsInnerWindow();
  if (!window) {
    return;
  }

  if (aTypeAtom == nsGkAtoms::ondeviceorientation) {
#ifdef MOZ_WIDGET_ANDROID
    // Disable all potential fallback sensors.
    window->DisableDeviceSensor(SENSOR_GAME_ROTATION_VECTOR);
    window->DisableDeviceSensor(SENSOR_ROTATION_VECTOR);
#endif
    window->DisableDeviceSensor(SENSOR_ORIENTATION);
    return;
  }

  if (aTypeAtom == nsGkAtoms::ondeviceorientationabsolute) {
#ifdef MOZ_WIDGET_ANDROID
    window->DisableDeviceSensor(SENSOR_ROTATION_VECTOR);
#endif
    window->DisableDeviceSensor(SENSOR_ORIENTATION);
    return;
  }

  if (aTypeAtom == nsGkAtoms::ondevicemotion) {
    window->DisableDeviceSensor(SENSOR_ACCELERATION);
    window->DisableDeviceSensor(SENSOR_LINEAR_ACCELERATION);
    window->DisableDeviceSensor(SENSOR_GYROSCOPE);
    return;
  }

  if (aTypeAtom == nsGkAtoms::onuserproximity) {
    window->DisableDeviceSensor(SENSOR_PROXIMITY);
    return;
  }

  if (aTypeAtom == nsGkAtoms::ondevicelight) {
    window->DisableDeviceSensor(SENSOR_LIGHT);
    return;
  }

#if defined(MOZ_WIDGET_ANDROID)
  if (aTypeAtom == nsGkAtoms::onorientationchange) {
    window->DisableOrientationChangeListener();
    return;
  }
#endif

  NS_WARNING("Disabling an unknown device sensor.");
}

void EventListenerManager::NotifyEventListenerRemoved(nsAtom* aUserType) {
  // If the following code is changed, other callsites of EventListenerRemoved
  // and NotifyAboutMainThreadListenerChange should be changed too.
  ClearNoListenersForEvents();
  mNoListenerForEventAtom = nullptr;
  if (mTarget) {
    mTarget->EventListenerRemoved(aUserType);
  }
  if (mIsMainThreadELM && mTarget) {
    EventListenerService::NotifyAboutMainThreadListenerChange(mTarget,
                                                              aUserType);
  }
}

void EventListenerManager::RemoveEventListenerInternal(
    EventListenerHolder aListenerHolder, nsAtom* aUserType,
    const EventListenerFlags& aFlags, bool aAllEvents) {
  if (!aListenerHolder || (!aUserType && !aAllEvents) || mClearingListeners) {
    return;
  }

  Maybe<size_t> entryIndex = aAllEvents
                                 ? mListenerMap.EntryIndexForAllEvents()
                                 : mListenerMap.EntryIndexForType(aUserType);
  if (!entryIndex) {
    return;
  }

  ListenerArray& listenerArray = *mListenerMap.mEntries[*entryIndex].mListeners;

  Maybe<uint32_t> listenerIndex = [&]() -> Maybe<uint32_t> {
    uint32_t count = listenerArray.Length();
    for (uint32_t i = 0; i < count; ++i) {
      Listener* listener = &listenerArray.ElementAt(i);
      if (listener->mListener == aListenerHolder &&
          listener->mFlags.EqualsForRemoval(aFlags)) {
        return Some(i);
      }
    }
    return Nothing();
  }();

  if (!listenerIndex) {
    return;
  }

  listenerArray.RemoveElementAt(*listenerIndex);
  if (listenerArray.IsEmpty()) {
    mListenerMap.mEntries.RemoveElementAt(*entryIndex);
  }

  RefPtr<EventListenerManager> kungFuDeathGrip(this);
  if (!aAllEvents) {
    NotifyEventListenerRemoved(aUserType);
    if (IsDeviceType(aUserType)) {
      DisableDevice(aUserType);
    }
  }
}

static bool IsDefaultPassiveWhenOnRoot(EventMessage aMessage) {
  if (aMessage == eTouchStart || aMessage == eTouchMove || aMessage == eWheel ||
      aMessage == eLegacyMouseLineOrPageScroll ||
      aMessage == eLegacyMousePixelScroll) {
    return true;
  }
  return false;
}

static bool IsRootEventTarget(EventTarget* aTarget) {
  if (!aTarget) {
    return false;
  }
  if (aTarget->IsInnerWindow()) {
    return true;
  }
  const nsINode* node = nsINode::FromEventTarget(aTarget);
  if (!node) {
    return false;
  }
  Document* doc = node->OwnerDoc();
  return node == doc || node == doc->GetRootElement() || node == doc->GetBody();
}

void EventListenerManager::MaybeMarkPassive(EventMessage aMessage,
                                            EventListenerFlags& aFlags) {
  if (!mIsMainThreadELM) {
    return;
  }
  if (!IsDefaultPassiveWhenOnRoot(aMessage)) {
    return;
  }
  if (!IsRootEventTarget(mTarget)) {
    return;
  }
  aFlags.mPassive = true;
}

void EventListenerManager::AddEventListenerByType(
    EventListenerHolder aListenerHolder, const nsAString& aType,
    const EventListenerFlags& aFlags, const Optional<bool>& aPassive,
    AbortSignal* aSignal) {
  RefPtr<nsAtom> atom;
  EventMessage message =
      GetEventMessageAndAtomForListener(aType, getter_AddRefs(atom));

  EventListenerFlags flags = aFlags;
  if (aPassive.WasPassed()) {
    flags.mPassive = aPassive.Value();
  } else {
    MaybeMarkPassive(message, flags);
  }

  AddEventListenerInternal(std::move(aListenerHolder), message, atom, flags,
                           false, false, aSignal);
}

void EventListenerManager::RemoveEventListenerByType(
    EventListenerHolder aListenerHolder, const nsAString& aType,
    const EventListenerFlags& aFlags) {
  RefPtr<nsAtom> atom;
  (void)GetEventMessageAndAtomForListener(aType, getter_AddRefs(atom));
  RemoveEventListenerInternal(std::move(aListenerHolder), atom, aFlags);
}

EventListenerManager::Listener* EventListenerManager::FindEventHandler(
    nsAtom* aTypeAtom) {
  // Run through the listeners for this type and see if a script
  // listener is registered
  RefPtr<ListenerArray> listeners = mListenerMap.GetListenersForType(aTypeAtom);
  if (!listeners) {
    return nullptr;
  }

  uint32_t count = listeners->Length();
  for (uint32_t i = 0; i < count; ++i) {
    Listener* listener = &listeners->ElementAt(i);
    if (listener->mListenerIsHandler) {
      return listener;
    }
  }
  return nullptr;
}

EventListenerManager::Listener* EventListenerManager::SetEventHandlerInternal(
    nsAtom* aName, const TypedEventHandler& aTypedHandler,
    bool aPermitUntrustedEvents) {
  MOZ_ASSERT(aName);

  EventMessage eventMessage = GetEventMessage(aName);
  Listener* listener = FindEventHandler(aName);

  if (!listener) {
    // If we didn't find a script listener or no listeners existed
    // create and add a new one.
    EventListenerFlags flags;
    flags.mListenerIsJSListener = true;
    MaybeMarkPassive(eventMessage, flags);

    nsCOMPtr<JSEventHandler> jsEventHandler;
    NS_NewJSEventHandler(mTarget, aName, aTypedHandler,
                         getter_AddRefs(jsEventHandler));
    AddEventListenerInternal(EventListenerHolder(jsEventHandler), eventMessage,
                             aName, flags, true);

    listener = FindEventHandler(aName);
  } else {
    JSEventHandler* jsEventHandler = listener->GetJSEventHandler();
    MOZ_ASSERT(jsEventHandler,
               "How can we have an event handler with no JSEventHandler?");

    bool same = jsEventHandler->GetTypedEventHandler() == aTypedHandler;
    // Possibly the same listener, but update still the context and scope.
    jsEventHandler->SetHandler(aTypedHandler);
    if (mTarget && !same) {
      mTarget->EventListenerRemoved(aName);
      mTarget->EventListenerAdded(aName);
    }
    if (mIsMainThreadELM && mTarget) {
      EventListenerService::NotifyAboutMainThreadListenerChange(mTarget, aName);
    }
  }

  // Set flag to indicate possible need for compilation later
  listener->mHandlerIsString = !aTypedHandler.HasEventHandler();
  if (aPermitUntrustedEvents) {
    listener->mFlags.mAllowUntrustedEvents = true;
    mMayHaveListenersForUntrustedEvents = true;
  }

  return listener;
}

nsresult EventListenerManager::SetEventHandler(nsAtom* aName,
                                               const nsAString& aBody,
                                               bool aDeferCompilation,
                                               bool aPermitUntrustedEvents,
                                               Element* aElement) {
  auto removeEventHandler = MakeScopeExit([&] { RemoveEventHandler(aName); });

  nsCOMPtr<Document> doc;
  nsCOMPtr<nsIScriptGlobalObject> global =
      GetScriptGlobalAndDocument(getter_AddRefs(doc));

  if (!global) {
    // This can happen; for example this document might have been
    // loaded as data.
    return NS_OK;
  }

  nsresult rv = NS_OK;
  // return early preventing the event listener from being added
  // 'doc' is fetched above
  if (doc) {
    // Don't allow adding an event listener if the document is sandboxed
    // without 'allow-scripts'.
    if (doc->HasScriptsBlockedBySandbox()) {
      return NS_ERROR_DOM_SECURITY_ERR;
    }

    // Perform CSP check
    nsCOMPtr<nsIContentSecurityPolicy> csp = doc->GetCsp();
    uint32_t lineNum = 0;
    JS::ColumnNumberOneOrigin columnNum;

    JSContext* cx = nsContentUtils::GetCurrentJSContext();
    if (cx && !JS::DescribeScriptedCaller(cx, nullptr, &lineNum, &columnNum)) {
      JS_ClearPendingException(cx);
    }

    if (csp) {
      bool allowsInlineScript = true;
      rv = csp->GetAllowsInline(
          nsIContentSecurityPolicy::SCRIPT_SRC_ATTR_DIRECTIVE,
          true,    // aHasUnsafeHash
          u""_ns,  // aNonce
          true,    // aParserCreated (true because attribute event handler)
          aElement,
          nullptr,  // nsICSPEventListener
          aBody, lineNum, columnNum.oneOriginValue(), &allowsInlineScript);
      NS_ENSURE_SUCCESS(rv, rv);

      // return early if CSP wants us to block inline scripts
      if (!allowsInlineScript) {
        return NS_OK;
      }
    }
  }

  // This might be the first reference to this language in the global
  // We must init the language before we attempt to fetch its context.
  if (NS_FAILED(global->EnsureScriptEnvironment())) {
    NS_WARNING("Failed to setup script environment for this language");
    // but fall through and let the inevitable failure below handle it.
  }

  nsIScriptContext* context = global->GetScriptContext();
  NS_ENSURE_TRUE(context, NS_ERROR_FAILURE);
  NS_ENSURE_STATE(global->HasJSGlobal());

  removeEventHandler.release();

  Listener* listener = SetEventHandlerInternal(aName, TypedEventHandler(),
                                               aPermitUntrustedEvents);

  if (!aDeferCompilation) {
    return CompileEventHandlerInternal(listener, aName, &aBody, aElement);
  }

  return NS_OK;
}

void EventListenerManager::RemoveEventHandler(nsAtom* aName) {
  if (mClearingListeners) {
    return;
  }

  Maybe<size_t> entryIndex = mListenerMap.EntryIndexForType(aName);
  if (!entryIndex) {
    return;
  }

  ListenerArray& listenerArray = *mListenerMap.mEntries[*entryIndex].mListeners;

  Maybe<uint32_t> listenerIndex = [&]() -> Maybe<uint32_t> {
    uint32_t count = listenerArray.Length();
    for (uint32_t i = 0; i < count; ++i) {
      Listener* listener = &listenerArray.ElementAt(i);
      if (listener->mListenerIsHandler) {
        return Some(i);
      }
    }
    return Nothing();
  }();

  if (!listenerIndex) {
    return;
  }

  listenerArray.RemoveElementAt(*listenerIndex);
  if (listenerArray.IsEmpty()) {
    mListenerMap.mEntries.RemoveElementAt(*entryIndex);
  }

  RefPtr<EventListenerManager> kungFuDeathGrip(this);
  NotifyEventListenerRemoved(aName);
  if (IsDeviceType(aName)) {
    DisableDevice(aName);
  }
}

nsresult EventListenerManager::CompileEventHandlerInternal(
    Listener* aListener, nsAtom* aTypeAtom, const nsAString* aBody,
    Element* aElement) {
  MOZ_ASSERT(aListener->GetJSEventHandler());
  MOZ_ASSERT(aListener->mHandlerIsString,
             "Why are we compiling a non-string JS listener?");
  JSEventHandler* jsEventHandler = aListener->GetJSEventHandler();
  MOZ_ASSERT(!jsEventHandler->GetTypedEventHandler().HasEventHandler(),
             "What is there to compile?");

  nsresult result = NS_OK;
  nsCOMPtr<Document> doc;
  nsCOMPtr<nsIScriptGlobalObject> global =
      GetScriptGlobalAndDocument(getter_AddRefs(doc));
  NS_ENSURE_STATE(global);

  // Activate JSAPI, and make sure that exceptions are reported on the right
  // Window.
  AutoJSAPI jsapi;
  if (NS_WARN_IF(!jsapi.Init(global))) {
    return NS_ERROR_UNEXPECTED;
  }
  JSContext* cx = jsapi.cx();

  nsAtom* attrName = aTypeAtom;

  // Flag us as not a string so we don't keep trying to compile strings which
  // can't be compiled.
  aListener->mHandlerIsString = false;

  // mTarget may not be an Element if it's a window and we're
  // getting an inline event listener forwarded from <html:body> or
  // <html:frameset> or <xul:window> or the like.
  // XXX I don't like that we have to reference content from
  // here. The alternative is to store the event handler string on
  // the JSEventHandler itself, and that still doesn't address
  // the arg names issue.
  RefPtr<Element> element = Element::FromEventTargetOrNull(mTarget);
  MOZ_ASSERT(element || aBody, "Where will we get our body?");
  nsAutoString handlerBody;
  const nsAString* body = aBody;
  if (!aBody) {
    if (aTypeAtom == nsGkAtoms::onSVGLoad) {
      attrName = nsGkAtoms::onload;
    } else if (aTypeAtom == nsGkAtoms::onSVGScroll) {
      attrName = nsGkAtoms::onscroll;
    } else if (aTypeAtom == nsGkAtoms::onbeginEvent) {
      attrName = nsGkAtoms::onbegin;
    } else if (aTypeAtom == nsGkAtoms::onrepeatEvent) {
      attrName = nsGkAtoms::onrepeat;
    } else if (aTypeAtom == nsGkAtoms::onendEvent) {
      attrName = nsGkAtoms::onend;
    } else if (aTypeAtom == nsGkAtoms::onwebkitAnimationEnd) {
      attrName = nsGkAtoms::onwebkitanimationend;
    } else if (aTypeAtom == nsGkAtoms::onwebkitAnimationIteration) {
      attrName = nsGkAtoms::onwebkitanimationiteration;
    } else if (aTypeAtom == nsGkAtoms::onwebkitAnimationStart) {
      attrName = nsGkAtoms::onwebkitanimationstart;
    } else if (aTypeAtom == nsGkAtoms::onwebkitTransitionEnd) {
      attrName = nsGkAtoms::onwebkittransitionend;
    }

    element->GetAttr(attrName, handlerBody);
    body = &handlerBody;
    aElement = element;
  }
  aListener = nullptr;

  nsAutoCString url("-moz-evil:lying-event-listener"_ns);
  MOZ_ASSERT(body);
  MOZ_ASSERT(aElement);
  nsIURI* uri = aElement->OwnerDoc()->GetDocumentURI();
  if (uri) {
    uri->GetSpec(url);
  }

  nsCOMPtr<nsPIDOMWindowInner> win =
      nsPIDOMWindowInner::FromEventTargetOrNull(mTarget);
  uint32_t argCount;
  const char** argNames;
  nsContentUtils::GetEventArgNames(aElement->GetNameSpaceID(), aTypeAtom, win,
                                   &argCount, &argNames);

  // Wrap the event target, so that we can use it as the scope for the event
  // handler. Note that mTarget is different from aElement in the <body> case,
  // where mTarget is a Window.
  //
  // The wrapScope doesn't really matter here, because the target will create
  // its reflector in the proper scope, and then we'll enter that realm.
  JS::Rooted<JSObject*> wrapScope(cx, global->GetGlobalJSObject());
  JS::Rooted<JS::Value> v(cx);
  {
    JSAutoRealm ar(cx, wrapScope);
    nsresult rv = nsContentUtils::WrapNative(cx, mTarget, &v,
                                             /* aAllowWrapping = */ false);
    if (NS_WARN_IF(NS_FAILED(rv))) {
      return rv;
    }
  }

  JS::Rooted<JSObject*> target(cx, &v.toObject());
  JSAutoRealm ar(cx, target);

  // Now that we've entered the realm we actually care about, create our
  // scope chain.  Note that we start with |element|, not aElement, because
  // mTarget is different from aElement in the <body> case, where mTarget is a
  // Window, and in that case we do not want the scope chain to include the body
  // or the document.
  JS::RootedVector<JSObject*> scopeChain(cx);
  if (!nsJSUtils::GetScopeChainForElement(cx, element, &scopeChain)) {
    return NS_ERROR_OUT_OF_MEMORY;
  }

  nsDependentAtomString str(attrName);
  // Most of our names are short enough that we don't even have to malloc
  // the JS string stuff, so don't worry about playing games with
  // refcounting XPCOM stringbuffers.
  JS::Rooted<JSString*> jsStr(
      cx, JS_NewUCStringCopyN(cx, str.BeginReading(), str.Length()));
  NS_ENSURE_TRUE(jsStr, NS_ERROR_OUT_OF_MEMORY);

  // Get the reflector for |aElement|, so that we can pass to setElement.
  if (NS_WARN_IF(!GetOrCreateDOMReflector(cx, aElement, &v))) {
    return NS_ERROR_FAILURE;
  }

  RefPtr<JS::loader::ScriptFetchOptions> fetchOptions =
      new JS::loader::ScriptFetchOptions(
          CORS_NONE, /* aNonce = */ u""_ns, RequestPriority::Auto,
          JS::loader::ParserMetadata::NotParserInserted,
          aElement->OwnerDoc()->NodePrincipal());

  RefPtr<JS::loader::EventScript> eventScript = new JS::loader::EventScript(
      aElement->OwnerDoc()->GetReferrerPolicy(), fetchOptions, uri);

  JS::CompileOptions options(cx);
  // Use line 0 to make the function body starts from line 1.
  options.setIntroductionType("eventHandler")
      .setFileAndLine(url.get(), 0)
      .setDeferDebugMetadata(true);

  JS::Rooted<JSObject*> handler(cx);
  result = nsJSUtils::CompileFunction(jsapi, scopeChain, options,
                                      nsAtomCString(aTypeAtom), argCount,
                                      argNames, *body, handler.address());
  NS_ENSURE_SUCCESS(result, result);
  NS_ENSURE_TRUE(handler, NS_ERROR_FAILURE);

  JS::Rooted<JS::Value> privateValue(cx, JS::PrivateValue(eventScript));
  result = nsJSUtils::UpdateFunctionDebugMetadata(jsapi, handler, options,
                                                  jsStr, privateValue);
  NS_ENSURE_SUCCESS(result, result);

  MOZ_ASSERT(js::IsObjectInContextCompartment(handler, cx));
  JS::Rooted<JSObject*> handlerGlobal(cx, JS::CurrentGlobalOrNull(cx));

  if (jsEventHandler->EventName() == nsGkAtoms::onerror && win) {
    RefPtr<OnErrorEventHandlerNonNull> handlerCallback =
        new OnErrorEventHandlerNonNull(static_cast<JSContext*>(nullptr),
                                       handler, handlerGlobal,
                                       /* aIncumbentGlobal = */ nullptr);
    jsEventHandler->SetHandler(handlerCallback);
  } else if (jsEventHandler->EventName() == nsGkAtoms::onbeforeunload && win) {
    RefPtr<OnBeforeUnloadEventHandlerNonNull> handlerCallback =
        new OnBeforeUnloadEventHandlerNonNull(static_cast<JSContext*>(nullptr),
                                              handler, handlerGlobal,
                                              /* aIncumbentGlobal = */ nullptr);
    jsEventHandler->SetHandler(handlerCallback);
  } else {
    RefPtr<EventHandlerNonNull> handlerCallback = new EventHandlerNonNull(
        static_cast<JSContext*>(nullptr), handler, handlerGlobal,
        /* aIncumbentGlobal = */ nullptr);
    jsEventHandler->SetHandler(handlerCallback);
  }

  return result;
}

bool EventListenerManager::HandleEventSingleListener(
    Listener* aListener, nsAtom* aTypeAtom, WidgetEvent* aEvent,
    Event* aDOMEvent, EventTarget* aCurrentTarget, bool aItemInShadowTree) {
  if (!aEvent->mCurrentTarget) {
    aEvent->mCurrentTarget = aCurrentTarget->GetTargetForDOMEvent();
    if (!aEvent->mCurrentTarget) {
      return false;
    }
  }

  aEvent->mFlags.mInPassiveListener = aListener->mFlags.mPassive;

  nsCOMPtr<nsPIDOMWindowInner> innerWindow =
      WindowFromListener(aListener, aTypeAtom, aItemInShadowTree);
  mozilla::dom::Event* oldWindowEvent = nullptr;
  if (innerWindow) {
    oldWindowEvent = innerWindow->SetEvent(aDOMEvent);
  }

  nsresult result = NS_OK;

  // strong ref
  EventListenerHolder listenerHolder(aListener->mListener.Clone());

  // If this is a script handler and we haven't yet
  // compiled the event handler itself
  if ((aListener->mListenerType == Listener::eJSEventListener) &&
      aListener->mHandlerIsString) {
    result =
        CompileEventHandlerInternal(aListener, aTypeAtom, nullptr, nullptr);
    aListener = nullptr;
  }

  if (NS_SUCCEEDED(result)) {
    Maybe<EventCallbackDebuggerNotificationGuard> dbgGuard;
    if (dom::ChromeUtils::IsDevToolsOpened()) {
      dbgGuard.emplace(aCurrentTarget, aDOMEvent);
    }
    nsAutoMicroTask mt;

    // Event::currentTarget is set in EventDispatcher.
    if (listenerHolder.HasWebIDLCallback()) {
      ErrorResult rv;
      listenerHolder.GetWebIDLCallback()->HandleEvent(aCurrentTarget,
                                                      *aDOMEvent, rv);
      result = rv.StealNSResult();
    } else {
      // listenerHolder is holding a stack ref here.
      result = MOZ_KnownLive(listenerHolder.GetXPCOMCallback())
                   ->HandleEvent(aDOMEvent);
    }
  }

  if (innerWindow) {
    Unused << innerWindow->SetEvent(oldWindowEvent);
  }

  if (NS_FAILED(result)) {
    aEvent->mFlags.mExceptionWasRaised = true;
  }
  aEvent->mFlags.mInPassiveListener = false;
  return !aEvent->mFlags.mImmediatePropagationStopped;
}

/* static */ EventMessage EventListenerManager::GetLegacyEventMessage(
    EventMessage aEventMessage) {
  // webkit-prefixed legacy events:
  if (aEventMessage == eTransitionEnd) {
    return eWebkitTransitionEnd;
  }
  if (aEventMessage == eAnimationStart) {
    return eWebkitAnimationStart;
  }
  if (aEventMessage == eAnimationEnd) {
    return eWebkitAnimationEnd;
  }
  if (aEventMessage == eAnimationIteration) {
    return eWebkitAnimationIteration;
  }

  switch (aEventMessage) {
    case eFullscreenChange:
      return eMozFullscreenChange;
    case eFullscreenError:
      return eMozFullscreenError;
    default:
      return aEventMessage;
  }
}

EventMessage EventListenerManager::GetEventMessage(nsAtom* aEventName) const {
  if (mIsMainThreadELM) {
    return nsContentUtils::GetEventMessage(aEventName);
  }

  // The nsContentUtils event message hashtables aren't threadsafe, so just fall
  // back to eUnidentifiedEvent.
  return eUnidentifiedEvent;
}

EventMessage EventListenerManager::GetEventMessageAndAtomForListener(
    const nsAString& aType, nsAtom** aAtom) {
  if (mIsMainThreadELM) {
    return nsContentUtils::GetEventMessageAndAtomForListener(aType, aAtom);
  }

  *aAtom = NS_Atomize(u"on"_ns + aType).take();
  return eUnidentifiedEvent;
}

already_AddRefed<nsPIDOMWindowInner> EventListenerManager::WindowFromListener(
    Listener* aListener, nsAtom* aTypeAtom, bool aItemInShadowTree) {
  nsCOMPtr<nsPIDOMWindowInner> innerWindow;
  if (!aItemInShadowTree) {
    if (aListener->mListener.HasWebIDLCallback()) {
      CallbackObject* callback = aListener->mListener.GetWebIDLCallback();
      nsIGlobalObject* global = nullptr;
      if (callback) {
        global = callback->IncumbentGlobalOrNull();
      }
      if (global) {
        innerWindow = global->GetAsInnerWindow();  // Can be nullptr
      }
    } else if (mTarget) {
      // This ensures `window.event` can be set properly for
      // nsWindowRoot to handle KeyPress event.
      if (aListener && aTypeAtom == nsGkAtoms::onkeypress &&
          mTarget->IsRootWindow()) {
        nsPIWindowRoot* root = mTarget->AsWindowRoot();
        if (nsPIDOMWindowOuter* outerWindow = root->GetWindow()) {
          innerWindow = outerWindow->GetCurrentInnerWindow();
        }
      } else {
        // Can't get the global from
        // listener->mListener.GetXPCOMCallback().
        // In most cases, it would be the same as for
        // the target, so let's do that.
        if (nsIGlobalObject* global = mTarget->GetOwnerGlobal()) {
          innerWindow = global->GetAsInnerWindow();
        }
      }
    }
  }
  return innerWindow.forget();
}

Maybe<size_t> EventListenerManager::EventListenerMap::EntryIndexForType(
    nsAtom* aTypeAtom) const {
  MOZ_ASSERT(aTypeAtom);

  size_t matchIndexOrInsertionPoint = 0;
  bool foundMatch = BinarySearchIf(mEntries, 0, mEntries.Length(),
                                   ListenerMapEntryComparator(aTypeAtom),
                                   &matchIndexOrInsertionPoint);
  return foundMatch ? Some(matchIndexOrInsertionPoint) : Nothing();
}

Maybe<size_t> EventListenerManager::EventListenerMap::EntryIndexForAllEvents()
    const {
  // If we have an entry for "all events listeners", it'll be at the beginning
  // of the list and its type atom will be null.
  return !mEntries.IsEmpty() && mEntries[0].mTypeAtom == nullptr ? Some(0)
                                                                 : Nothing();
}

RefPtr<EventListenerManager::ListenerArray>
EventListenerManager::EventListenerMap::GetListenersForType(
    nsAtom* aTypeAtom) const {
  Maybe<size_t> index = EntryIndexForType(aTypeAtom);
  return index ? mEntries[*index].mListeners : nullptr;
}

RefPtr<EventListenerManager::ListenerArray>
EventListenerManager::EventListenerMap::GetListenersForAllEvents() const {
  Maybe<size_t> index = EntryIndexForAllEvents();
  return index ? mEntries[*index].mListeners : nullptr;
}

RefPtr<EventListenerManager::ListenerArray>
EventListenerManager::EventListenerMap::GetOrCreateListenersForType(
    nsAtom* aTypeAtom) {
  MOZ_ASSERT(aTypeAtom);
  size_t matchIndexOrInsertionPoint = 0;
  bool foundMatch = BinarySearchIf(mEntries, 0, mEntries.Length(),
                                   ListenerMapEntryComparator(aTypeAtom),
                                   &matchIndexOrInsertionPoint);
  if (foundMatch) {
    return mEntries[matchIndexOrInsertionPoint].mListeners;
  }
  RefPtr<ListenerArray> listeners = MakeRefPtr<ListenerArray>();
  mEntries.InsertElementAt(matchIndexOrInsertionPoint,
                           EventListenerMapEntry{aTypeAtom, listeners});

  return listeners;
}

RefPtr<EventListenerManager::ListenerArray>
EventListenerManager::EventListenerMap::GetOrCreateListenersForAllEvents() {
  RefPtr<ListenerArray> listeners = GetListenersForAllEvents();
  if (!listeners) {
    listeners = MakeRefPtr<ListenerArray>();
    mEntries.InsertElementAt(0, EventListenerMapEntry{nullptr, listeners});
  }
  return listeners;
}

void EventListenerManager::HandleEventInternal(nsPresContext* aPresContext,
                                               WidgetEvent* aEvent,
                                               Event** aDOMEvent,
                                               EventTarget* aCurrentTarget,
                                               nsEventStatus* aEventStatus,
                                               bool aItemInShadowTree) {
  MOZ_ASSERT_IF(aEvent->mMessage != eUnidentifiedEvent, mIsMainThreadELM);

  // Set the value of the internal PreventDefault flag properly based on
  // aEventStatus
  if (!aEvent->DefaultPrevented() &&
      *aEventStatus == nsEventStatus_eConsumeNoDefault) {
    // Assume that if only aEventStatus claims that the event has already been
    // consumed, the consumer is default event handler.
    aEvent->PreventDefault();
  }

  if (aEvent->mFlags.mImmediatePropagationStopped) {
    return;
  }

  Maybe<AutoHandlingUserInputStatePusher> userInputStatePusher;
  Maybe<AutoPopupStatePusher> popupStatePusher;
  if (mIsMainThreadELM) {
    userInputStatePusher.emplace(UserActivation::IsUserInteractionEvent(aEvent),
                                 aEvent);
    popupStatePusher.emplace(
        PopupBlocker::GetEventPopupControlState(aEvent, *aDOMEvent));
  }

  EventMessage eventMessage = aEvent->mMessage;
  RefPtr<nsAtom> typeAtom =
      eventMessage == eUnidentifiedEvent
          ? aEvent->mSpecifiedEventType.get()
          : nsContentUtils::GetEventTypeFromMessage(eventMessage);
  if (!typeAtom) {
    // Some messages don't have a corresponding type atom, e.g.
    // eMouseEnterIntoWidget. These events can't have a listener, so we
    // can stop here.
    return;
  }

  bool hasAnyListenerForEventType = false;

  // First, notify any "all events" listeners.
  if (RefPtr<ListenerArray> listenersForAllEvents =
          mListenerMap.GetListenersForAllEvents()) {
    HandleEventWithListenerArray(listenersForAllEvents, typeAtom, eventMessage,
                                 aPresContext, aEvent, aDOMEvent,
                                 aCurrentTarget, aItemInShadowTree);
    hasAnyListenerForEventType = true;
  }

  // Now look for listeners for typeAtom, and call them if we have any.
  bool hasAnyListenerMatchingGroup = false;
  if (RefPtr<ListenerArray> listeners =
          mListenerMap.GetListenersForType(typeAtom)) {
    hasAnyListenerMatchingGroup = HandleEventWithListenerArray(
        listeners, typeAtom, eventMessage, aPresContext, aEvent, aDOMEvent,
        aCurrentTarget, aItemInShadowTree);
    hasAnyListenerForEventType = true;
  }

  if (!hasAnyListenerMatchingGroup && aEvent->IsTrusted()) {
    // If we didn't find any matching listeners, and our event has a legacy
    // version, check the listeners for the legacy version.
    EventMessage legacyEventMessage = GetLegacyEventMessage(eventMessage);
    if (legacyEventMessage != eventMessage) {
      MOZ_ASSERT(
          GetLegacyEventMessage(legacyEventMessage) == legacyEventMessage,
          "Legacy event messages should not themselves have legacy versions");
      RefPtr<nsAtom> legacyTypeAtom =
          nsContentUtils::GetEventTypeFromMessage(legacyEventMessage);
      if (RefPtr<ListenerArray> legacyListeners =
              mListenerMap.GetListenersForType(legacyTypeAtom)) {
        HandleEventWithListenerArray(
            legacyListeners, legacyTypeAtom, legacyEventMessage, aPresContext,
            aEvent, aDOMEvent, aCurrentTarget, aItemInShadowTree);
        hasAnyListenerForEventType = true;
      }
    }
  }

  aEvent->mCurrentTarget = nullptr;

  if (mIsMainThreadELM && !hasAnyListenerForEventType) {
    if (aEvent->mMessage != eUnidentifiedEvent) {
      mNoListenerForEvents[2] = mNoListenerForEvents[1];
      mNoListenerForEvents[1] = mNoListenerForEvents[0];
      mNoListenerForEvents[0] = aEvent->mMessage;
    } else {
      mNoListenerForEventAtom = aEvent->mSpecifiedEventType;
    }
  }

  if (aEvent->DefaultPrevented()) {
    *aEventStatus = nsEventStatus_eConsumeNoDefault;
  }
}

bool EventListenerManager::HandleEventWithListenerArray(
    ListenerArray* aListeners, nsAtom* aTypeAtom, EventMessage aEventMessage,
    nsPresContext* aPresContext, WidgetEvent* aEvent, Event** aDOMEvent,
    EventTarget* aCurrentTarget, bool aItemInShadowTree) {
  auto ensureDOMEvent = [&]() {
    if (!*aDOMEvent) {
      // Lazily create the DOM event.
      // This is tiny bit slow, but happens only once per event.
      // Similar code also in EventDispatcher.
      nsCOMPtr<EventTarget> et = aEvent->mOriginalTarget;
      RefPtr<Event> event =
          EventDispatcher::CreateEvent(et, aPresContext, aEvent, u""_ns);
      event.forget(aDOMEvent);
    }
    return *aDOMEvent != nullptr;
  };

  Maybe<EventMessageAutoOverride> eventMessageAutoOverride;
  bool isOverridingEventMessage = aEvent->mMessage != aEventMessage;
  bool hasAnyListenerMatchingGroup = false;
  bool didReplaceOnceListener = false;

  for (Listener& listenerRef : aListeners->EndLimitedRange()) {
    Listener* listener = &listenerRef;
    if (listener->mListenerType == Listener::eNoListener) {
      // The listener is a placeholder value of a removed "once" listener.
      continue;
    }
    if (!listener->mEnabled) {
      // The listener has been disabled, for example by devtools.
      continue;
    }
    if (!listener->MatchesEventGroup(aEvent)) {
      continue;
    }
    hasAnyListenerMatchingGroup = true;

    // Check that the phase is same in event and event listener. Also check
    // that the event is trusted or that the listener allows untrusted events.
    if (!listener->MatchesEventPhase(aEvent) ||
        !listener->AllowsEventTrustedness(aEvent)) {
      continue;
    }

    Maybe<Listener> listenerHolder;
    if (listener->mFlags.mOnce) {
      // Move the listener to the stack before handling the event.
      // The order is important, otherwise the listener could be
      // called again inside the listener.
      listenerHolder.emplace(std::move(*listener));
      listener = listenerHolder.ptr();
      didReplaceOnceListener = true;
    }
    if (ensureDOMEvent()) {
      if (isOverridingEventMessage && !eventMessageAutoOverride) {
        // Override the domEvent's event-message (its .type) until we
        // finish traversing listeners (when eventMessageAutoOverride
        // destructs).
        eventMessageAutoOverride.emplace(*aDOMEvent, aEventMessage);
      }
      if (!HandleEventSingleListener(listener, aTypeAtom, aEvent, *aDOMEvent,
                                     aCurrentTarget, aItemInShadowTree)) {
        break;
      }
    }
  }

  if (didReplaceOnceListener) {
    // If there are any once listeners replaced with a placeholder during the
    // loop above, we need to clean up them here. Note that this could clear
    // once listeners handled in some outer level as well, but that should not
    // affect the result.
    size_t oldLength = aListeners->Length();
    aListeners->NonObservingRemoveElementsBy([](const Listener& aListener) {
      return aListener.mListenerType == Listener::eNoListener;
    });
    size_t newLength = aListeners->Length();
    if (newLength == 0) {
      // Remove the entry that has now become empty.
      mListenerMap.mEntries.RemoveElementsBy([](EventListenerMapEntry& entry) {
        return entry.mListeners->IsEmpty();
      });
    }
    if (newLength < oldLength) {
      // Call NotifyEventListenerRemoved once for every removed listener.
      size_t removedCount = oldLength - newLength;
      for (size_t i = 0; i < removedCount; i++) {
        NotifyEventListenerRemoved(aTypeAtom);
      }
      if (IsDeviceType(aTypeAtom)) {
        // Call DisableDevice once for every removed listener.
        for (size_t i = 0; i < removedCount; i++) {
          DisableDevice(aTypeAtom);
        }
      }
    }
  }

  return hasAnyListenerMatchingGroup;
}

void EventListenerManager::Disconnect() {
  mTarget = nullptr;
  RemoveAllListenersSilently();
}

void EventListenerManager::AddEventListener(const nsAString& aType,
                                            EventListenerHolder aListenerHolder,
                                            bool aUseCapture,
                                            bool aWantsUntrusted) {
  EventListenerFlags flags;
  flags.mCapture = aUseCapture;
  flags.mAllowUntrustedEvents = aWantsUntrusted;
  return AddEventListenerByType(std::move(aListenerHolder), aType, flags);
}

void EventListenerManager::AddEventListener(
    const nsAString& aType, EventListenerHolder aListenerHolder,
    const dom::AddEventListenerOptionsOrBoolean& aOptions,
    bool aWantsUntrusted) {
  EventListenerFlags flags;
  Optional<bool> passive;
  AbortSignal* signal = nullptr;
  if (aOptions.IsBoolean()) {
    flags.mCapture = aOptions.GetAsBoolean();
  } else {
    const auto& options = aOptions.GetAsAddEventListenerOptions();
    flags.mCapture = options.mCapture;
    flags.mInSystemGroup = options.mMozSystemGroup;
    flags.mOnce = options.mOnce;
    if (options.mPassive.WasPassed()) {
      passive.Construct(options.mPassive.Value());
    }

    if (options.mSignal.WasPassed()) {
      signal = &options.mSignal.Value();
    }
  }

  flags.mAllowUntrustedEvents = aWantsUntrusted;
  return AddEventListenerByType(std::move(aListenerHolder), aType, flags,
                                passive, signal);
}

void EventListenerManager::RemoveEventListener(
    const nsAString& aType, EventListenerHolder aListenerHolder,
    bool aUseCapture) {
  EventListenerFlags flags;
  flags.mCapture = aUseCapture;
  RemoveEventListenerByType(std::move(aListenerHolder), aType, flags);
}

void EventListenerManager::RemoveEventListener(
    const nsAString& aType, EventListenerHolder aListenerHolder,
    const dom::EventListenerOptionsOrBoolean& aOptions) {
  EventListenerFlags flags;
  if (aOptions.IsBoolean()) {
    flags.mCapture = aOptions.GetAsBoolean();
  } else {
    const auto& options = aOptions.GetAsEventListenerOptions();
    flags.mCapture = options.mCapture;
    flags.mInSystemGroup = options.mMozSystemGroup;
  }
  RemoveEventListenerByType(std::move(aListenerHolder), aType, flags);
}

void EventListenerManager::AddListenerForAllEvents(EventListener* aDOMListener,
                                                   bool aUseCapture,
                                                   bool aWantsUntrusted,
                                                   bool aSystemEventGroup) {
  EventListenerFlags flags;
  flags.mCapture = aUseCapture;
  flags.mAllowUntrustedEvents = aWantsUntrusted;
  flags.mInSystemGroup = aSystemEventGroup;
  AddEventListenerInternal(EventListenerHolder(aDOMListener), eAllEvents,
                           nullptr, flags, false, true);
}

void EventListenerManager::RemoveListenerForAllEvents(
    EventListener* aDOMListener, bool aUseCapture, bool aSystemEventGroup) {
  EventListenerFlags flags;
  flags.mCapture = aUseCapture;
  flags.mInSystemGroup = aSystemEventGroup;
  RemoveEventListenerInternal(EventListenerHolder(aDOMListener), nullptr, flags,
                              true);
}

bool EventListenerManager::HasMutationListeners() {
  if (mMayHaveMutationListeners) {
    for (const auto& entry : mListenerMap.mEntries) {
      EventMessage message = GetEventMessage(entry.mTypeAtom);
      if (message >= eLegacyMutationEventFirst &&
          message <= eLegacyMutationEventLast) {
        return true;
      }
    }
  }

  return false;
}

uint32_t EventListenerManager::MutationListenerBits() {
  uint32_t bits = 0;
  if (mMayHaveMutationListeners) {
    for (const auto& entry : mListenerMap.mEntries) {
      EventMessage message = GetEventMessage(entry.mTypeAtom);
      if (message >= eLegacyMutationEventFirst &&
          message <= eLegacyMutationEventLast) {
        if (message == eLegacySubtreeModified) {
          return NS_EVENT_BITS_MUTATION_ALL;
        }
        bits |= MutationBitForEventType(message);
      }
    }
  }
  return bits;
}

bool EventListenerManager::HasListenersFor(const nsAString& aEventName) const {
  RefPtr<nsAtom> atom = NS_Atomize(u"on"_ns + aEventName);
  return HasListenersFor(atom);
}

bool EventListenerManager::HasListenersFor(nsAtom* aEventNameWithOn) const {
  return HasListenersForInternal(aEventNameWithOn, false);
}

bool EventListenerManager::HasNonSystemGroupListenersFor(
    nsAtom* aEventNameWithOn) const {
  return HasListenersForInternal(aEventNameWithOn, true);
}

bool EventListenerManager::HasListenersForInternal(
    nsAtom* aEventNameWithOn, bool aIgnoreSystemGroup) const {
#ifdef DEBUG
  nsAutoString name;
  aEventNameWithOn->ToString(name);
#endif
  NS_ASSERTION(StringBeginsWith(name, u"on"_ns),
               "Event name does not start with 'on'");
  RefPtr<ListenerArray> listeners =
      mListenerMap.GetListenersForType(aEventNameWithOn);
  if (!listeners) {
    return false;
  }

  MOZ_ASSERT(!listeners->IsEmpty());

  if (!aIgnoreSystemGroup) {
    return true;
  }

  // Check if any non-system-group listeners exist in `listeners`.
  for (const auto& listener : listeners->NonObservingRange()) {
    if (!listener.mFlags.mInSystemGroup) {
      return true;
    }
  }

  return false;
}

bool EventListenerManager::HasListeners() const {
  return !mListenerMap.IsEmpty();
}

nsresult EventListenerManager::GetListenerInfo(
    nsTArray<RefPtr<nsIEventListenerInfo>>& aList) {
  nsCOMPtr<EventTarget> target = mTarget;
  NS_ENSURE_STATE(target);
  aList.Clear();
  for (const auto& entry : mListenerMap.mEntries) {
    for (const Listener& listener : entry.mListeners->ForwardRange()) {
      // If this is a script handler and we haven't yet
      // compiled the event handler itself go ahead and compile it
      if (listener.mListenerType == Listener::eJSEventListener &&
          listener.mHandlerIsString) {
        CompileEventHandlerInternal(const_cast<Listener*>(&listener),
                                    entry.mTypeAtom, nullptr, nullptr);
      }
      nsAutoString eventType;
      if (listener.mAllEvents) {
        eventType.SetIsVoid(true);
      } else if (listener.mListenerType == Listener::eNoListener) {
        continue;
      } else {
        eventType.Assign(Substring(nsDependentAtomString(entry.mTypeAtom), 2));
      }

      JS::Rooted<JSObject*> callback(RootingCx());
      JS::Rooted<JSObject*> callbackGlobal(RootingCx());
      if (JSEventHandler* handler = listener.GetJSEventHandler()) {
        if (handler->GetTypedEventHandler().HasEventHandler()) {
          CallbackFunction* callbackFun = handler->GetTypedEventHandler().Ptr();
          callback = callbackFun->CallableOrNull();
          callbackGlobal = callbackFun->CallbackGlobalOrNull();
          if (!callback) {
            // This will be null for cross-compartment event listeners
            // which have been destroyed.
            continue;
          }
        }
      } else if (listener.mListenerType == Listener::eWebIDLListener) {
        EventListener* listenerCallback =
            listener.mListener.GetWebIDLCallback();
        callback = listenerCallback->CallbackOrNull();
        callbackGlobal = listenerCallback->CallbackGlobalOrNull();
        if (!callback) {
          // This will be null for cross-compartment event listeners
          // which have been destroyed.
          continue;
        }
      }

      RefPtr<EventListenerInfo> info = new EventListenerInfo(
          this, eventType, callback, callbackGlobal, listener.mFlags.mCapture,
          listener.mFlags.mAllowUntrustedEvents, listener.mFlags.mInSystemGroup,
          listener.mListenerIsHandler);
      aList.AppendElement(info.forget());
    }
  }
  return NS_OK;
}

EventListenerManager::Listener* EventListenerManager::GetListenerFor(
    nsAString& aType, JSObject* aListener, bool aCapturing,
    bool aAllowsUntrusted, bool aInSystemEventGroup, bool aIsHandler) {
  NS_ENSURE_TRUE(aListener, nullptr);

  RefPtr<ListenerArray> listeners = ([&]() -> RefPtr<ListenerArray> {
    if (aType.IsVoid()) {
      return mListenerMap.GetListenersForAllEvents();
    }

    for (auto& mapEntry : mListenerMap.mEntries) {
      if (RefPtr<nsAtom> typeAtom = mapEntry.mTypeAtom) {
        if (Substring(nsDependentAtomString(typeAtom), 2).Equals(aType)) {
          return mapEntry.mListeners;
        }
      }
    }

    return nullptr;
  })();

  if (!listeners) {
    return nullptr;
  }

  for (Listener& listener : listeners->ForwardRange()) {
    if (listener.mListenerType == Listener::eNoListener) {
      continue;
    }

    if (listener.mFlags.mCapture != aCapturing ||
        listener.mFlags.mAllowUntrustedEvents != aAllowsUntrusted ||
        listener.mFlags.mInSystemGroup != aInSystemEventGroup) {
      continue;
    }

    if (aIsHandler) {
      if (JSEventHandler* handler = listener.GetJSEventHandler()) {
        if (handler->GetTypedEventHandler().HasEventHandler()) {
          if (handler->GetTypedEventHandler().Ptr()->CallableOrNull() ==
              aListener) {
            return &listener;
          }
        }
      }
    } else if (listener.mListenerType == Listener::eWebIDLListener &&
               listener.mListener.GetWebIDLCallback()->CallbackOrNull() ==
                   aListener) {
      return &listener;
    }
  }
  return nullptr;
}

nsresult EventListenerManager::IsListenerEnabled(
    nsAString& aType, JSObject* aListener, bool aCapturing,
    bool aAllowsUntrusted, bool aInSystemEventGroup, bool aIsHandler,
    bool* aEnabled) {
  Listener* listener =
      GetListenerFor(aType, aListener, aCapturing, aAllowsUntrusted,
                     aInSystemEventGroup, aIsHandler);
  NS_ENSURE_TRUE(listener, NS_ERROR_NOT_AVAILABLE);
  *aEnabled = listener->mEnabled;
  return NS_OK;
}

nsresult EventListenerManager::SetListenerEnabled(
    nsAString& aType, JSObject* aListener, bool aCapturing,
    bool aAllowsUntrusted, bool aInSystemEventGroup, bool aIsHandler,
    bool aEnabled) {
  Listener* listener =
      GetListenerFor(aType, aListener, aCapturing, aAllowsUntrusted,
                     aInSystemEventGroup, aIsHandler);
  NS_ENSURE_TRUE(listener, NS_ERROR_NOT_AVAILABLE);
  listener->mEnabled = aEnabled;
  if (aEnabled) {
    // We may have enabled some listener, clear the cache for which events
    // we don't have listeners.
    ClearNoListenersForEvents();
    mNoListenerForEventAtom = nullptr;
  }
  return NS_OK;
}

bool EventListenerManager::HasUnloadListeners() {
  return mListenerMap.GetListenersForType(nsGkAtoms::onunload) != nullptr;
}

bool EventListenerManager::HasBeforeUnloadListeners() {
  return mListenerMap.GetListenersForType(nsGkAtoms::onbeforeunload) != nullptr;
}

void EventListenerManager::SetEventHandler(nsAtom* aEventName,
                                           EventHandlerNonNull* aHandler) {
  if (!aHandler) {
    RemoveEventHandler(aEventName);
    return;
  }

  // Untrusted events are always permitted for non-chrome script
  // handlers.
  SetEventHandlerInternal(
      aEventName, TypedEventHandler(aHandler),
      !mIsMainThreadELM || !nsContentUtils::IsCallerChrome());
}

void EventListenerManager::SetEventHandler(
    OnErrorEventHandlerNonNull* aHandler) {
  if (!aHandler) {
    RemoveEventHandler(nsGkAtoms::onerror);
    return;
  }

  // Untrusted events are always permitted on workers and for non-chrome script
  // on the main thread.
  bool allowUntrusted = !mIsMainThreadELM || !nsContentUtils::IsCallerChrome();

  SetEventHandlerInternal(nsGkAtoms::onerror, TypedEventHandler(aHandler),
                          allowUntrusted);
}

void EventListenerManager::SetEventHandler(
    OnBeforeUnloadEventHandlerNonNull* aHandler) {
  if (!aHandler) {
    RemoveEventHandler(nsGkAtoms::onbeforeunload);
    return;
  }

  // Untrusted events are always permitted for non-chrome script
  // handlers.
  SetEventHandlerInternal(
      nsGkAtoms::onbeforeunload, TypedEventHandler(aHandler),
      !mIsMainThreadELM || !nsContentUtils::IsCallerChrome());
}

const TypedEventHandler* EventListenerManager::GetTypedEventHandler(
    nsAtom* aEventName) {
  Listener* listener = FindEventHandler(aEventName);

  if (!listener) {
    return nullptr;
  }

  JSEventHandler* jsEventHandler = listener->GetJSEventHandler();

  if (listener->mHandlerIsString) {
    CompileEventHandlerInternal(listener, aEventName, nullptr, nullptr);
  }

  const TypedEventHandler& typedHandler =
      jsEventHandler->GetTypedEventHandler();
  return typedHandler.HasEventHandler() ? &typedHandler : nullptr;
}

size_t EventListenerManager::SizeOfIncludingThis(
    MallocSizeOf aMallocSizeOf) const {
  return aMallocSizeOf(this) + mListenerMap.SizeOfExcludingThis(aMallocSizeOf);
}

size_t EventListenerManager::EventListenerMap::SizeOfExcludingThis(
    MallocSizeOf aMallocSizeOf) const {
  size_t n = mEntries.ShallowSizeOfExcludingThis(aMallocSizeOf);
  for (const auto& entry : mEntries) {
    n += entry.SizeOfExcludingThis(aMallocSizeOf);
  }
  return n;
}

size_t EventListenerManager::EventListenerMapEntry::SizeOfExcludingThis(
    MallocSizeOf aMallocSizeOf) const {
  return mListeners->SizeOfIncludingThis(aMallocSizeOf);
}

size_t EventListenerManager::ListenerArray::SizeOfIncludingThis(
    MallocSizeOf aMallocSizeOf) const {
  size_t n = aMallocSizeOf(this);
  n += ShallowSizeOfExcludingThis(aMallocSizeOf);
  for (const auto& listener : NonObservingRange()) {
    JSEventHandler* jsEventHandler = listener.GetJSEventHandler();
    if (jsEventHandler) {
      n += jsEventHandler->SizeOfIncludingThis(aMallocSizeOf);
    }
  }
  return n;
}

uint32_t EventListenerManager::ListenerCount() const {
  uint32_t count = 0;
  for (const auto& entry : mListenerMap.mEntries) {
    count += entry.mListeners->Length();
  }
  return count;
}

void EventListenerManager::MarkForCC() {
  for (const auto& entry : mListenerMap.mEntries) {
    for (const auto& listener : entry.mListeners->NonObservingRange()) {
      JSEventHandler* jsEventHandler = listener.GetJSEventHandler();
      if (jsEventHandler) {
        const TypedEventHandler& typedHandler =
            jsEventHandler->GetTypedEventHandler();
        if (typedHandler.HasEventHandler()) {
          typedHandler.Ptr()->MarkForCC();
        }
      } else if (listener.mListenerType == Listener::eWebIDLListener) {
        listener.mListener.GetWebIDLCallback()->MarkForCC();
      }
    }
  }
  if (mRefCnt.IsPurple()) {
    mRefCnt.RemovePurple();
  }
}

void EventListenerManager::TraceListeners(JSTracer* aTrc) {
  for (const auto& entry : mListenerMap.mEntries) {
    for (const auto& listener : entry.mListeners->NonObservingRange()) {
      JSEventHandler* jsEventHandler = listener.GetJSEventHandler();
      if (jsEventHandler) {
        const TypedEventHandler& typedHandler =
            jsEventHandler->GetTypedEventHandler();
        if (typedHandler.HasEventHandler()) {
          mozilla::TraceScriptHolder(typedHandler.Ptr(), aTrc);
        }
      } else if (listener.mListenerType == Listener::eWebIDLListener) {
        mozilla::TraceScriptHolder(listener.mListener.GetWebIDLCallback(),
                                   aTrc);
      }
      // We might have eWrappedJSListener, but that is the legacy type for
      // JS implemented event listeners, and trickier to handle here.
    }
  }
}

bool EventListenerManager::HasNonSystemGroupListenersForUntrustedKeyEvents() {
  for (const auto& entry : mListenerMap.mEntries) {
    if (entry.mTypeAtom != nsGkAtoms::onkeydown &&
        entry.mTypeAtom != nsGkAtoms::onkeypress &&
        entry.mTypeAtom != nsGkAtoms::onkeyup) {
      continue;
    }
    for (const auto& listener : entry.mListeners->NonObservingRange()) {
      if (!listener.mFlags.mInSystemGroup &&
          listener.mFlags.mAllowUntrustedEvents) {
        return true;
      }
    }
  }
  return false;
}

bool EventListenerManager::
    HasNonPassiveNonSystemGroupListenersForUntrustedKeyEvents() {
  for (const auto& entry : mListenerMap.mEntries) {
    if (entry.mTypeAtom != nsGkAtoms::onkeydown &&
        entry.mTypeAtom != nsGkAtoms::onkeypress &&
        entry.mTypeAtom != nsGkAtoms::onkeyup) {
      continue;
    }
    for (const auto& listener : entry.mListeners->NonObservingRange()) {
      if (!listener.mFlags.mPassive && !listener.mFlags.mInSystemGroup &&
          listener.mFlags.mAllowUntrustedEvents) {
        return true;
      }
    }
  }
  return false;
}

bool EventListenerManager::HasApzAwareListeners() {
  if (!mIsMainThreadELM) {
    return false;
  }

  for (const auto& entry : mListenerMap.mEntries) {
    if (!IsApzAwareEvent(entry.mTypeAtom)) {
      continue;
    }
    for (const auto& listener : entry.mListeners->NonObservingRange()) {
      if (!listener.mFlags.mPassive) {
        return true;
      }
    }
  }
  return false;
}

static bool IsWheelEventType(nsAtom* aEvent) {
  if (aEvent == nsGkAtoms::onwheel || aEvent == nsGkAtoms::onDOMMouseScroll ||
      aEvent == nsGkAtoms::onmousewheel ||
      aEvent == nsGkAtoms::onMozMousePixelScroll) {
    return true;
  }
  return false;
}

bool EventListenerManager::IsApzAwareEvent(nsAtom* aEvent) {
  if (IsWheelEventType(aEvent)) {
    return true;
  }
  // In theory we should schedule a repaint if the touch event pref changes,
  // because the event regions might be out of date. In practice that seems like
  // overkill because users generally shouldn't be flipping this pref, much
  // less expecting touch listeners on the page to immediately start preventing
  // scrolling without so much as a repaint. Tests that we write can work
  // around this constraint easily enough.
  if (aEvent == nsGkAtoms::ontouchstart || aEvent == nsGkAtoms::ontouchmove) {
    return TouchEvent::PrefEnabled(
        nsContentUtils::GetDocShellForEventTarget(mTarget));
  }
  return false;
}

bool EventListenerManager::HasNonPassiveWheelListener() {
  MOZ_ASSERT(NS_IsMainThread());
  for (const auto& entry : mListenerMap.mEntries) {
    if (!IsWheelEventType(entry.mTypeAtom)) {
      continue;
    }
    for (const auto& listener : entry.mListeners->NonObservingRange()) {
      if (!listener.mFlags.mPassive) {
        return true;
      }
    }
  }
  return false;
}

void EventListenerManager::RemoveAllListeners() {
  while (!mListenerMap.IsEmpty()) {
    size_t entryIndex = mListenerMap.mEntries.Length() - 1;
    EventListenerMapEntry& entry = mListenerMap.mEntries[entryIndex];
    RefPtr<nsAtom> type = entry.mTypeAtom;
    MOZ_ASSERT(!entry.mListeners->IsEmpty());
    size_t idx = entry.mListeners->Length() - 1;
    entry.mListeners->RemoveElementAt(idx);
    if (entry.mListeners->IsEmpty()) {
      mListenerMap.mEntries.RemoveElementAt(entryIndex);
    }
    NotifyEventListenerRemoved(type);
    if (IsDeviceType(type)) {
      DisableDevice(type);
    }
  }
}

already_AddRefed<nsIScriptGlobalObject>
EventListenerManager::GetScriptGlobalAndDocument(Document** aDoc) {
  nsCOMPtr<Document> doc;
  nsCOMPtr<nsPIDOMWindowInner> win;
  if (nsINode* node = nsINode::FromEventTargetOrNull(mTarget)) {
    // Try to get context from doc
    doc = node->OwnerDoc();
    if (doc->IsLoadedAsData()) {
      return nullptr;
    }

    win = do_QueryInterface(doc->GetScopeObject());
  } else if ((win = GetTargetAsInnerWindow())) {
    doc = win->GetExtantDoc();
  }

  if (!win || !win->IsCurrentInnerWindow()) {
    return nullptr;
  }

  doc.forget(aDoc);
  nsCOMPtr<nsIScriptGlobalObject> global = do_QueryInterface(win);
  return global.forget();
}

EventListenerManager::ListenerSignalFollower::ListenerSignalFollower(
    EventListenerManager* aListenerManager,
    EventListenerManager::Listener* aListener, nsAtom* aTypeAtom)
    : dom::AbortFollower(),
      mListenerManager(aListenerManager),
      mListener(aListener->mListener.Clone()),
      mTypeAtom(aTypeAtom),
      mAllEvents(aListener->mAllEvents),
      mFlags(aListener->mFlags){};

NS_IMPL_CYCLE_COLLECTION_CLASS(EventListenerManager::ListenerSignalFollower)

NS_IMPL_CYCLE_COLLECTING_ADDREF(EventListenerManager::ListenerSignalFollower)
NS_IMPL_CYCLE_COLLECTING_RELEASE(EventListenerManager::ListenerSignalFollower)

NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(
    EventListenerManager::ListenerSignalFollower)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mListener)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END

NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(
    EventListenerManager::ListenerSignalFollower)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mListener)
  tmp->mListenerManager = nullptr;
NS_IMPL_CYCLE_COLLECTION_UNLINK_END

NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(
    EventListenerManager::ListenerSignalFollower)
  NS_INTERFACE_MAP_ENTRY(nsISupports)
NS_INTERFACE_MAP_END

void EventListenerManager::ListenerSignalFollower::RunAbortAlgorithm() {
  if (mListenerManager) {
    RefPtr<EventListenerManager> elm = mListenerManager;
    mListenerManager = nullptr;
    elm->RemoveEventListenerInternal(std::move(mListener), mTypeAtom, mFlags,
                                     mAllEvents);
  }
}

}  // namespace mozilla