Add m-esr52 at 52.6.0

1 files changed, 1068 insertions, 0 deletions

diff --git a/dom/events/EventDispatcher.cpp b/dom/events/EventDispatcher.cpp
new file mode 100644
index 000000000..a1d0675ae
--- /dev/null
+++ b/dom/events/EventDispatcher.cpp
@@ -0,0 +1,1068 @@
+/* -*- 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 "nsError.h"
+#include <new>
+#include "nsIContent.h"
+#include "nsIDocument.h"
+#include "nsINode.h"
+#include "nsPIDOMWindow.h"
+#include "AnimationEvent.h"
+#include "BeforeAfterKeyboardEvent.h"
+#include "BeforeUnloadEvent.h"
+#include "ClipboardEvent.h"
+#include "CommandEvent.h"
+#include "CompositionEvent.h"
+#include "DataContainerEvent.h"
+#include "DeviceMotionEvent.h"
+#include "DragEvent.h"
+#include "GeckoProfiler.h"
+#include "KeyboardEvent.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/PopStateEvent.h"
+#include "mozilla/dom/ScrollAreaEvent.h"
+#include "mozilla/dom/SimpleGestureEvent.h"
+#include "mozilla/dom/StorageEvent.h"
+#include "mozilla/dom/SVGZoomEvent.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"
+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,
+                                nsIDocument** aDocument = nullptr)
+{
+  if (aDocument) {
+    *aDocument = nullptr;
+  }
+
+  if (NS_WARN_IF(!aEventTarget)) {
+    return false;
+  }
+
+  nsCOMPtr<nsIDocument> doc = do_QueryInterface(aEventTarget);
+  if (!doc) {
+    nsCOMPtr<nsINode> node = do_QueryInterface(aEventTarget);
+    if (node) {
+      doc = node->OwnerDoc();
+    } else {
+      nsCOMPtr<nsPIDOMWindowInner> window = do_QueryInterface(aEventTarget);
+      if (!window) {
+        return false;
+      }
+      doc = window->GetExtantDoc();
+    }
+    if (!doc) {
+      return false;
+    }
+  }
+  bool isChrome = nsContentUtils::IsChromeDoc(doc);
+  if (aDocument) {
+    doc.swap(*aDocument);
+  }
+  return isChrome;
+}
+
+
+#define NS_TARGET_CHAIN_FORCE_CONTENT_DISPATCH  (1 << 0)
+#define NS_TARGET_CHAIN_WANTS_WILL_HANDLE_EVENT (1 << 1)
+#define NS_TARGET_CHAIN_MAY_HAVE_MANAGER        (1 << 2)
+#define NS_TARGET_CHAIN_CHECKED_IF_CHROME       (1 << 3)
+#define NS_TARGET_CHAIN_IS_CHROME_CONTENT       (1 << 4)
+
+// EventTargetChainItem represents a single item in the event target chain.
+class EventTargetChainItem
+{
+private:
+  explicit EventTargetChainItem(EventTarget* aTarget);
+public:
+  EventTargetChainItem()
+    : mFlags(0)
+    , mItemFlags(0)
+  {
+  }
+
+  static EventTargetChainItem* Create(nsTArray<EventTargetChainItem>& aChain,
+                                      EventTarget* aTarget,
+                                      EventTargetChainItem* aChild = nullptr)
+  {
+    MOZ_ASSERT(!aChild || &aChain.ElementAt(aChain.Length() - 1) == aChild);
+    return new (aChain.AppendElement()) EventTargetChainItem(aTarget);
+  }
+
+  static void DestroyLast(nsTArray<EventTargetChainItem>& aChain,
+                          EventTargetChainItem* aItem)
+  {
+    uint32_t lastIndex = aChain.Length() - 1;
+    MOZ_ASSERT(&aChain[lastIndex] == aItem);
+    aChain.RemoveElementAt(lastIndex);
+  }
+
+  bool IsValid()
+  {
+    NS_WARNING_ASSERTION(!!(mTarget), "Event target is not valid!");
+    return !!(mTarget);
+  }
+
+  EventTarget* GetNewTarget()
+  {
+    return mNewTarget;
+  }
+
+  void SetNewTarget(EventTarget* aNewTarget)
+  {
+    mNewTarget = aNewTarget;
+  }
+
+  void SetForceContentDispatch(bool aForce)
+  {
+    if (aForce) {
+      mFlags |= NS_TARGET_CHAIN_FORCE_CONTENT_DISPATCH;
+    } else {
+      mFlags &= ~NS_TARGET_CHAIN_FORCE_CONTENT_DISPATCH;
+    }
+  }
+
+  bool ForceContentDispatch()
+  {
+    return !!(mFlags & NS_TARGET_CHAIN_FORCE_CONTENT_DISPATCH);
+  }
+
+  void SetWantsWillHandleEvent(bool aWants)
+  {
+    if (aWants) {
+      mFlags |= NS_TARGET_CHAIN_WANTS_WILL_HANDLE_EVENT;
+    } else {
+      mFlags &= ~NS_TARGET_CHAIN_WANTS_WILL_HANDLE_EVENT;
+    }
+  }
+
+  bool WantsWillHandleEvent()
+  {
+    return !!(mFlags & NS_TARGET_CHAIN_WANTS_WILL_HANDLE_EVENT);
+  }
+
+  void SetMayHaveListenerManager(bool aMayHave)
+  {
+    if (aMayHave) {
+      mFlags |= NS_TARGET_CHAIN_MAY_HAVE_MANAGER;
+    } else {
+      mFlags &= ~NS_TARGET_CHAIN_MAY_HAVE_MANAGER;
+    }
+  }
+
+  bool MayHaveListenerManager()
+  {
+    return !!(mFlags & NS_TARGET_CHAIN_MAY_HAVE_MANAGER);
+  }
+  
+  EventTarget* CurrentTarget()
+  {
+    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.
+   */
+  static void HandleEventTargetChain(nsTArray<EventTargetChainItem>& aChain,
+                                     EventChainPostVisitor& aVisitor,
+                                     EventDispatchingCallback* aCallback,
+                                     ELMCreationDetector& aCd);
+
+  /**
+   * Resets aVisitor object and calls PreHandleEvent.
+   * Copies mItemFlags and mItemData to the current EventTargetChainItem.
+   */
+  void PreHandleEvent(EventChainPreVisitor& 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.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!");
+      mManager->HandleEvent(aVisitor.mPresContext, aVisitor.mEvent,
+                            &aVisitor.mDOMEvent,
+                            CurrentTarget(),
+                            &aVisitor.mEventStatus);
+      NS_ASSERTION(aVisitor.mEvent->mCurrentTarget == nullptr,
+                   "CurrentTarget should be null!");
+    }
+  }
+
+  /**
+   * Copies mItemFlags and mItemData to aVisitor and calls PostHandleEvent.
+   */
+  void PostHandleEvent(EventChainPostVisitor& aVisitor);
+
+private:
+  nsCOMPtr<EventTarget>             mTarget;
+  uint16_t                          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 & NS_TARGET_CHAIN_CHECKED_IF_CHROME)) {
+      mFlags |= NS_TARGET_CHAIN_CHECKED_IF_CHROME;
+      if (IsEventTargetChrome(mTarget)) {
+        mFlags |= NS_TARGET_CHAIN_IS_CHROME_CONTENT;
+      }
+    }
+    return !!(mFlags & NS_TARGET_CHAIN_IS_CHROME_CONTENT);
+  }
+};
+
+EventTargetChainItem::EventTargetChainItem(EventTarget* aTarget)
+  : mTarget(aTarget)
+  , mFlags(0)
+  , mItemFlags(0)
+{
+  MOZ_ASSERT(!aTarget || mTarget == aTarget->GetTargetForEventTargetChain());
+}
+
+void
+EventTargetChainItem::PreHandleEvent(EventChainPreVisitor& aVisitor)
+{
+  aVisitor.Reset();
+  Unused << mTarget->PreHandleEvent(aVisitor);
+  SetForceContentDispatch(aVisitor.mForceContentDispatch);
+  SetWantsWillHandleEvent(aVisitor.mWantsWillHandleEvent);
+  SetMayHaveListenerManager(aVisitor.mMayHaveListenerManager);
+  mItemFlags = aVisitor.mItemFlags;
+  mItemData = aVisitor.mItemData;
+}
+
+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;
+  uint32_t chainLength = aChain.Length();
+
+  // Capture
+  aVisitor.mEvent->mFlags.mInCapturePhase = true;
+  aVisitor.mEvent->mFlags.mInBubblingPhase = false;
+  for (uint32_t i = chainLength - 1; i > 0; --i) {
+    EventTargetChainItem& item = aChain[i];
+    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;
+        }
+      }
+    }
+  }
+
+  // Target
+  aVisitor.mEvent->mFlags.mInBubblingPhase = true;
+  EventTargetChainItem& targetItem = aChain[0];
+  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 = 1; i < chainLength; ++i) {
+    EventTargetChainItem& item = aChain[i];
+    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;
+    }
+
+    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) {
+    // 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;
+
+    // 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->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 */ nsresult
+EventDispatcher::Dispatch(nsISupports* aTarget,
+                          nsPresContext* aPresContext,
+                          WidgetEvent* aEvent,
+                          nsIDOMEvent* aDOMEvent,
+                          nsEventStatus* aEventStatus,
+                          EventDispatchingCallback* aCallback,
+                          nsTArray<EventTarget*>* aTargets)
+{
+  PROFILER_LABEL("EventDispatcher", "Dispatch",
+    js::ProfileEntry::Category::EVENTS);
+
+  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);
+
+#ifdef MOZ_TASK_TRACER
+  {
+    if (aDOMEvent) {
+      nsAutoString eventType;
+      aDOMEvent->GetType(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]",
+               NS_ConvertUTF16toUTF8(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 =
+        do_QueryInterface(content->FindFirstNonChromeOnlyAccessContent());
+      NS_ENSURE_STATE(newTarget);
+
+      aEvent->mOriginalTarget = target;
+      target = newTarget;
+      retargeted = true;
+    }
+  }
+
+  if (aEvent->mFlags.mOnlyChromeDispatch) {
+    nsCOMPtr<nsIDocument> 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 TabChildGlobal for event target chain.
+      target = piTarget;
+    } else if (NS_WARN_IF(!doc)) {
+      return NS_ERROR_UNEXPECTED;
+    }
+  }
+
+#ifdef DEBUG
+  if (aEvent->mMessage != eVoidEvent &&
+      !nsContentUtils::IsSafeToRunScript()) {
+    nsresult rv = NS_ERROR_FAILURE;
+    if (target->GetContextForEventHandlers(&rv) ||
+        NS_FAILED(rv)) {
+      nsCOMPtr<nsINode> node = do_QueryInterface(target);
+      if (node && nsContentUtils::IsChromeDoc(node->OwnerDoc())) {
+        NS_WARNING("Fix the caller!");
+      } else {
+        NS_ERROR("This is unsafe! Fix the caller!");
+      }
+    }
+  }
+
+  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.SwapElements(*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 nsIDOMEvent::target and nsIDOMEvent::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;
+  }
+
+  nsCOMPtr<nsIContent> content = do_QueryInterface(aEvent->mOriginalTarget);
+  bool isInAnon = (content && (content->IsInAnonymousSubtree() ||
+                               content->IsInShadowTree()));
+
+  aEvent->mFlags.mIsBeingDispatched = true;
+
+  // Create visitor object and start event dispatching.
+  // PreHandleEvent for the original target.
+  nsEventStatus status = aEventStatus ? *aEventStatus : nsEventStatus_eIgnore;
+  EventChainPreVisitor preVisitor(aPresContext, aEvent, aDOMEvent, status,
+                                  isInAnon);
+  targetEtci->PreHandleEvent(preVisitor);
+
+  if (!preVisitor.mCanHandle && preVisitor.mAutomaticChromeDispatch && content) {
+    // Event target couldn't handle the event. Try to propagate to chrome.
+    EventTargetChainItem::DestroyLast(chain, targetEtci);
+    targetEtci = EventTargetChainItemForChromeTarget(chain, content);
+    NS_ENSURE_STATE(targetEtci);
+    MOZ_ASSERT(&chain[0] == targetEtci);
+    targetEtci->PreHandleEvent(preVisitor);
+  }
+  if (preVisitor.mCanHandle) {
+    // At least the original target can handle the event.
+    // Setting the retarget to the |target| simplifies retargeting code.
+    nsCOMPtr<EventTarget> t = do_QueryInterface(aEvent->mTarget);
+    targetEtci->SetNewTarget(t);
+    EventTargetChainItem* topEtci = targetEtci;
+    targetEtci = nullptr;
+    while (preVisitor.mParentTarget) {
+      EventTarget* parentTarget = preVisitor.mParentTarget;
+      EventTargetChainItem* parentEtci =
+        EventTargetChainItem::Create(chain, preVisitor.mParentTarget, topEtci);
+      if (!parentEtci->IsValid()) {
+        EventTargetChainItem::DestroyLast(chain, parentEtci);
+        rv = NS_ERROR_FAILURE;
+        break;
+      }
+
+      // Item needs event retargetting.
+      if (preVisitor.mEventTargetAtParent) {
+        // Need to set the target of the event
+        // so that also the next retargeting works.
+        preVisitor.mEvent->mTarget = preVisitor.mEventTargetAtParent;
+        parentEtci->SetNewTarget(preVisitor.mEventTargetAtParent);
+      }
+
+      parentEtci->PreHandleEvent(preVisitor);
+      if (preVisitor.mCanHandle) {
+        topEtci = parentEtci;
+      } else {
+        EventTargetChainItem::DestroyLast(chain, parentEtci);
+        parentEtci = nullptr;
+        if (preVisitor.mAutomaticChromeDispatch && content) {
+          // Even if the current target can't handle the event, try to
+          // propagate to chrome.
+          nsCOMPtr<nsINode> disabledTarget = do_QueryInterface(parentTarget);
+          if (disabledTarget) {
+            parentEtci = EventTargetChainItemForChromeTarget(chain,
+                                                             disabledTarget,
+                                                             topEtci);
+            if (parentEtci) {
+              parentEtci->PreHandleEvent(preVisitor);
+              if (preVisitor.mCanHandle) {
+                chain[0].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. Handle the chain.
+        EventChainPostVisitor postVisitor(preVisitor);
+        EventTargetChainItem::HandleEventTargetChain(chain, postVisitor,
+                                                     aCallback, cd);
+
+        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;
+
+  if (!externalDOMEvent && preVisitor.mDOMEvent) {
+    // An 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,
+                                  nsIDOMEvent* aDOMEvent,
+                                  nsPresContext* aPresContext,
+                                  nsEventStatus* aEventStatus)
+{
+  if (aDOMEvent) {
+    WidgetEvent* innerEvent = aDOMEvent->WidgetEventPtr();
+    NS_ENSURE_TRUE(innerEvent, NS_ERROR_ILLEGAL_VALUE);
+
+    bool dontResetTrusted = false;
+    if (innerEvent->mFlags.mDispatchedAtLeastOnce) {
+      innerEvent->mTarget = nullptr;
+      innerEvent->mOriginalTarget = nullptr;
+    } else {
+      aDOMEvent->GetIsTrusted(&dontResetTrusted);
+    }
+
+    if (!dontResetTrusted) {
+      //Check security state to determine if dispatcher is trusted
+      bool trusted = NS_IsMainThread() ? nsContentUtils::LegacyIsCallerChromeOrNativeCode()
+                                       : mozilla::dom::workers::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)
+{
+  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 eBeforeAfterKeyboardEventClass:
+      return NS_NewDOMBeforeAfterKeyboardEvent(aOwner, aPresContext,
+                                               aEvent->AsBeforeAfterKeyboardEvent());
+    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 eSVGZoomEventClass:
+      return NS_NewDOMSVGZoomEvent(aOwner, aPresContext,
+                                   aEvent->AsSVGZoomEvent());
+    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.
+
+#define LOG_EVENT_CREATION(name) mozilla::Telemetry::Accumulate( \
+    mozilla::Telemetry::CREATE_EVENT_##name, true);
+
+  if (aEventType.LowerCaseEqualsLiteral("mouseevent")) {
+    LOG_EVENT_CREATION(MOUSEEVENT);
+    return NS_NewDOMMouseEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("mouseevents")) {
+    LOG_EVENT_CREATION(MOUSEEVENTS);
+    return NS_NewDOMMouseEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("popupevents")) {
+    LOG_EVENT_CREATION(POPUPEVENTS);
+    return NS_NewDOMMouseEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("mousescrollevents")) {
+    LOG_EVENT_CREATION(MOUSESCROLLEVENTS);
+    return NS_NewDOMMouseScrollEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("dragevent")) {
+    LOG_EVENT_CREATION(DRAGEVENT);
+    return NS_NewDOMDragEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("dragevents")) {
+    LOG_EVENT_CREATION(DRAGEVENTS);
+    return NS_NewDOMDragEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("keyboardevent")) {
+    LOG_EVENT_CREATION(KEYBOARDEVENT);
+    return NS_NewDOMKeyboardEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("keyevents")) {
+    LOG_EVENT_CREATION(KEYEVENTS);
+    return NS_NewDOMKeyboardEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("compositionevent")) {
+    LOG_EVENT_CREATION(COMPOSITIONEVENT);
+    return NS_NewDOMCompositionEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("textevent")) {
+    LOG_EVENT_CREATION(TEXTEVENT);
+    return NS_NewDOMCompositionEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("textevents")) {
+    LOG_EVENT_CREATION(TEXTEVENTS);
+    return NS_NewDOMCompositionEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("mutationevent")) {
+    LOG_EVENT_CREATION(MUTATIONEVENT);
+    return NS_NewDOMMutationEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("mutationevents")) {
+    LOG_EVENT_CREATION(MUTATIONEVENTS);
+    return NS_NewDOMMutationEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("deviceorientationevent")) {
+    LOG_EVENT_CREATION(DEVICEORIENTATIONEVENT);
+    DeviceOrientationEventInit init;
+    RefPtr<Event> event =
+      DeviceOrientationEvent::Constructor(aOwner, EmptyString(), init);
+    event->MarkUninitialized();
+    return event.forget();
+  }
+  if (aEventType.LowerCaseEqualsLiteral("devicemotionevent")) {
+    LOG_EVENT_CREATION(DEVICEMOTIONEVENT);
+    return NS_NewDOMDeviceMotionEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("uievent")) {
+    LOG_EVENT_CREATION(UIEVENT);
+    return NS_NewDOMUIEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("uievents")) {
+    LOG_EVENT_CREATION(UIEVENTS);
+    return NS_NewDOMUIEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("event")) {
+    LOG_EVENT_CREATION(EVENT);
+    return NS_NewDOMEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("events")) {
+    LOG_EVENT_CREATION(EVENTS);
+    return NS_NewDOMEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("htmlevents")) {
+    LOG_EVENT_CREATION(HTMLEVENTS);
+    return NS_NewDOMEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("svgevent")) {
+    LOG_EVENT_CREATION(SVGEVENT);
+    return NS_NewDOMEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("svgevents")) {
+    LOG_EVENT_CREATION(SVGEVENTS);
+    return NS_NewDOMEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("svgzoomevent")) {
+    LOG_EVENT_CREATION(SVGZOOMEVENT);
+    return NS_NewDOMSVGZoomEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("svgzoomevents")) {
+    LOG_EVENT_CREATION(SVGZOOMEVENTS);
+    return NS_NewDOMSVGZoomEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("timeevent")) {
+    LOG_EVENT_CREATION(TIMEEVENT);
+    return NS_NewDOMTimeEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("timeevents")) {
+    LOG_EVENT_CREATION(TIMEEVENTS);
+    return NS_NewDOMTimeEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("xulcommandevent")) {
+    LOG_EVENT_CREATION(XULCOMMANDEVENT);
+    return NS_NewDOMXULCommandEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("xulcommandevents")) {
+    LOG_EVENT_CREATION(XULCOMMANDEVENTS);
+    return NS_NewDOMXULCommandEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("commandevent")) {
+    LOG_EVENT_CREATION(COMMANDEVENT);
+    return NS_NewDOMCommandEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("commandevents")) {
+    LOG_EVENT_CREATION(COMMANDEVENTS);
+    return NS_NewDOMCommandEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("datacontainerevent")) {
+    LOG_EVENT_CREATION(DATACONTAINEREVENT);
+    return NS_NewDOMDataContainerEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("datacontainerevents")) {
+    LOG_EVENT_CREATION(DATACONTAINEREVENTS);
+    return NS_NewDOMDataContainerEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("messageevent")) {
+    LOG_EVENT_CREATION(MESSAGEEVENT);
+    RefPtr<Event> event = new MessageEvent(aOwner, aPresContext, nullptr);
+    return event.forget();
+  }
+  if (aEventType.LowerCaseEqualsLiteral("notifypaintevent")) {
+    LOG_EVENT_CREATION(NOTIFYPAINTEVENT);
+    return NS_NewDOMNotifyPaintEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("simplegestureevent")) {
+    LOG_EVENT_CREATION(SIMPLEGESTUREEVENT);
+    return NS_NewDOMSimpleGestureEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("beforeunloadevent")) {
+    LOG_EVENT_CREATION(BEFOREUNLOADEVENT);
+    return NS_NewDOMBeforeUnloadEvent(aOwner, aPresContext, nullptr);
+  }
+  // XXXkhuey this is broken
+  if (aEventType.LowerCaseEqualsLiteral("pagetransition")) {
+    LOG_EVENT_CREATION(PAGETRANSITION);
+    PageTransitionEventInit init;
+    RefPtr<Event> event =
+      PageTransitionEvent::Constructor(aOwner, EmptyString(), init);
+    event->MarkUninitialized();
+    return event.forget();
+  }
+  if (aEventType.LowerCaseEqualsLiteral("scrollareaevent")) {
+    LOG_EVENT_CREATION(SCROLLAREAEVENT);
+    return NS_NewDOMScrollAreaEvent(aOwner, aPresContext, nullptr);
+  }
+  // XXXkhuey Chrome supports popstateevent here, even though it provides no
+  // initPopStateEvent method.  This is nuts ... but copying it is unlikely to
+  // break the web.
+  if (aEventType.LowerCaseEqualsLiteral("popstateevent")) {
+    LOG_EVENT_CREATION(POPSTATEEVENT);
+    AutoJSContext cx;
+    RootedDictionary<PopStateEventInit> init(cx);
+    RefPtr<Event> event =
+      PopStateEvent::Constructor(aOwner, EmptyString(), init);
+    event->MarkUninitialized();
+    return event.forget();
+  }
+  if (aEventType.LowerCaseEqualsLiteral("touchevent") &&
+      TouchEvent::PrefEnabled(nsContentUtils::GetDocShellForEventTarget(aOwner))) {
+    LOG_EVENT_CREATION(TOUCHEVENT);
+    return NS_NewDOMTouchEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("hashchangeevent")) {
+    LOG_EVENT_CREATION(HASHCHANGEEVENT);
+    HashChangeEventInit init;
+    RefPtr<Event> event =
+      HashChangeEvent::Constructor(aOwner, EmptyString(), init);
+    event->MarkUninitialized();
+    return event.forget();
+  }
+  if (aEventType.LowerCaseEqualsLiteral("customevent")) {
+    LOG_EVENT_CREATION(CUSTOMEVENT);
+    return NS_NewDOMCustomEvent(aOwner, aPresContext, nullptr);
+  }
+  if (aEventType.LowerCaseEqualsLiteral("storageevent")) {
+    LOG_EVENT_CREATION(STORAGEEVENT);
+    return NS_NewDOMStorageEvent(aOwner);
+  }
+
+#undef LOG_EVENT_CREATION
+
+  // NEW EVENT TYPES SHOULD NOT BE ADDED HERE; THEY SHOULD USE ONLY EVENT
+  // CONSTRUCTORS
+
+  return nullptr;
+}
+
+} // namespace mozilla