--- a/dom/events/EventTarget.cpp
+++ b/dom/events/EventTarget.cpp
@@ -24,18 +24,26 @@ EventTarget::Constructor(const GlobalObj
     return nullptr;
   }
   RefPtr<EventTarget> target = new ConstructibleEventTarget(global);
   return target.forget();
 }
 
 bool
 EventTarget::ComputeWantsUntrusted(const Nullable<bool>& aWantsUntrusted,
+                                   const AddEventListenerOptionsOrBoolean* aOptions,
                                    ErrorResult& aRv)
 {
+  if (aOptions && aOptions->IsAddEventListenerOptions()) {
+    const auto& options = aOptions->GetAsAddEventListenerOptions();
+    if (options.mWantUntrusted.WasPassed()) {
+      return options.mWantUntrusted.Value();
+    }
+  }
+
   if (!aWantsUntrusted.IsNull()) {
     return aWantsUntrusted.Value();
   }
 
   bool defaultWantsUntrusted = ComputeDefaultWantsUntrusted(aRv);
   if (aRv.Failed()) {
     return false;
   }
@@ -45,17 +53,17 @@ EventTarget::ComputeWantsUntrusted(const
 
 void
 EventTarget::AddEventListener(const nsAString& aType,
                               EventListener* aCallback,
                               const AddEventListenerOptionsOrBoolean& aOptions,
                               const Nullable<bool>& aWantsUntrusted,
                               ErrorResult& aRv)
 {
-  bool wantsUntrusted = ComputeWantsUntrusted(aWantsUntrusted, aRv);
+  bool wantsUntrusted = ComputeWantsUntrusted(aWantsUntrusted, &aOptions, aRv);
   if (aRv.Failed()) {
     return;
   }
 
   EventListenerManager* elm = GetOrCreateListenerManager();
   if (!elm) {
     aRv.Throw(NS_ERROR_UNEXPECTED);
     return;
@@ -66,17 +74,17 @@ EventTarget::AddEventListener(const nsAS
 
 nsresult
 EventTarget::AddEventListener(const nsAString& aType,
                               nsIDOMEventListener* aListener,
                               bool aUseCapture,
                               const Nullable<bool>& aWantsUntrusted)
 {
   ErrorResult rv;
-  bool wantsUntrusted = ComputeWantsUntrusted(aWantsUntrusted, rv);
+  bool wantsUntrusted = ComputeWantsUntrusted(aWantsUntrusted, nullptr, rv);
   if (rv.Failed()) {
     return rv.StealNSResult();
   }
 
   EventListenerManager* elm = GetOrCreateListenerManager();
   NS_ENSURE_STATE(elm);
   elm->AddEventListener(aType, aListener, aUseCapture, wantsUntrusted);
   return NS_OK;
@@ -107,17 +115,17 @@ EventTarget::RemoveEventListener(const n
 
 nsresult
 EventTarget::AddSystemEventListener(const nsAString& aType,
                                     nsIDOMEventListener* aListener,
                                     bool aUseCapture,
                                     const Nullable<bool>& aWantsUntrusted)
 {
   ErrorResult rv;
-  bool wantsUntrusted = ComputeWantsUntrusted(aWantsUntrusted, rv);
+  bool wantsUntrusted = ComputeWantsUntrusted(aWantsUntrusted, nullptr, rv);
   if (rv.Failed()) {
     return rv.StealNSResult();
   }
 
   EventListenerManager* elm = GetOrCreateListenerManager();
   NS_ENSURE_STATE(elm);
 
   EventListenerFlags flags;

--- a/dom/events/EventTarget.h
+++ b/dom/events/EventTarget.h
@@ -286,16 +286,17 @@ protected:
    */
   virtual bool ComputeDefaultWantsUntrusted(ErrorResult& aRv) = 0;
 
   /**
    * A method to compute the right wantsUntrusted value for AddEventListener.
    * This will call the above hook as needed.
    */
   bool ComputeWantsUntrusted(const Nullable<bool>& aWantsUntrusted,
+                             const AddEventListenerOptionsOrBoolean* aOptions,
                              ErrorResult& aRv);
 
   /**
    * addSystemEventListener() adds an event listener of aType to the system
    * group.  Typically, core code should use the system group for listening to
    * content (i.e., non-chrome) element's events.  If core code uses
    * EventTarget::AddEventListener for a content node, it means
    * that the listener cannot listen to the event when web content calls

--- a/dom/webidl/EventTarget.webidl
+++ b/dom/webidl/EventTarget.webidl
@@ -16,16 +16,18 @@ dictionary EventListenerOptions {
   /* Setting to true make the listener be added to the system group. */
   [Func="ThreadSafeIsChromeOrXBL"]
   boolean mozSystemGroup = false;
 };
 
 dictionary AddEventListenerOptions : EventListenerOptions {
   boolean passive;
   boolean once = false;
+  [ChromeOnly]
+  boolean wantUntrusted;
 };
 
 [Constructor,
  Exposed=(Window,Worker,WorkerDebugger,AudioWorklet,System)]
 interface EventTarget {
   /* Passing null for wantsUntrusted means "default behavior", which
      differs in content and chrome.  In content that default boolean
      value is true, while in chrome the default boolean value is