--- a/layout/xul/nsImageBoxFrame.cpp
+++ b/layout/xul/nsImageBoxFrame.cpp
@@ -105,18 +105,22 @@ nsImageBoxFrameEvent::Run()
 
 void
 FireImageDOMEvent(nsIContent* aContent, EventMessage aMessage)
 {
   NS_ASSERTION(aMessage == eLoad || aMessage == eLoadError,
                "invalid message");
 
   nsCOMPtr<nsIRunnable> event = new nsImageBoxFrameEvent(aContent, aMessage);
-  if (NS_FAILED(NS_DispatchToCurrentThread(event)))
+  nsresult rv = aContent->OwnerDoc()->Dispatch("nsImageBoxFrameEvent",
+                                               TaskCategory::Other,
+                                               event.forget());
+  if (NS_FAILED(rv)) {
     NS_WARNING("failed to dispatch image event");
+  }
 }
 
 //
 // NS_NewImageBoxFrame
 //
 // Creates a new image frame and returns it
 //
 nsIFrame*

--- a/layout/xul/nsListBoxBodyFrame.cpp
+++ b/layout/xul/nsListBoxBodyFrame.cpp
@@ -823,23 +823,25 @@ nsListBoxBodyFrame::InternalPositionChan
   return DoInternalPositionChangedSync(smoother->mDelta < 0,
                                        smoother->mDelta < 0 ?
                                          -smoother->mDelta : smoother->mDelta);
 }
 
 nsresult
 nsListBoxBodyFrame::InternalPositionChanged(bool aUp, int32_t aDelta)
 {
-  RefPtr<nsPositionChangedEvent> ev =
+  RefPtr<nsPositionChangedEvent> event =
     new nsPositionChangedEvent(this, aUp, aDelta);
-  nsresult rv = NS_DispatchToCurrentThread(ev);
+  nsresult rv = mContent->OwnerDoc()->Dispatch("nsPositionChangedEvent",
+                                               TaskCategory::Other,
+                                               do_AddRef(event));
   if (NS_SUCCEEDED(rv)) {
-    if (!mPendingPositionChangeEvents.AppendElement(ev)) {
+    if (!mPendingPositionChangeEvents.AppendElement(event)) {
       rv = NS_ERROR_OUT_OF_MEMORY;
-      ev->Revoke();
+      event->Revoke();
     }
   }
   return rv;
 }
 
 nsresult
 nsListBoxBodyFrame::DoInternalPositionChangedSync(bool aUp, int32_t aDelta)
 {

--- a/layout/xul/nsMenuBarFrame.cpp
+++ b/layout/xul/nsMenuBarFrame.cpp
@@ -340,17 +340,19 @@ nsMenuBarFrame::ChangeMenuItem(nsMenuFra
     if (wasOpen && !aMenuItem->IsDisabled())
       aNewMenu = content;
   }
 
   // use an event so that hiding and showing can be done synchronously, which
   // avoids flickering
   nsCOMPtr<nsIRunnable> event =
     new nsMenuBarSwitchMenu(GetContent(), aOldMenu, aNewMenu, aSelectFirstItem);
-  return NS_DispatchToCurrentThread(event);
+  return mContent->OwnerDoc()->Dispatch("nsMenuBarSwitchMenu",
+                                        TaskCategory::Other,
+                                        event.forget());
 }
 
 nsMenuFrame*
 nsMenuBarFrame::Enter(WidgetGUIEvent* aEvent)
 {
   if (!mCurrentMenu)
     return nullptr;
 

--- a/layout/xul/nsMenuFrame.cpp
+++ b/layout/xul/nsMenuFrame.cpp
@@ -595,17 +595,19 @@ nsMenuFrame::PopupClosed(bool aDeselectM
             return;
 
           parent = parent->GetParent();
         }
 
         nsCOMPtr<nsIRunnable> event =
           new nsMenuActivateEvent(current->GetContent(),
                                   PresContext(), true);
-        NS_DispatchToCurrentThread(event);
+        mContent->OwnerDoc()->Dispatch("nsMenuActivateEvent",
+                                       TaskCategory::Other,
+                                       event.forget());
       }
     }
   }
 }
 
 NS_IMETHODIMP
 nsMenuFrame::SelectMenu(bool aActivateFlag)
 {
@@ -644,17 +646,19 @@ nsMenuFrame::SelectMenu(bool aActivateFl
     nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
     if (pm) {
       nsMenuParent* menuParent = GetMenuParent();
       pm->CancelMenuTimer(menuParent);
     }
 
     nsCOMPtr<nsIRunnable> event =
       new nsMenuActivateEvent(mContent, PresContext(), aActivateFlag);
-    NS_DispatchToCurrentThread(event);
+    mContent->OwnerDoc()->Dispatch("nsMenuActivateEvent",
+                                   TaskCategory::Other,
+                                   event.forget());
   }
 
   return NS_OK;
 }
 
 nsresult
 nsMenuFrame::AttributeChanged(int32_t aNameSpaceID,
                               nsIAtom* aAttribute,

--- a/layout/xul/nsMenuPopupFrame.cpp
+++ b/layout/xul/nsMenuPopupFrame.cpp
@@ -552,17 +552,19 @@ nsMenuPopupFrame::LayoutPopup(nsBoxLayou
       mContent->AddSystemEventListener(NS_LITERAL_STRING("transitionend"),
                                        mPopupShownDispatcher, false, false);
       return;
     }
 #endif
 
     // If there are no transitions, fire the popupshown event right away.
     nsCOMPtr<nsIRunnable> event = new nsXULPopupShownEvent(GetContent(), pc);
-    NS_DispatchToCurrentThread(event);
+    mContent->OwnerDoc()->Dispatch("nsXULPopupShownEvent",
+                                   TaskCategory::Other,
+                                   event.forget());
   }
 
   if (needCallback && !mReflowCallbackData.mPosted) {
     pc->PresShell()->PostReflowCallback(this);
     mReflowCallbackData.MarkPosted(aAnchor, aSizedToPopup);
   }
 }
 

