Adding upstream version 86.0.1.upstream/86.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1466 insertions, 0 deletions

diff --git a/dom/events/EventDispatcher.cpp b/dom/events/EventDispatcher.cpp
new file mode 100644
index 0000000000..f3e877ee81
--- /dev/null
+++ b/dom/events/EventDispatcher.cpp
@@ -0,0 +1,1466 @@
+/* -*- 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/. */
+
+#include "nsPresContext.h"
+#include "nsContentUtils.h"
+#include "nsDocShell.h"
+#include "nsError.h"
+#include <new>
+#include "nsIContent.h"
+#include "nsIContentInlines.h"
+#include "mozilla/dom/Document.h"
+#include "nsINode.h"
+#include "nsIScriptObjectPrincipal.h"
+#include "nsPIDOMWindow.h"
+#include "nsRefreshDriver.h"
+#include "AnimationEvent.h"
+#include "BeforeUnloadEvent.h"
+#include "ClipboardEvent.h"
+#include "CommandEvent.h"
+#include "CompositionEvent.h"
+#include "DeviceMotionEvent.h"
+#include "DragEvent.h"
+#include "GeckoProfiler.h"
+#include "KeyboardEvent.h"
+#include "Layers.h"
+#include "mozilla/BasePrincipal.h"
+#include "mozilla/ContentEvents.h"
+#include "mozilla/dom/CloseEvent.h"
+#include "mozilla/dom/CustomEvent.h"
+#include "mozilla/dom/DeviceOrientationEvent.h"
+#include "mozilla/dom/EventTarget.h"
+#include "mozilla/dom/FocusEvent.h"
+#include "mozilla/dom/HashChangeEvent.h"
+#include "mozilla/dom/InputEvent.h"
+#include "mozilla/dom/MessageEvent.h"
+#include "mozilla/dom/MouseScrollEvent.h"
+#include "mozilla/dom/MutationEvent.h"
+#include "mozilla/dom/NotifyPaintEvent.h"
+#include "mozilla/dom/PageTransitionEvent.h"
+#include "mozilla/dom/PointerEvent.h"
+#include "mozilla/dom/RootedDictionary.h"
+#include "mozilla/dom/ScrollAreaEvent.h"
+#include "mozilla/dom/SimpleGestureEvent.h"
+#include "mozilla/dom/ScriptSettings.h"
+#include "mozilla/dom/StorageEvent.h"
+#include "mozilla/dom/TimeEvent.h"
+#include "mozilla/dom/TouchEvent.h"
+#include "mozilla/dom/TransitionEvent.h"
+#include "mozilla/dom/WheelEvent.h"
+#include "mozilla/dom/WorkerPrivate.h"
+#include "mozilla/dom/XULCommandEvent.h"
+#include "mozilla/EventDispatcher.h"
+#include "mozilla/EventListenerManager.h"
+#include "mozilla/InternalMutationEvent.h"
+#include "mozilla/ipc/MessageChannel.h"
+#include "mozilla/MiscEvents.h"
+#include "mozilla/MouseEvents.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/TextEvents.h"
+#include "mozilla/TouchEvents.h"
+#include "mozilla/Unused.h"
+
+#ifdef MOZ_TASK_TRACER
+#  include "GeckoTaskTracer.h"
+#  include "mozilla/dom/Element.h"
+#  include "mozilla/Likely.h"
+using namespace mozilla::tasktracer;
+#endif
+
+namespace mozilla {
+
+using namespace dom;
+
+class ELMCreationDetector {
+ public:
+  ELMCreationDetector()
+      // We can do this optimization only in the main thread.
+      : mNonMainThread(!NS_IsMainThread()),
+        mInitialCount(mNonMainThread
+                          ? 0
+                          : EventListenerManager::sMainThreadCreatedCount) {}
+
+  bool MayHaveNewListenerManager() {
+    return mNonMainThread ||
+           mInitialCount != EventListenerManager::sMainThreadCreatedCount;
+  }
+
+  bool IsMainThread() { return !mNonMainThread; }
+
+ private:
+  bool mNonMainThread;
+  uint32_t mInitialCount;
+};
+
+static bool IsEventTargetChrome(EventTarget* aEventTarget,
+                                Document** aDocument = nullptr) {
+  if (aDocument) {
+    *aDocument = nullptr;
+  }
+
+  Document* doc = nullptr;
+  if (nsCOMPtr<nsINode> node = do_QueryInterface(aEventTarget)) {
+    doc = node->OwnerDoc();
+  } else if (nsCOMPtr<nsPIDOMWindowInner> window =
+                 do_QueryInterface(aEventTarget)) {
+    doc = window->GetExtantDoc();
+  }
+
+  // nsContentUtils::IsChromeDoc is null-safe.
+  bool isChrome = false;
+  if (doc) {
+    isChrome = nsContentUtils::IsChromeDoc(doc);
+    if (aDocument) {
+      nsCOMPtr<Document> retVal = doc;
+      retVal.swap(*aDocument);
+    }
+  } else if (nsCOMPtr<nsIScriptObjectPrincipal> sop =
+                 do_QueryInterface(aEventTarget->GetOwnerGlobal())) {
+    isChrome = sop->GetPrincipal()->IsSystemPrincipal();
+  }
+  return isChrome;
+}
+
+// EventTargetChainItem represents a single item in the event target chain.
+class EventTargetChainItem {
+ public:
+  explicit EventTargetChainItem(EventTarget* aTarget)
+      : mTarget(aTarget), mItemFlags(0) {
+    MOZ_COUNT_CTOR(EventTargetChainItem);
+  }
+
+  MOZ_COUNTED_DTOR(EventTargetChainItem)
+
+  static EventTargetChainItem* Create(nsTArray<EventTargetChainItem>& aChain,
+                                      EventTarget* aTarget,
+                                      EventTargetChainItem* aChild = nullptr) {
+    // The last item which can handle the event must be aChild.
+    MOZ_ASSERT(GetLastCanHandleEventTarget(aChain) == aChild);
+    MOZ_ASSERT(!aTarget || aTarget == aTarget->GetTargetForEventTargetChain());
+    EventTargetChainItem* etci = aChain.AppendElement(aTarget);
+    return etci;
+  }
+
+  static void DestroyLast(nsTArray<EventTargetChainItem>& aChain,
+                          EventTargetChainItem* aItem) {
+    MOZ_ASSERT(&aChain.LastElement() == aItem);
+    aChain.RemoveLastElement();
+  }
+
+  static EventTargetChainItem* GetFirstCanHandleEventTarget(
+      nsTArray<EventTargetChainItem>& aChain) {
+    return &aChain[GetFirstCanHandleEventTargetIdx(aChain)];
+  }
+
+  static uint32_t GetFirstCanHandleEventTargetIdx(
+      nsTArray<EventTargetChainItem>& aChain) {
+    // aChain[i].PreHandleEventOnly() = true only when the target element wants
+    // PreHandleEvent and set mCanHandle=false. So we find the first element
+    // which can handle the event.
+    for (uint32_t i = 0; i < aChain.Length(); ++i) {
+      if (!aChain[i].PreHandleEventOnly()) {
+        return i;
+      }
+    }
+    MOZ_ASSERT(false);
+    return 0;
+  }
+
+  static EventTargetChainItem* GetLastCanHandleEventTarget(
+      nsTArray<EventTargetChainItem>& aChain) {
+    // Fine the last item which can handle the event.
+    for (int32_t i = aChain.Length() - 1; i >= 0; --i) {
+      if (!aChain[i].PreHandleEventOnly()) {
+        return &aChain[i];
+      }
+    }
+    return nullptr;
+  }
+
+  bool IsValid() const {
+    NS_WARNING_ASSERTION(!!(mTarget), "Event target is not valid!");
+    return !!(mTarget);
+  }
+
+  EventTarget* GetNewTarget() const { return mNewTarget; }
+
+  void SetNewTarget(EventTarget* aNewTarget) { mNewTarget = aNewTarget; }
+
+  EventTarget* GetRetargetedRelatedTarget() { return mRetargetedRelatedTarget; }
+
+  void SetRetargetedRelatedTarget(EventTarget* aTarget) {
+    mRetargetedRelatedTarget = aTarget;
+  }
+
+  void SetRetargetedTouchTarget(
+      Maybe<nsTArray<RefPtr<EventTarget>>>&& aTargets) {
+    mRetargetedTouchTargets = std::move(aTargets);
+  }
+
+  bool HasRetargetTouchTargets() const {
+    return mRetargetedTouchTargets.isSome() || mInitialTargetTouches.isSome();
+  }
+
+  void RetargetTouchTargets(WidgetTouchEvent* aTouchEvent, Event* aDOMEvent) {
+    MOZ_ASSERT(HasRetargetTouchTargets());
+    MOZ_ASSERT(aTouchEvent,
+               "mRetargetedTouchTargets should be empty when dispatching "
+               "non-touch events.");
+
+    if (mRetargetedTouchTargets.isSome()) {
+      WidgetTouchEvent::TouchArray& touches = aTouchEvent->mTouches;
+      MOZ_ASSERT(!touches.Length() ||
+                 touches.Length() == mRetargetedTouchTargets->Length());
+      for (uint32_t i = 0; i < touches.Length(); ++i) {
+        touches[i]->mTarget = mRetargetedTouchTargets->ElementAt(i);
+      }
+    }
+
+    if (aDOMEvent) {
+      // The number of touch objects in targetTouches list may change depending
+      // on the retargeting.
+      TouchEvent* touchDOMEvent = static_cast<TouchEvent*>(aDOMEvent);
+      TouchList* targetTouches = touchDOMEvent->GetExistingTargetTouches();
+      if (targetTouches) {
+        targetTouches->Clear();
+        if (mInitialTargetTouches.isSome()) {
+          for (uint32_t i = 0; i < mInitialTargetTouches->Length(); ++i) {
+            Touch* touch = mInitialTargetTouches->ElementAt(i);
+            if (touch) {
+              touch->mTarget = touch->mOriginalTarget;
+            }
+            targetTouches->Append(touch);
+          }
+        }
+      }
+    }
+  }
+
+  void SetInitialTargetTouches(
+      Maybe<nsTArray<RefPtr<dom::Touch>>>&& aInitialTargetTouches) {
+    mInitialTargetTouches = std::move(aInitialTargetTouches);
+  }
+
+  void SetForceContentDispatch(bool aForce) {
+    mFlags.mForceContentDispatch = aForce;
+  }
+
+  bool ForceContentDispatch() const { return mFlags.mForceContentDispatch; }
+
+  void SetWantsWillHandleEvent(bool aWants) {
+    mFlags.mWantsWillHandleEvent = aWants;
+  }
+
+  bool WantsWillHandleEvent() const { return mFlags.mWantsWillHandleEvent; }
+
+  void SetWantsPreHandleEvent(bool aWants) {
+    mFlags.mWantsPreHandleEvent = aWants;
+  }
+
+  bool WantsPreHandleEvent() const { return mFlags.mWantsPreHandleEvent; }
+
+  void SetPreHandleEventOnly(bool aWants) {
+    mFlags.mPreHandleEventOnly = aWants;
+  }
+
+  bool PreHandleEventOnly() const { return mFlags.mPreHandleEventOnly; }
+
+  void SetRootOfClosedTree(bool aSet) { mFlags.mRootOfClosedTree = aSet; }
+
+  bool IsRootOfClosedTree() const { return mFlags.mRootOfClosedTree; }
+
+  void SetItemInShadowTree(bool aSet) { mFlags.mItemInShadowTree = aSet; }
+
+  bool IsItemInShadowTree() const { return mFlags.mItemInShadowTree; }
+
+  void SetIsSlotInClosedTree(bool aSet) { mFlags.mIsSlotInClosedTree = aSet; }
+
+  bool IsSlotInClosedTree() const { return mFlags.mIsSlotInClosedTree; }
+
+  void SetIsChromeHandler(bool aSet) { mFlags.mIsChromeHandler = aSet; }
+
+  bool IsChromeHandler() const { return mFlags.mIsChromeHandler; }
+
+  void SetMayHaveListenerManager(bool aMayHave) {
+    mFlags.mMayHaveManager = aMayHave;
+  }
+
+  bool MayHaveListenerManager() { return mFlags.mMayHaveManager; }
+
+  EventTarget* CurrentTarget() const { return mTarget; }
+
+  /**
+   * Dispatches event through the event target chain.
+   * Handles capture, target and bubble phases both in default
+   * and system event group and calls also PostHandleEvent for each
+   * item in the chain.
+   */
+  MOZ_CAN_RUN_SCRIPT
+  static void HandleEventTargetChain(nsTArray<EventTargetChainItem>& aChain,
+                                     EventChainPostVisitor& aVisitor,
+                                     EventDispatchingCallback* aCallback,
+                                     ELMCreationDetector& aCd);
+
+  /**
+   * Resets aVisitor object and calls GetEventTargetParent.
+   * Copies mItemFlags and mItemData to the current EventTargetChainItem.
+   */
+  void GetEventTargetParent(EventChainPreVisitor& aVisitor);
+
+  /**
+   * Calls PreHandleEvent for those items which called SetWantsPreHandleEvent.
+   */
+  void PreHandleEvent(EventChainVisitor& aVisitor);
+
+  /**
+   * If the current item in the event target chain has an event listener
+   * manager, this method calls EventListenerManager::HandleEvent().
+   */
+  void HandleEvent(EventChainPostVisitor& aVisitor, ELMCreationDetector& aCd) {
+    if (WantsWillHandleEvent()) {
+      mTarget->WillHandleEvent(aVisitor);
+    }
+    if (aVisitor.mEvent->PropagationStopped()) {
+      return;
+    }
+    if (aVisitor.mEvent->mFlags.mOnlySystemGroupDispatch &&
+        !aVisitor.mEvent->mFlags.mInSystemGroup) {
+      return;
+    }
+    if (aVisitor.mEvent->mFlags.mOnlySystemGroupDispatchInContent &&
+        !aVisitor.mEvent->mFlags.mInSystemGroup && !IsCurrentTargetChrome()) {
+      return;
+    }
+    if (!mManager) {
+      if (!MayHaveListenerManager() && !aCd.MayHaveNewListenerManager()) {
+        return;
+      }
+      mManager = mTarget->GetExistingListenerManager();
+    }
+    if (mManager) {
+      NS_ASSERTION(aVisitor.mEvent->mCurrentTarget == nullptr,
+                   "CurrentTarget should be null!");
+
+      if (aVisitor.mEvent->mMessage == eMouseClick) {
+        aVisitor.mEvent->mFlags.mHadNonPrivilegedClickListeners =
+            aVisitor.mEvent->mFlags.mHadNonPrivilegedClickListeners ||
+            mManager->HasNonPrivilegedClickListeners();
+      }
+      mManager->HandleEvent(aVisitor.mPresContext, aVisitor.mEvent,
+                            &aVisitor.mDOMEvent, CurrentTarget(),
+                            &aVisitor.mEventStatus, IsItemInShadowTree());
+      NS_ASSERTION(aVisitor.mEvent->mCurrentTarget == nullptr,
+                   "CurrentTarget should be null!");
+    }
+  }
+
+  /**
+   * Copies mItemFlags and mItemData to aVisitor and calls PostHandleEvent.
+   */
+  MOZ_CAN_RUN_SCRIPT void PostHandleEvent(EventChainPostVisitor& aVisitor);
+
+ private:
+  const nsCOMPtr<EventTarget> mTarget;
+  nsCOMPtr<EventTarget> mRetargetedRelatedTarget;
+  Maybe<nsTArray<RefPtr<EventTarget>>> mRetargetedTouchTargets;
+  Maybe<nsTArray<RefPtr<dom::Touch>>> mInitialTargetTouches;
+
+  class EventTargetChainFlags {
+   public:
+    explicit EventTargetChainFlags() { SetRawFlags(0); }
+    // Cached flags for each EventTargetChainItem which are set when calling
+    // GetEventTargetParent to create event target chain. They are used to
+    // manage or speedup event dispatching.
+    bool mForceContentDispatch : 1;
+    bool mWantsWillHandleEvent : 1;
+    bool mMayHaveManager : 1;
+    bool mChechedIfChrome : 1;
+    bool mIsChromeContent : 1;
+    bool mWantsPreHandleEvent : 1;
+    bool mPreHandleEventOnly : 1;
+    bool mRootOfClosedTree : 1;
+    bool mItemInShadowTree : 1;
+    bool mIsSlotInClosedTree : 1;
+    bool mIsChromeHandler : 1;
+
+   private:
+    typedef uint32_t RawFlags;
+    void SetRawFlags(RawFlags aRawFlags) {
+      static_assert(
+          sizeof(EventTargetChainFlags) <= sizeof(RawFlags),
+          "EventTargetChainFlags must not be bigger than the RawFlags");
+      memcpy(this, &aRawFlags, sizeof(EventTargetChainFlags));
+    }
+  } mFlags;
+
+  uint16_t mItemFlags;
+  nsCOMPtr<nsISupports> mItemData;
+  // Event retargeting must happen whenever mNewTarget is non-null.
+  nsCOMPtr<EventTarget> mNewTarget;
+  // Cache mTarget's event listener manager.
+  RefPtr<EventListenerManager> mManager;
+
+  bool IsCurrentTargetChrome() {
+    if (!mFlags.mChechedIfChrome) {
+      mFlags.mChechedIfChrome = true;
+      if (IsEventTargetChrome(mTarget)) {
+        mFlags.mIsChromeContent = true;
+      }
+    }
+    return mFlags.mIsChromeContent;
+  }
+};
+
+void EventTargetChainItem::GetEventTargetParent(
+    EventChainPreVisitor& aVisitor) {
+  aVisitor.Reset();
+  mTarget->GetEventTargetParent(aVisitor);
+  SetForceContentDispatch(aVisitor.mForceContentDispatch);
+  SetWantsWillHandleEvent(aVisitor.mWantsWillHandleEvent);
+  SetMayHaveListenerManager(aVisitor.mMayHaveListenerManager);
+  SetWantsPreHandleEvent(aVisitor.mWantsPreHandleEvent);
+  SetPreHandleEventOnly(aVisitor.mWantsPreHandleEvent && !aVisitor.mCanHandle);
+  SetRootOfClosedTree(aVisitor.mRootOfClosedTree);
+  SetItemInShadowTree(aVisitor.mItemInShadowTree);
+  SetRetargetedRelatedTarget(aVisitor.mRetargetedRelatedTarget);
+  SetRetargetedTouchTarget(std::move(aVisitor.mRetargetedTouchTargets));
+  mItemFlags = aVisitor.mItemFlags;
+  mItemData = aVisitor.mItemData;
+}
+
+void EventTargetChainItem::PreHandleEvent(EventChainVisitor& aVisitor) {
+  if (!WantsPreHandleEvent()) {
+    return;
+  }
+  aVisitor.mItemFlags = mItemFlags;
+  aVisitor.mItemData = mItemData;
+  Unused << mTarget->PreHandleEvent(aVisitor);
+}
+
+void EventTargetChainItem::PostHandleEvent(EventChainPostVisitor& aVisitor) {
+  aVisitor.mItemFlags = mItemFlags;
+  aVisitor.mItemData = mItemData;
+  mTarget->PostHandleEvent(aVisitor);
+}
+
+void EventTargetChainItem::HandleEventTargetChain(
+    nsTArray<EventTargetChainItem>& aChain, EventChainPostVisitor& aVisitor,
+    EventDispatchingCallback* aCallback, ELMCreationDetector& aCd) {
+  // Save the target so that it can be restored later.
+  nsCOMPtr<EventTarget> firstTarget = aVisitor.mEvent->mTarget;
+  nsCOMPtr<EventTarget> firstRelatedTarget = aVisitor.mEvent->mRelatedTarget;
+  Maybe<AutoTArray<nsCOMPtr<EventTarget>, 10>> firstTouchTargets;
+  WidgetTouchEvent* touchEvent = nullptr;
+  if (aVisitor.mEvent->mClass == eTouchEventClass) {
+    touchEvent = aVisitor.mEvent->AsTouchEvent();
+    if (!aVisitor.mEvent->mFlags.mInSystemGroup) {
+      firstTouchTargets.emplace();
+      WidgetTouchEvent* touchEvent = aVisitor.mEvent->AsTouchEvent();
+      WidgetTouchEvent::TouchArray& touches = touchEvent->mTouches;
+      for (uint32_t i = 0; i < touches.Length(); ++i) {
+        firstTouchTargets->AppendElement(touches[i]->mTarget);
+      }
+    }
+  }
+
+  uint32_t chainLength = aChain.Length();
+  uint32_t firstCanHandleEventTargetIdx =
+      EventTargetChainItem::GetFirstCanHandleEventTargetIdx(aChain);
+
+  // Capture
+  aVisitor.mEvent->mFlags.mInCapturePhase = true;
+  aVisitor.mEvent->mFlags.mInBubblingPhase = false;
+  for (uint32_t i = chainLength - 1; i > firstCanHandleEventTargetIdx; --i) {
+    EventTargetChainItem& item = aChain[i];
+    if (item.PreHandleEventOnly()) {
+      continue;
+    }
+    if ((!aVisitor.mEvent->mFlags.mNoContentDispatch ||
+         item.ForceContentDispatch()) &&
+        !aVisitor.mEvent->PropagationStopped()) {
+      item.HandleEvent(aVisitor, aCd);
+    }
+
+    if (item.GetNewTarget()) {
+      // item is at anonymous boundary. Need to retarget for the child items.
+      for (uint32_t j = i; j > 0; --j) {
+        uint32_t childIndex = j - 1;
+        EventTarget* newTarget = aChain[childIndex].GetNewTarget();
+        if (newTarget) {
+          aVisitor.mEvent->mTarget = newTarget;
+          break;
+        }
+      }
+    }
+
+    // https://dom.spec.whatwg.org/#dispatching-events
+    // Step 14.2
+    // "Set event's relatedTarget to tuple's relatedTarget."
+    // Note, the initial retargeting was done already when creating
+    // event target chain, so we need to do this only after calling
+    // HandleEvent, not before, like in the specification.
+    if (item.GetRetargetedRelatedTarget()) {
+      bool found = false;
+      for (uint32_t j = i; j > 0; --j) {
+        uint32_t childIndex = j - 1;
+        EventTarget* relatedTarget =
+            aChain[childIndex].GetRetargetedRelatedTarget();
+        if (relatedTarget) {
+          found = true;
+          aVisitor.mEvent->mRelatedTarget = relatedTarget;
+          break;
+        }
+      }
+      if (!found) {
+        aVisitor.mEvent->mRelatedTarget =
+            aVisitor.mEvent->mOriginalRelatedTarget;
+      }
+    }
+
+    if (item.HasRetargetTouchTargets()) {
+      bool found = false;
+      for (uint32_t j = i; j > 0; --j) {
+        uint32_t childIndex = j - 1;
+        if (aChain[childIndex].HasRetargetTouchTargets()) {
+          found = true;
+          aChain[childIndex].RetargetTouchTargets(touchEvent,
+                                                  aVisitor.mDOMEvent);
+          break;
+        }
+      }
+      if (!found) {
+        WidgetTouchEvent::TouchArray& touches = touchEvent->mTouches;
+        for (uint32_t i = 0; i < touches.Length(); ++i) {
+          touches[i]->mTarget = touches[i]->mOriginalTarget;
+        }
+      }
+    }
+  }
+
+  // Target
+  aVisitor.mEvent->mFlags.mInBubblingPhase = true;
+  EventTargetChainItem& targetItem = aChain[firstCanHandleEventTargetIdx];
+  // Need to explicitly retarget touch targets so that initial targets get set
+  // properly in case nothing else retargeted touches.
+  if (targetItem.HasRetargetTouchTargets()) {
+    targetItem.RetargetTouchTargets(touchEvent, aVisitor.mDOMEvent);
+  }
+  if (!aVisitor.mEvent->PropagationStopped() &&
+      (!aVisitor.mEvent->mFlags.mNoContentDispatch ||
+       targetItem.ForceContentDispatch())) {
+    targetItem.HandleEvent(aVisitor, aCd);
+  }
+  if (aVisitor.mEvent->mFlags.mInSystemGroup) {
+    targetItem.PostHandleEvent(aVisitor);
+  }
+
+  // Bubble
+  aVisitor.mEvent->mFlags.mInCapturePhase = false;
+  for (uint32_t i = firstCanHandleEventTargetIdx + 1; i < chainLength; ++i) {
+    EventTargetChainItem& item = aChain[i];
+    if (item.PreHandleEventOnly()) {
+      continue;
+    }
+    EventTarget* newTarget = item.GetNewTarget();
+    if (newTarget) {
+      // Item is at anonymous boundary. Need to retarget for the current item
+      // and for parent items.
+      aVisitor.mEvent->mTarget = newTarget;
+    }
+
+    // https://dom.spec.whatwg.org/#dispatching-events
+    // Step 15.2
+    // "Set event's relatedTarget to tuple's relatedTarget."
+    EventTarget* relatedTarget = item.GetRetargetedRelatedTarget();
+    if (relatedTarget) {
+      aVisitor.mEvent->mRelatedTarget = relatedTarget;
+    }
+
+    if (item.HasRetargetTouchTargets()) {
+      item.RetargetTouchTargets(touchEvent, aVisitor.mDOMEvent);
+    }
+
+    if (aVisitor.mEvent->mFlags.mBubbles || newTarget) {
+      if ((!aVisitor.mEvent->mFlags.mNoContentDispatch ||
+           item.ForceContentDispatch()) &&
+          !aVisitor.mEvent->PropagationStopped()) {
+        item.HandleEvent(aVisitor, aCd);
+      }
+      if (aVisitor.mEvent->mFlags.mInSystemGroup) {
+        item.PostHandleEvent(aVisitor);
+      }
+    }
+  }
+  aVisitor.mEvent->mFlags.mInBubblingPhase = false;
+
+  if (!aVisitor.mEvent->mFlags.mInSystemGroup &&
+      aVisitor.mEvent->IsAllowedToDispatchInSystemGroup()) {
+    // Dispatch to the system event group.  Make sure to clear the
+    // STOP_DISPATCH flag since this resets for each event group.
+    aVisitor.mEvent->mFlags.mPropagationStopped = false;
+    aVisitor.mEvent->mFlags.mImmediatePropagationStopped = false;
+
+    // Setting back the original target of the event.
+    aVisitor.mEvent->mTarget = aVisitor.mEvent->mOriginalTarget;
+    aVisitor.mEvent->mRelatedTarget = aVisitor.mEvent->mOriginalRelatedTarget;
+    if (firstTouchTargets) {
+      WidgetTouchEvent::TouchArray& touches = touchEvent->mTouches;
+      for (uint32_t i = 0; i < touches.Length(); ++i) {
+        touches[i]->mTarget = touches[i]->mOriginalTarget;
+      }
+    }
+
+    // Special handling if PresShell (or some other caller)
+    // used a callback object.
+    if (aCallback) {
+      aCallback->HandleEvent(aVisitor);
+    }
+
+    // Retarget for system event group (which does the default handling too).
+    // Setting back the target which was used also for default event group.
+    aVisitor.mEvent->mTarget = firstTarget;
+    aVisitor.mEvent->mRelatedTarget = firstRelatedTarget;
+    if (firstTouchTargets) {
+      WidgetTouchEvent::TouchArray& touches = touchEvent->mTouches;
+      for (uint32_t i = 0; i < firstTouchTargets->Length(); ++i) {
+        touches[i]->mTarget = firstTouchTargets->ElementAt(i);
+      }
+    }
+
+    aVisitor.mEvent->mFlags.mInSystemGroup = true;
+    HandleEventTargetChain(aChain, aVisitor, aCallback, aCd);
+    aVisitor.mEvent->mFlags.mInSystemGroup = false;
+
+    // After dispatch, clear all the propagation flags so that
+    // system group listeners don't affect to the event.
+    aVisitor.mEvent->mFlags.mPropagationStopped = false;
+    aVisitor.mEvent->mFlags.mImmediatePropagationStopped = false;
+  }
+}
+
+static nsTArray<EventTargetChainItem>* sCachedMainThreadChain = nullptr;
+
+/* static */
+void EventDispatcher::Shutdown() {
+  delete sCachedMainThreadChain;
+  sCachedMainThreadChain = nullptr;
+}
+
+EventTargetChainItem* EventTargetChainItemForChromeTarget(
+    nsTArray<EventTargetChainItem>& aChain, nsINode* aNode,
+    EventTargetChainItem* aChild = nullptr) {
+  if (!aNode->IsInComposedDoc()) {
+    return nullptr;
+  }
+  nsPIDOMWindowInner* win = aNode->OwnerDoc()->GetInnerWindow();
+  EventTarget* piTarget = win ? win->GetParentTarget() : nullptr;
+  NS_ENSURE_TRUE(piTarget, nullptr);
+
+  EventTargetChainItem* etci = EventTargetChainItem::Create(
+      aChain, piTarget->GetTargetForEventTargetChain(), aChild);
+  if (!etci->IsValid()) {
+    EventTargetChainItem::DestroyLast(aChain, etci);
+    return nullptr;
+  }
+  return etci;
+}
+
+/* static */ EventTargetChainItem* MayRetargetToChromeIfCanNotHandleEvent(
+    nsTArray<EventTargetChainItem>& aChain, EventChainPreVisitor& aPreVisitor,
+    EventTargetChainItem* aTargetEtci, EventTargetChainItem* aChildEtci,
+    nsINode* aContent) {
+  if (!aPreVisitor.mWantsPreHandleEvent) {
+    // Keep EventTargetChainItem if we need to call PreHandleEvent on it.
+    EventTargetChainItem::DestroyLast(aChain, aTargetEtci);
+  }
+  if (aPreVisitor.mAutomaticChromeDispatch && aContent) {
+    aPreVisitor.mRelatedTargetRetargetedInCurrentScope = false;
+    // Event target couldn't handle the event. Try to propagate to chrome.
+    EventTargetChainItem* chromeTargetEtci =
+        EventTargetChainItemForChromeTarget(aChain, aContent, aChildEtci);
+    if (chromeTargetEtci) {
+      // If we propagate to chrome, need to ensure we mark
+      // EventTargetChainItem to be chrome handler so that event.composedPath()
+      // can return the right value.
+      chromeTargetEtci->SetIsChromeHandler(true);
+      chromeTargetEtci->GetEventTargetParent(aPreVisitor);
+      return chromeTargetEtci;
+    }
+  }
+  return nullptr;
+}
+
+static bool ShouldClearTargets(WidgetEvent* aEvent) {
+  nsCOMPtr<nsIContent> finalTarget;
+  nsCOMPtr<nsIContent> finalRelatedTarget;
+  if ((finalTarget = do_QueryInterface(aEvent->mTarget)) &&
+      finalTarget->SubtreeRoot()->IsShadowRoot()) {
+    return true;
+  }
+
+  if ((finalRelatedTarget = do_QueryInterface(aEvent->mRelatedTarget)) &&
+      finalRelatedTarget->SubtreeRoot()->IsShadowRoot()) {
+    return true;
+  }
+  // XXXsmaug Check also all the touch objects.
+
+  return false;
+}
+
+/* static */
+nsresult EventDispatcher::Dispatch(nsISupports* aTarget,
+                                   nsPresContext* aPresContext,
+                                   WidgetEvent* aEvent, Event* aDOMEvent,
+                                   nsEventStatus* aEventStatus,
+                                   EventDispatchingCallback* aCallback,
+                                   nsTArray<EventTarget*>* aTargets) {
+  AUTO_PROFILER_LABEL("EventDispatcher::Dispatch", OTHER);
+
+  NS_ASSERTION(aEvent, "Trying to dispatch without WidgetEvent!");
+  NS_ENSURE_TRUE(!aEvent->mFlags.mIsBeingDispatched,
+                 NS_ERROR_DOM_INVALID_STATE_ERR);
+  NS_ASSERTION(!aTargets || !aEvent->mMessage, "Wrong parameters!");
+
+  // If we're dispatching an already created DOMEvent object, make
+  // sure it is initialized!
+  // If aTargets is non-null, the event isn't going to be dispatched.
+  NS_ENSURE_TRUE(aEvent->mMessage || !aDOMEvent || aTargets,
+                 NS_ERROR_DOM_INVALID_STATE_ERR);
+
+  // Events shall not be fired while we are in stable state to prevent anything
+  // visible from the scripts.
+  MOZ_ASSERT(!nsContentUtils::IsInStableOrMetaStableState());
+  NS_ENSURE_TRUE(!nsContentUtils::IsInStableOrMetaStableState(),
+                 NS_ERROR_DOM_INVALID_STATE_ERR);
+
+#ifdef MOZ_TASK_TRACER
+  if (MOZ_UNLIKELY(mozilla::tasktracer::IsStartLogging())) {
+    nsAutoCString eventType;
+    nsAutoString eventTypeU16;
+    if (aDOMEvent) {
+      aDOMEvent->GetType(eventTypeU16);
+    } else {
+      Event::GetWidgetEventType(aEvent, eventTypeU16);
+    }
+    CopyUTF16toUTF8(eventTypeU16, eventType);
+
+    nsCOMPtr<Element> element = do_QueryInterface(aTarget);
+    nsAutoString elementId;
+    nsAutoString elementTagName;
+    if (element) {
+      element->GetId(elementId);
+      element->GetTagName(elementTagName);
+    }
+    AddLabel("Event [%s] dispatched at target [id:%s tag:%s]", eventType.get(),
+             NS_ConvertUTF16toUTF8(elementId).get(),
+             NS_ConvertUTF16toUTF8(elementTagName).get());
+  }
+#endif
+
+  nsCOMPtr<EventTarget> target = do_QueryInterface(aTarget);
+
+  bool retargeted = false;
+
+  if (aEvent->mFlags.mRetargetToNonNativeAnonymous) {
+    nsCOMPtr<nsIContent> content = do_QueryInterface(target);
+    if (content && content->IsInNativeAnonymousSubtree()) {
+      nsCOMPtr<EventTarget> newTarget =
+          content->FindFirstNonChromeOnlyAccessContent();
+      NS_ENSURE_STATE(newTarget);
+
+      aEvent->mOriginalTarget = target;
+      target = newTarget;
+      retargeted = true;
+    }
+  }
+
+  if (aEvent->mFlags.mOnlyChromeDispatch) {
+    nsCOMPtr<Document> doc;
+    if (!IsEventTargetChrome(target, getter_AddRefs(doc)) && doc) {
+      nsPIDOMWindowInner* win = doc->GetInnerWindow();
+      // If we can't dispatch the event to chrome, do nothing.
+      EventTarget* piTarget = win ? win->GetParentTarget() : nullptr;
+      if (!piTarget) {
+        return NS_OK;
+      }
+
+      // Set the target to be the original dispatch target,
+      aEvent->mTarget = target;
+      // but use chrome event handler or BrowserChildMessageManager for event
+      // target chain.
+      target = piTarget;
+    } else if (NS_WARN_IF(!doc)) {
+      return NS_ERROR_UNEXPECTED;
+    }
+  }
+
+#ifdef DEBUG
+  if (NS_IsMainThread() && aEvent->mMessage != eVoidEvent &&
+      !nsContentUtils::IsSafeToRunScript()) {
+    static const auto warn = [](bool aIsSystem) {
+      if (aIsSystem) {
+        NS_WARNING("Fix the caller!");
+      } else {
+        MOZ_CRASH("This is unsafe! Fix the caller!");
+      }
+    };
+    if (nsCOMPtr<nsINode> node = do_QueryInterface(target)) {
+      // If this is a node, it's possible that this is some sort of DOM tree
+      // that is never accessed by script (for example an SVG image or XBL
+      // binding document or whatnot).  We really only want to warn/assert here
+      // if there might be actual scripted listeners for this event, so restrict
+      // the warnings/asserts to the case when script can or once could touch
+      // this node's document.
+      Document* doc = node->OwnerDoc();
+      bool hasHadScriptHandlingObject;
+      nsIGlobalObject* global =
+          doc->GetScriptHandlingObject(hasHadScriptHandlingObject);
+      if (global || hasHadScriptHandlingObject) {
+        warn(nsContentUtils::IsChromeDoc(doc));
+      }
+    } else if (nsCOMPtr<nsIGlobalObject> global = target->GetOwnerGlobal()) {
+      warn(global->PrincipalOrNull()->IsSystemPrincipal());
+    }
+  }
+
+  if (aDOMEvent) {
+    WidgetEvent* innerEvent = aDOMEvent->WidgetEventPtr();
+    NS_ASSERTION(innerEvent == aEvent,
+                 "The inner event of aDOMEvent is not the same as aEvent!");
+  }
+#endif
+
+  nsresult rv = NS_OK;
+  bool externalDOMEvent = !!(aDOMEvent);
+
+  // If we have a PresContext, make sure it doesn't die before
+  // event dispatching is finished.
+  RefPtr<nsPresContext> kungFuDeathGrip(aPresContext);
+
+  ELMCreationDetector cd;
+  nsTArray<EventTargetChainItem> chain;
+  if (cd.IsMainThread()) {
+    if (!sCachedMainThreadChain) {
+      sCachedMainThreadChain = new nsTArray<EventTargetChainItem>();
+    }
+    chain = std::move(*sCachedMainThreadChain);
+    chain.SetCapacity(128);
+  }
+
+  // Create the event target chain item for the event target.
+  EventTargetChainItem* targetEtci = EventTargetChainItem::Create(
+      chain, target->GetTargetForEventTargetChain());
+  MOZ_ASSERT(&chain[0] == targetEtci);
+  if (!targetEtci->IsValid()) {
+    EventTargetChainItem::DestroyLast(chain, targetEtci);
+    return NS_ERROR_FAILURE;
+  }
+
+  // Make sure that Event::target and Event::originalTarget
+  // point to the last item in the chain.
+  if (!aEvent->mTarget) {
+    // Note, CurrentTarget() points always to the object returned by
+    // GetTargetForEventTargetChain().
+    aEvent->mTarget = targetEtci->CurrentTarget();
+  } else {
+    // XXX But if the target is already set, use that. This is a hack
+    //     for the 'load', 'beforeunload' and 'unload' events,
+    //     which are dispatched to |window| but have document as their target.
+    //
+    // Make sure that the event target points to the right object.
+    aEvent->mTarget = aEvent->mTarget->GetTargetForEventTargetChain();
+    NS_ENSURE_STATE(aEvent->mTarget);
+  }
+
+  if (retargeted) {
+    aEvent->mOriginalTarget =
+        aEvent->mOriginalTarget->GetTargetForEventTargetChain();
+    NS_ENSURE_STATE(aEvent->mOriginalTarget);
+  } else {
+    aEvent->mOriginalTarget = aEvent->mTarget;
+  }
+
+  aEvent->mOriginalRelatedTarget = aEvent->mRelatedTarget;
+
+  bool clearTargets = false;
+
+  nsCOMPtr<nsIContent> content = do_QueryInterface(aEvent->mOriginalTarget);
+  bool isInAnon = content && content->IsInNativeAnonymousSubtree();
+
+  aEvent->mFlags.mIsBeingDispatched = true;
+
+  // Create visitor object and start event dispatching.
+  // GetEventTargetParent for the original target.
+  nsEventStatus status = aDOMEvent && aDOMEvent->DefaultPrevented()
+                             ? nsEventStatus_eConsumeNoDefault
+                         : aEventStatus ? *aEventStatus
+                                        : nsEventStatus_eIgnore;
+  nsCOMPtr<EventTarget> targetForPreVisitor = aEvent->mTarget;
+  EventChainPreVisitor preVisitor(aPresContext, aEvent, aDOMEvent, status,
+                                  isInAnon, targetForPreVisitor);
+  targetEtci->GetEventTargetParent(preVisitor);
+
+  if (!preVisitor.mCanHandle) {
+    targetEtci = MayRetargetToChromeIfCanNotHandleEvent(
+        chain, preVisitor, targetEtci, nullptr, content);
+  }
+  if (!preVisitor.mCanHandle) {
+    // The original target and chrome target (mAutomaticChromeDispatch=true)
+    // can not handle the event but we still have to call their PreHandleEvent.
+    for (uint32_t i = 0; i < chain.Length(); ++i) {
+      chain[i].PreHandleEvent(preVisitor);
+    }
+
+    clearTargets = ShouldClearTargets(aEvent);
+  } else {
+    // At least the original target can handle the event.
+    // Setting the retarget to the |target| simplifies retargeting code.
+    nsCOMPtr<EventTarget> t = aEvent->mTarget;
+    targetEtci->SetNewTarget(t);
+    // In order to not change the targetTouches array passed to TouchEvents
+    // when dispatching events from JS, we need to store the initial Touch
+    // objects on the list.
+    if (aEvent->mClass == eTouchEventClass && aDOMEvent) {
+      TouchEvent* touchEvent = static_cast<TouchEvent*>(aDOMEvent);
+      TouchList* targetTouches = touchEvent->GetExistingTargetTouches();
+      if (targetTouches) {
+        Maybe<nsTArray<RefPtr<dom::Touch>>> initialTargetTouches;
+        initialTargetTouches.emplace();
+        for (uint32_t i = 0; i < targetTouches->Length(); ++i) {
+          initialTargetTouches->AppendElement(targetTouches->Item(i));
+        }
+        targetEtci->SetInitialTargetTouches(std::move(initialTargetTouches));
+        targetTouches->Clear();
+      }
+    }
+    EventTargetChainItem* topEtci = targetEtci;
+    targetEtci = nullptr;
+    while (preVisitor.GetParentTarget()) {
+      EventTarget* parentTarget = preVisitor.GetParentTarget();
+      EventTargetChainItem* parentEtci =
+          EventTargetChainItem::Create(chain, parentTarget, topEtci);
+      if (!parentEtci->IsValid()) {
+        EventTargetChainItem::DestroyLast(chain, parentEtci);
+        rv = NS_ERROR_FAILURE;
+        break;
+      }
+
+      parentEtci->SetIsSlotInClosedTree(preVisitor.mParentIsSlotInClosedTree);
+      parentEtci->SetIsChromeHandler(preVisitor.mParentIsChromeHandler);
+
+      // Item needs event retargetting.
+      if (preVisitor.mEventTargetAtParent) {
+        // Need to set the target of the event
+        // so that also the next retargeting works.
+        preVisitor.mTargetInKnownToBeHandledScope = preVisitor.mEvent->mTarget;
+        preVisitor.mEvent->mTarget = preVisitor.mEventTargetAtParent;
+        parentEtci->SetNewTarget(preVisitor.mEventTargetAtParent);
+      }
+
+      if (preVisitor.mRetargetedRelatedTarget) {
+        preVisitor.mEvent->mRelatedTarget = preVisitor.mRetargetedRelatedTarget;
+      }
+
+      parentEtci->GetEventTargetParent(preVisitor);
+      if (preVisitor.mCanHandle) {
+        preVisitor.mTargetInKnownToBeHandledScope = preVisitor.mEvent->mTarget;
+        topEtci = parentEtci;
+      } else {
+        bool ignoreBecauseOfShadowDOM = preVisitor.mIgnoreBecauseOfShadowDOM;
+        nsCOMPtr<nsINode> disabledTarget = do_QueryInterface(parentTarget);
+        parentEtci = MayRetargetToChromeIfCanNotHandleEvent(
+            chain, preVisitor, parentEtci, topEtci, disabledTarget);
+        if (parentEtci && preVisitor.mCanHandle) {
+          preVisitor.mTargetInKnownToBeHandledScope =
+              preVisitor.mEvent->mTarget;
+          EventTargetChainItem* item =
+              EventTargetChainItem::GetFirstCanHandleEventTarget(chain);
+          if (!ignoreBecauseOfShadowDOM) {
+            // If we ignored the target because of Shadow DOM retargeting, we
+            // shouldn't treat the target to be in the event path at all.
+            item->SetNewTarget(parentTarget);
+          }
+          topEtci = parentEtci;
+          continue;
+        }
+        break;
+      }
+    }
+    if (NS_SUCCEEDED(rv)) {
+      if (aTargets) {
+        aTargets->Clear();
+        uint32_t numTargets = chain.Length();
+        EventTarget** targets = aTargets->AppendElements(numTargets);
+        for (uint32_t i = 0; i < numTargets; ++i) {
+          targets[i] = chain[i].CurrentTarget()->GetTargetForDOMEvent();
+        }
+      } else {
+        // Event target chain is created. PreHandle the chain.
+        for (uint32_t i = 0; i < chain.Length(); ++i) {
+          chain[i].PreHandleEvent(preVisitor);
+        }
+
+        clearTargets = ShouldClearTargets(aEvent);
+
+        // Handle the chain.
+        EventChainPostVisitor postVisitor(preVisitor);
+        MOZ_RELEASE_ASSERT(!aEvent->mPath);
+        aEvent->mPath = &chain;
+
+#ifdef MOZ_GECKO_PROFILER
+        if (profiler_is_active()) {
+          // Add a profiler label and a profiler marker for the actual
+          // dispatch of the event.
+          // This is a very hot code path, so we need to make sure not to
+          // do this extra work when we're not profiling.
+          if (!postVisitor.mDOMEvent) {
+            // This is tiny bit slow, but happens only once per event.
+            // Similar code also in EventListenerManager.
+            nsCOMPtr<EventTarget> et = aEvent->mOriginalTarget;
+            RefPtr<Event> event =
+                EventDispatcher::CreateEvent(et, aPresContext, aEvent, u""_ns);
+            event.swap(postVisitor.mDOMEvent);
+          }
+          nsAutoString typeStr;
+          postVisitor.mDOMEvent->GetType(typeStr);
+          AUTO_PROFILER_LABEL_DYNAMIC_LOSSY_NSSTRING(
+              "EventDispatcher::Dispatch", OTHER, typeStr);
+
+          nsCOMPtr<nsIDocShell> docShell;
+          docShell = nsContentUtils::GetDocShellForEventTarget(aEvent->mTarget);
+          MarkerInnerWindowId innerWindowId;
+          if (nsCOMPtr<nsPIDOMWindowInner> inner =
+                  do_QueryInterface(aEvent->mTarget->GetOwnerGlobal())) {
+            innerWindowId = MarkerInnerWindowId{inner->WindowID()};
+          }
+
+          struct DOMEventMarker {
+            static constexpr Span<const char> MarkerTypeName() {
+              return MakeStringSpan("DOMEvent");
+            }
+            static void StreamJSONMarkerData(
+                baseprofiler::SpliceableJSONWriter& aWriter,
+                const ProfilerString16View& aEventType,
+                const TimeStamp& aStartTime, const TimeStamp& aEventTimeStamp) {
+              aWriter.StringProperty(
+                  "eventType", NS_ConvertUTF16toUTF8(aEventType.Data(),
+                                                     aEventType.Length()));
+              // This is the event processing latency, which is the time from
+              // when the event was created, to when it was started to be
+              // processed. Note that the computation of this latency is
+              // deferred until serialization time, at the expense of some extra
+              // memory.
+              aWriter.DoubleProperty(
+                  "latency", (aStartTime - aEventTimeStamp).ToMilliseconds());
+            }
+            static MarkerSchema MarkerTypeDisplay() {
+              using MS = MarkerSchema;
+              MS schema{MS::Location::markerChart, MS::Location::markerTable,
+                        MS::Location::timelineOverview};
+              schema.SetChartLabel("{marker.data.eventType}");
+              schema.SetTooltipLabel("{marker.data.eventType} - DOMEvent");
+              schema.SetTableLabel("{marker.data.eventType}");
+              schema.AddKeyLabelFormat("latency", "Latency",
+                                       MS::Format::duration);
+              return schema;
+            }
+          };
+
+          auto startTime = TimeStamp::NowUnfuzzed();
+          profiler_add_marker("DOMEvent", geckoprofiler::category::DOM,
+                              {MarkerTiming::IntervalStart(),
+                               MarkerInnerWindowId(innerWindowId)},
+                              DOMEventMarker{}, typeStr, startTime,
+                              aEvent->mTimeStamp);
+
+          EventTargetChainItem::HandleEventTargetChain(chain, postVisitor,
+                                                       aCallback, cd);
+
+          profiler_add_marker(
+              "DOMEvent", geckoprofiler::category::DOM,
+              {MarkerTiming::IntervalEnd(), std::move(innerWindowId)},
+              DOMEventMarker{}, typeStr, startTime, aEvent->mTimeStamp);
+        } else
+#endif
+        {
+          EventTargetChainItem::HandleEventTargetChain(chain, postVisitor,
+                                                       aCallback, cd);
+        }
+        aEvent->mPath = nullptr;
+
+        if (aEvent->mMessage == eKeyPress && aEvent->IsTrusted()) {
+          if (aPresContext && aPresContext->GetRootPresContext()) {
+            nsRefreshDriver* driver =
+                aPresContext->GetRootPresContext()->RefreshDriver();
+            if (driver && driver->HasPendingTick()) {
+              driver->RegisterCompositionPayload(
+                  {layers::CompositionPayloadType::eKeyPress,
+                   aEvent->mTimeStamp});
+            }
+          }
+        }
+
+        preVisitor.mEventStatus = postVisitor.mEventStatus;
+        // If the DOM event was created during event flow.
+        if (!preVisitor.mDOMEvent && postVisitor.mDOMEvent) {
+          preVisitor.mDOMEvent = postVisitor.mDOMEvent;
+        }
+      }
+    }
+  }
+
+  // Note, EventTargetChainItem objects are deleted when the chain goes out of
+  // the scope.
+
+  aEvent->mFlags.mIsBeingDispatched = false;
+  aEvent->mFlags.mDispatchedAtLeastOnce = true;
+
+  // https://dom.spec.whatwg.org/#concept-event-dispatch
+  // step 10. If clearTargets, then:
+  //          1. Set event's target to null.
+  //          2. Set event's relatedTarget to null.
+  //          3. Set event's touch target list to the empty list.
+  if (clearTargets) {
+    aEvent->mTarget = nullptr;
+    aEvent->mOriginalTarget = nullptr;
+    aEvent->mRelatedTarget = nullptr;
+    aEvent->mOriginalRelatedTarget = nullptr;
+    // XXXsmaug Check also all the touch objects.
+  }
+
+  if (!externalDOMEvent && preVisitor.mDOMEvent) {
+    // A dom::Event was created while dispatching the event.
+    // Duplicate private data if someone holds a pointer to it.
+    nsrefcnt rc = 0;
+    NS_RELEASE2(preVisitor.mDOMEvent, rc);
+    if (preVisitor.mDOMEvent) {
+      preVisitor.mDOMEvent->DuplicatePrivateData();
+    }
+  }
+
+  if (aEventStatus) {
+    *aEventStatus = preVisitor.mEventStatus;
+  }
+
+  if (cd.IsMainThread() && chain.Capacity() == 128 && sCachedMainThreadChain) {
+    chain.ClearAndRetainStorage();
+    chain.SwapElements(*sCachedMainThreadChain);
+  }
+
+  return rv;
+}
+
+/* static */
+nsresult EventDispatcher::DispatchDOMEvent(nsISupports* aTarget,
+                                           WidgetEvent* aEvent,
+                                           Event* aDOMEvent,
+                                           nsPresContext* aPresContext,
+                                           nsEventStatus* aEventStatus) {
+  if (aDOMEvent) {
+    WidgetEvent* innerEvent = aDOMEvent->WidgetEventPtr();
+    NS_ENSURE_TRUE(innerEvent, NS_ERROR_ILLEGAL_VALUE);
+
+    // Don't modify the event if it's being dispatched right now.
+    if (innerEvent->mFlags.mIsBeingDispatched) {
+      return NS_ERROR_DOM_INVALID_STATE_ERR;
+    }
+
+    bool dontResetTrusted = false;
+    if (innerEvent->mFlags.mDispatchedAtLeastOnce) {
+      innerEvent->mTarget = nullptr;
+      innerEvent->mOriginalTarget = nullptr;
+    } else {
+      dontResetTrusted = aDOMEvent->IsTrusted();
+    }
+
+    if (!dontResetTrusted) {
+      // Check security state to determine if dispatcher is trusted
+      bool trusted = NS_IsMainThread()
+                         ? nsContentUtils::LegacyIsCallerChromeOrNativeCode()
+                         : IsCurrentThreadRunningChromeWorker();
+      aDOMEvent->SetTrusted(trusted);
+    }
+
+    return EventDispatcher::Dispatch(aTarget, aPresContext, innerEvent,
+                                     aDOMEvent, aEventStatus);
+  } else if (aEvent) {
+    return EventDispatcher::Dispatch(aTarget, aPresContext, aEvent, aDOMEvent,
+                                     aEventStatus);
+  }
+  return NS_ERROR_ILLEGAL_VALUE;
+}
+
+/* static */ already_AddRefed<dom::Event> EventDispatcher::CreateEvent(
+    EventTarget* aOwner, nsPresContext* aPresContext, WidgetEvent* aEvent,
+    const nsAString& aEventType, CallerType aCallerType) {
+  if (aEvent) {
+    switch (aEvent->mClass) {
+      case eMutationEventClass:
+        return NS_NewDOMMutationEvent(aOwner, aPresContext,
+                                      aEvent->AsMutationEvent());
+      case eGUIEventClass:
+      case eScrollPortEventClass:
+      case eUIEventClass:
+        return NS_NewDOMUIEvent(aOwner, aPresContext, aEvent->AsGUIEvent());
+      case eScrollAreaEventClass:
+        return NS_NewDOMScrollAreaEvent(aOwner, aPresContext,
+                                        aEvent->AsScrollAreaEvent());
+      case eKeyboardEventClass:
+        return NS_NewDOMKeyboardEvent(aOwner, aPresContext,
+                                      aEvent->AsKeyboardEvent());
+      case eCompositionEventClass:
+        return NS_NewDOMCompositionEvent(aOwner, aPresContext,
+                                         aEvent->AsCompositionEvent());
+      case eMouseEventClass:
+        return NS_NewDOMMouseEvent(aOwner, aPresContext,
+                                   aEvent->AsMouseEvent());
+      case eFocusEventClass:
+        return NS_NewDOMFocusEvent(aOwner, aPresContext,
+                                   aEvent->AsFocusEvent());
+      case eMouseScrollEventClass:
+        return NS_NewDOMMouseScrollEvent(aOwner, aPresContext,
+                                         aEvent->AsMouseScrollEvent());
+      case eWheelEventClass:
+        return NS_NewDOMWheelEvent(aOwner, aPresContext,
+                                   aEvent->AsWheelEvent());
+      case eEditorInputEventClass:
+        return NS_NewDOMInputEvent(aOwner, aPresContext,
+                                   aEvent->AsEditorInputEvent());
+      case eDragEventClass:
+        return NS_NewDOMDragEvent(aOwner, aPresContext, aEvent->AsDragEvent());
+      case eClipboardEventClass:
+        return NS_NewDOMClipboardEvent(aOwner, aPresContext,
+                                       aEvent->AsClipboardEvent());
+      case eSMILTimeEventClass:
+        return NS_NewDOMTimeEvent(aOwner, aPresContext,
+                                  aEvent->AsSMILTimeEvent());
+      case eCommandEventClass:
+        return NS_NewDOMCommandEvent(aOwner, aPresContext,
+                                     aEvent->AsCommandEvent());
+      case eSimpleGestureEventClass:
+        return NS_NewDOMSimpleGestureEvent(aOwner, aPresContext,
+                                           aEvent->AsSimpleGestureEvent());
+      case ePointerEventClass:
+        return NS_NewDOMPointerEvent(aOwner, aPresContext,
+                                     aEvent->AsPointerEvent());
+      case eTouchEventClass:
+        return NS_NewDOMTouchEvent(aOwner, aPresContext,
+                                   aEvent->AsTouchEvent());
+      case eTransitionEventClass:
+        return NS_NewDOMTransitionEvent(aOwner, aPresContext,
+                                        aEvent->AsTransitionEvent());
+      case eAnimationEventClass:
+        return NS_NewDOMAnimationEvent(aOwner, aPresContext,
+                                       aEvent->AsAnimationEvent());
+      default:
+        // For all other types of events, create a vanilla event object.
+        return NS_NewDOMEvent(aOwner, aPresContext, aEvent);
+    }
+  }
+
+  // And if we didn't get an event, check the type argument.
+
+  if (aEventType.LowerCaseEqualsLiteral("mouseevent") ||
+      aEventType.LowerCaseEqualsLiteral("mouseevents")) {
+    return NS_NewDOMMouseEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("dragevent")) {
+    return NS_NewDOMDragEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("keyboardevent")) {
+    return NS_NewDOMKeyboardEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("compositionevent") ||
+      aEventType.LowerCaseEqualsLiteral("textevent")) {
+    return NS_NewDOMCompositionEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("mutationevent") ||
+      aEventType.LowerCaseEqualsLiteral("mutationevents")) {
+    return NS_NewDOMMutationEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("deviceorientationevent")) {
+    DeviceOrientationEventInit init;
+    RefPtr<Event> event =
+        DeviceOrientationEvent::Constructor(aOwner, u""_ns, init);
+    event->MarkUninitialized();
+    return event.forget();
+  }
+  if (aEventType.LowerCaseEqualsLiteral("devicemotionevent")) {
+    return NS_NewDOMDeviceMotionEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("uievent") ||
+      aEventType.LowerCaseEqualsLiteral("uievents")) {
+    return NS_NewDOMUIEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("event") ||
+      aEventType.LowerCaseEqualsLiteral("events") ||
+      aEventType.LowerCaseEqualsLiteral("htmlevents") ||
+      aEventType.LowerCaseEqualsLiteral("svgevents")) {
+    return NS_NewDOMEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("messageevent")) {
+    RefPtr<Event> event = new MessageEvent(aOwner, aPresContext, nullptr);
+    return event.forget();
+  }
+  if (aEventType.LowerCaseEqualsLiteral("beforeunloadevent")) {
+    return NS_NewDOMBeforeUnloadEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("touchevent") &&
+      TouchEvent::LegacyAPIEnabled(
+          nsContentUtils::GetDocShellForEventTarget(aOwner),
+          aCallerType == CallerType::System)) {
+    return NS_NewDOMTouchEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("hashchangeevent")) {
+    HashChangeEventInit init;
+    RefPtr<Event> event = HashChangeEvent::Constructor(aOwner, u""_ns, init);
+    event->MarkUninitialized();
+    return event.forget();
+  }
+  if (aEventType.LowerCaseEqualsLiteral("customevent")) {
+    return NS_NewDOMCustomEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("storageevent")) {
+    RefPtr<Event> event =
+        StorageEvent::Constructor(aOwner, u""_ns, StorageEventInit());
+    event->MarkUninitialized();
+    return event.forget();
+  }
+  if (aEventType.LowerCaseEqualsLiteral("focusevent")) {
+    RefPtr<Event> event = NS_NewDOMFocusEvent(aOwner, aPresContext, nullptr);
+    event->MarkUninitialized();
+    return event.forget();
+  }
+
+  // Only allow these events for chrome
+  if (aCallerType == CallerType::System) {
+    if (aEventType.LowerCaseEqualsLiteral("simplegestureevent")) {
+      return NS_NewDOMSimpleGestureEvent(aOwner, aPresContext, nullptr);
+    }
+    if (aEventType.LowerCaseEqualsLiteral("xulcommandevent") ||
+        aEventType.LowerCaseEqualsLiteral("xulcommandevents")) {
+      return NS_NewDOMXULCommandEvent(aOwner, aPresContext, nullptr);
+    }
+  }
+
+  // NEW EVENT TYPES SHOULD NOT BE ADDED HERE; THEY SHOULD USE ONLY EVENT
+  // CONSTRUCTORS
+
+  return nullptr;
+}
+
+struct CurrentTargetPathInfo {
+  uint32_t mIndex;
+  int32_t mHiddenSubtreeLevel;
+};
+
+static CurrentTargetPathInfo TargetPathInfo(
+    const nsTArray<EventTargetChainItem>& aEventPath,
+    const EventTarget& aCurrentTarget) {
+  int32_t currentTargetHiddenSubtreeLevel = 0;
+  for (uint32_t index = aEventPath.Length(); index--;) {
+    const EventTargetChainItem& item = aEventPath.ElementAt(index);
+    if (item.PreHandleEventOnly()) {
+      continue;
+    }
+
+    if (item.IsRootOfClosedTree()) {
+      currentTargetHiddenSubtreeLevel++;
+    }
+
+    if (item.CurrentTarget() == &aCurrentTarget) {
+      return {index, currentTargetHiddenSubtreeLevel};
+    }
+
+    if (item.IsSlotInClosedTree()) {
+      currentTargetHiddenSubtreeLevel--;
+    }
+  }
+  MOZ_ASSERT_UNREACHABLE("No target found?");
+  return {0, 0};
+}
+
+// https://dom.spec.whatwg.org/#dom-event-composedpath
+void EventDispatcher::GetComposedPathFor(WidgetEvent* aEvent,
+                                         nsTArray<RefPtr<EventTarget>>& aPath) {
+  MOZ_ASSERT(aPath.IsEmpty());
+  nsTArray<EventTargetChainItem>* path = aEvent->mPath;
+  if (!path || path->IsEmpty() || !aEvent->mCurrentTarget) {
+    return;
+  }
+
+  EventTarget* currentTarget =
+      aEvent->mCurrentTarget->GetTargetForEventTargetChain();
+  if (!currentTarget) {
+    return;
+  }
+
+  CurrentTargetPathInfo currentTargetInfo =
+      TargetPathInfo(*path, *currentTarget);
+
+  {
+    int32_t maxHiddenLevel = currentTargetInfo.mHiddenSubtreeLevel;
+    int32_t currentHiddenLevel = currentTargetInfo.mHiddenSubtreeLevel;
+    for (uint32_t index = currentTargetInfo.mIndex; index--;) {
+      EventTargetChainItem& item = path->ElementAt(index);
+      if (item.PreHandleEventOnly()) {
+        continue;
+      }
+
+      if (item.IsRootOfClosedTree()) {
+        currentHiddenLevel++;
+      }
+
+      if (currentHiddenLevel <= maxHiddenLevel) {
+        aPath.AppendElement(item.CurrentTarget()->GetTargetForDOMEvent());
+      }
+
+      if (item.IsChromeHandler()) {
+        break;
+      }
+
+      if (item.IsSlotInClosedTree()) {
+        currentHiddenLevel--;
+        maxHiddenLevel = std::min(maxHiddenLevel, currentHiddenLevel);
+      }
+    }
+
+    aPath.Reverse();
+  }
+
+  aPath.AppendElement(currentTarget->GetTargetForDOMEvent());
+
+  {
+    int32_t maxHiddenLevel = currentTargetInfo.mHiddenSubtreeLevel;
+    int32_t currentHiddenLevel = currentTargetInfo.mHiddenSubtreeLevel;
+    for (uint32_t index = currentTargetInfo.mIndex + 1; index < path->Length();
+         ++index) {
+      EventTargetChainItem& item = path->ElementAt(index);
+      if (item.PreHandleEventOnly()) {
+        continue;
+      }
+
+      if (item.IsSlotInClosedTree()) {
+        currentHiddenLevel++;
+      }
+
+      if (item.IsChromeHandler()) {
+        break;
+      }
+
+      if (currentHiddenLevel <= maxHiddenLevel) {
+        aPath.AppendElement(item.CurrentTarget()->GetTargetForDOMEvent());
+      }
+
+      if (item.IsRootOfClosedTree()) {
+        currentHiddenLevel--;
+        maxHiddenLevel = std::min(maxHiddenLevel, currentHiddenLevel);
+      }
+    }
+  }
+}
+
+}  // namespace mozilla