--- a/layout/xul/tree/nsTreeBodyFrame.cpp
+++ b/layout/xul/tree/nsTreeBodyFrame.cpp
@@ -4735,21 +4735,24 @@ nsTreeBodyFrame::FireScrollEvent()
 }
 
 void
 nsTreeBodyFrame::PostScrollEvent()
 {
   if (mScrollEvent.IsPending())
     return;
 
-  RefPtr<ScrollEvent> ev = new ScrollEvent(this);
-  if (NS_FAILED(NS_DispatchToCurrentThread(ev))) {
+  RefPtr<ScrollEvent> event = new ScrollEvent(this);
+  nsresult rv = mContent->OwnerDoc()->Dispatch("ScrollEvent",
+                                               TaskCategory::Other,
+                                               do_AddRef(event));
+  if (NS_FAILED(rv)) {
     NS_WARNING("failed to dispatch ScrollEvent");
   } else {
-    mScrollEvent = ev;
+    mScrollEvent = event;
   }
 }
 
 void
 nsTreeBodyFrame::ScrollbarActivityStarted() const
 {
   if (mScrollbarActivity) {
     mScrollbarActivity->ActivityStarted();
@@ -4926,17 +4929,19 @@ nsTreeBodyFrame::FullScrollbarsUpdate(bo
   // Overflow checking dispatches synchronous events, which can cause infinite
   // recursion during reflow. Do the first overflow check synchronously, but
   // force any nested checks to round-trip through the event loop. See bug
   // 905909.
   RefPtr<nsOverflowChecker> checker = new nsOverflowChecker(this);
   if (!mCheckingOverflow) {
     nsContentUtils::AddScriptRunner(checker);
   } else {
-    NS_DispatchToCurrentThread(checker);
+    mContent->OwnerDoc()->Dispatch("nsOverflowChecker",
+                                   TaskCategory::Other,
+                                   checker.forget());
   }
   return weakFrame.IsAlive();
 }
 
 nsresult
 nsTreeBodyFrame::OnImageIsAnimated(imgIRequest* aRequest)
 {
   nsLayoutUtils::RegisterImageRequest(PresContext(),