Merge remote-tracking branch 'upstream/master' into feat-cow-infra

`tests/wpt/web-platform-tests/html/browsers/origin/cross-origin-objects/cross-origin-objects.html`
was reverted to the upstream version.

1 files changed, 469 insertions, 269 deletions

diff --git a/components/script/dom/eventtarget.rs b/components/script/dom/eventtarget.rs
index f45942f0f05..eb27f63069f 100644
--- a/components/script/dom/eventtarget.rs
+++ b/components/script/dom/eventtarget.rs
@@ -1,54 +1,64 @@
 /* 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/. */
-
-use dom::beforeunloadevent::BeforeUnloadEvent;
-use dom::bindings::callback::{CallbackContainer, ExceptionHandling, CallbackFunction};
-use dom::bindings::cell::DOMRefCell;
-use dom::bindings::codegen::Bindings::BeforeUnloadEventBinding::BeforeUnloadEventMethods;
-use dom::bindings::codegen::Bindings::ErrorEventBinding::ErrorEventMethods;
-use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
-use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
-use dom::bindings::codegen::Bindings::EventHandlerBinding::OnBeforeUnloadEventHandlerNonNull;
-use dom::bindings::codegen::Bindings::EventHandlerBinding::OnErrorEventHandlerNonNull;
-use dom::bindings::codegen::Bindings::EventListenerBinding::EventListener;
-use dom::bindings::codegen::Bindings::EventTargetBinding::EventTargetMethods;
-use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
-use dom::bindings::codegen::UnionTypes::EventOrString;
-use dom::bindings::error::{Error, Fallible, report_pending_exception};
-use dom::bindings::inheritance::Castable;
-use dom::bindings::js::Root;
-use dom::bindings::reflector::{DomObject, Reflector};
-use dom::bindings::str::DOMString;
-use dom::element::Element;
-use dom::errorevent::ErrorEvent;
-use dom::event::{Event, EventBubbles, EventCancelable, EventStatus};
-use dom::node::document_from_node;
-use dom::virtualmethods::VirtualMethods;
-use dom::window::Window;
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+use crate::dom::beforeunloadevent::BeforeUnloadEvent;
+use crate::dom::bindings::callback::{CallbackContainer, CallbackFunction, ExceptionHandling};
+use crate::dom::bindings::cell::DomRefCell;
+use crate::dom::bindings::codegen::Bindings::BeforeUnloadEventBinding::BeforeUnloadEventMethods;
+use crate::dom::bindings::codegen::Bindings::ErrorEventBinding::ErrorEventMethods;
+use crate::dom::bindings::codegen::Bindings::EventBinding::EventMethods;
+use crate::dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
+use crate::dom::bindings::codegen::Bindings::EventHandlerBinding::OnBeforeUnloadEventHandlerNonNull;
+use crate::dom::bindings::codegen::Bindings::EventHandlerBinding::OnErrorEventHandlerNonNull;
+use crate::dom::bindings::codegen::Bindings::EventListenerBinding::EventListener;
+use crate::dom::bindings::codegen::Bindings::EventTargetBinding::AddEventListenerOptions;
+use crate::dom::bindings::codegen::Bindings::EventTargetBinding::EventListenerOptions;
+use crate::dom::bindings::codegen::Bindings::EventTargetBinding::EventTargetMethods;
+use crate::dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
+use crate::dom::bindings::codegen::UnionTypes::AddEventListenerOptionsOrBoolean;
+use crate::dom::bindings::codegen::UnionTypes::EventListenerOptionsOrBoolean;
+use crate::dom::bindings::codegen::UnionTypes::EventOrString;
+use crate::dom::bindings::error::{report_pending_exception, Error, Fallible};
+use crate::dom::bindings::inheritance::Castable;
+use crate::dom::bindings::reflector::{reflect_dom_object, DomObject, Reflector};
+use crate::dom::bindings::root::DomRoot;
+use crate::dom::bindings::str::DOMString;
+use crate::dom::element::Element;
+use crate::dom::errorevent::ErrorEvent;
+use crate::dom::event::{Event, EventBubbles, EventCancelable, EventStatus};
+use crate::dom::globalscope::GlobalScope;
+use crate::dom::htmlformelement::FormControlElementHelpers;
+use crate::dom::node::document_from_node;
+use crate::dom::virtualmethods::VirtualMethods;
+use crate::dom::window::Window;
+use crate::dom::workerglobalscope::WorkerGlobalScope;
+use crate::realms::{enter_realm, InRealm};
 use dom_struct::dom_struct;
 use fnv::FnvHasher;
-use heapsize::HeapSizeOf;
-use js::jsapi::{CompileFunction, JS_GetFunctionObject, JSAutoCompartment};
-use js::rust::{AutoObjectVectorWrapper, CompileOptionsWrapper};
-use libc::{c_char, size_t};
+use js::jsapi::JS_GetFunctionObject;
+use js::rust::transform_u16_to_source_text;
+use js::rust::wrappers::CompileFunction;
+use js::rust::{CompileOptionsWrapper, RootedObjectVectorWrapper};
+use libc::c_char;
 use servo_atoms::Atom;
 use servo_url::ServoUrl;
-use std::collections::HashMap;
 use std::collections::hash_map::Entry::{Occupied, Vacant};
+use std::collections::HashMap;
 use std::default::Default;
 use std::ffi::CString;
 use std::hash::BuildHasherDefault;
 use std::mem;
 use std::ops::{Deref, DerefMut};
-use std::ptr;
 use std::rc::Rc;
 
-#[derive(PartialEq, Clone, JSTraceable)]
+#[derive(Clone, JSTraceable, MallocSizeOf, PartialEq)]
 pub enum CommonEventHandler {
-    EventHandler(Rc<EventHandlerNonNull>),
-    ErrorEventHandler(Rc<OnErrorEventHandlerNonNull>),
-    BeforeUnloadEventHandler(Rc<OnBeforeUnloadEventHandlerNonNull>),
+    EventHandler(#[ignore_malloc_size_of = "Rc"] Rc<EventHandlerNonNull>),
+
+    ErrorEventHandler(#[ignore_malloc_size_of = "Rc"] Rc<OnErrorEventHandlerNonNull>),
+
+    BeforeUnloadEventHandler(#[ignore_malloc_size_of = "Rc"] Rc<OnBeforeUnloadEventHandlerNonNull>),
 }
 
 impl CommonEventHandler {
@@ -61,14 +71,14 @@ impl CommonEventHandler {
     }
 }
 
-#[derive(JSTraceable, Copy, Clone, PartialEq, HeapSizeOf)]
+#[derive(Clone, Copy, Debug, JSTraceable, MallocSizeOf, PartialEq)]
 pub enum ListenerPhase {
     Capturing,
     Bubbling,
 }
 
-/// https://html.spec.whatwg.org/multipage/#internal-raw-uncompiled-handler
-#[derive(JSTraceable, Clone, PartialEq)]
+/// <https://html.spec.whatwg.org/multipage/#internal-raw-uncompiled-handler>
+#[derive(Clone, JSTraceable, MallocSizeOf, PartialEq)]
 struct InternalRawUncompiledHandler {
     source: DOMString,
     url: ServoUrl,
@@ -76,7 +86,7 @@ struct InternalRawUncompiledHandler {
 }
 
 /// A representation of an event handler, either compiled or uncompiled raw source, or null.
-#[derive(JSTraceable, PartialEq, Clone)]
+#[derive(Clone, JSTraceable, MallocSizeOf, PartialEq)]
 enum InlineEventListener {
     Uncompiled(InternalRawUncompiledHandler),
     Compiled(CommonEventHandler),
@@ -86,9 +96,12 @@ enum InlineEventListener {
 impl InlineEventListener {
     /// Get a compiled representation of this event handler, compiling it from its
     /// raw source if necessary.
-    /// https://html.spec.whatwg.org/multipage/#getting-the-current-value-of-the-event-handler
-    fn get_compiled_handler(&mut self, owner: &EventTarget, ty: &Atom)
-                            -> Option<CommonEventHandler> {
+    /// <https://html.spec.whatwg.org/multipage/#getting-the-current-value-of-the-event-handler>
+    fn get_compiled_handler(
+        &mut self,
+        owner: &EventTarget,
+        ty: &Atom,
+    ) -> Option<CommonEventHandler> {
         match mem::replace(self, InlineEventListener::Null) {
             InlineEventListener::Null => None,
             InlineEventListener::Uncompiled(handler) => {
@@ -97,37 +110,34 @@ impl InlineEventListener {
                     *self = InlineEventListener::Compiled(compiled.clone());
                 }
                 result
-            }
+            },
             InlineEventListener::Compiled(handler) => {
                 *self = InlineEventListener::Compiled(handler.clone());
                 Some(handler)
-            }
+            },
         }
     }
 }
 
-#[derive(JSTraceable, Clone, PartialEq)]
+#[derive(Clone, JSTraceable, MallocSizeOf, PartialEq)]
 enum EventListenerType {
-    Additive(Rc<EventListener>),
+    Additive(#[ignore_malloc_size_of = "Rc"] Rc<EventListener>),
     Inline(InlineEventListener),
 }
 
-impl HeapSizeOf for EventListenerType {
-    fn heap_size_of_children(&self) -> usize {
-        // FIXME: Rc<T> isn't HeapSizeOf and we can't ignore it due to #6870 and #6871
-        0
-    }
-}
-
 impl EventListenerType {
-    fn get_compiled_listener(&mut self, owner: &EventTarget, ty: &Atom)
-                             -> Option<CompiledEventListener> {
+    fn get_compiled_listener(
+        &mut self,
+        owner: &EventTarget,
+        ty: &Atom,
+    ) -> Option<CompiledEventListener> {
         match self {
-            &mut EventListenerType::Inline(ref mut inline) =>
-                inline.get_compiled_handler(owner, ty)
-                      .map(CompiledEventListener::Handler),
-            &mut EventListenerType::Additive(ref listener) =>
-                Some(CompiledEventListener::Listener(listener.clone())),
+            &mut EventListenerType::Inline(ref mut inline) => inline
+                .get_compiled_handler(owner, ty)
+                .map(CompiledEventListener::Handler),
+            &mut EventListenerType::Additive(ref listener) => {
+                Some(CompiledEventListener::Listener(listener.clone()))
+            },
         }
     }
 }
@@ -141,11 +151,29 @@ pub enum CompiledEventListener {
 
 impl CompiledEventListener {
     #[allow(unsafe_code)]
+    pub fn associated_global(&self) -> DomRoot<GlobalScope> {
+        let obj = match self {
+            CompiledEventListener::Listener(listener) => listener.callback(),
+            CompiledEventListener::Handler(CommonEventHandler::EventHandler(handler)) => {
+                handler.callback()
+            },
+            CompiledEventListener::Handler(CommonEventHandler::ErrorEventHandler(handler)) => {
+                handler.callback()
+            },
+            CompiledEventListener::Handler(CommonEventHandler::BeforeUnloadEventHandler(
+                handler,
+            )) => handler.callback(),
+        };
+        unsafe { GlobalScope::from_object(obj) }
+    }
+
     // https://html.spec.whatwg.org/multipage/#the-event-handler-processing-algorithm
-    pub fn call_or_handle_event<T: DomObject>(&self,
-                                              object: &T,
-                                              event: &Event,
-                                              exception_handle: ExceptionHandling) {
+    pub fn call_or_handle_event(
+        &self,
+        object: &EventTarget,
+        event: &Event,
+        exception_handle: ExceptionHandling,
+    ) {
         // Step 3
         match *self {
             CompiledEventListener::Listener(ref listener) => {
@@ -155,80 +183,103 @@ impl CompiledEventListener {
                 match *handler {
                     CommonEventHandler::ErrorEventHandler(ref handler) => {
                         if let Some(event) = event.downcast::<ErrorEvent>() {
-                            let cx = object.global().get_cx();
-                            rooted!(in(cx) let error = unsafe { event.Error(cx) });
-                            let return_value = handler.Call_(object,
-                                                             EventOrString::String(event.Message()),
-                                                             Some(event.Filename()),
-                                                             Some(event.Lineno()),
-                                                             Some(event.Colno()),
-                                                             Some(error.handle()),
-                                                             exception_handle);
-                            // Step 4
-                            if let Ok(return_value) = return_value {
-                                rooted!(in(cx) let return_value = return_value);
-                                if return_value.handle().is_boolean() && return_value.handle().to_boolean() == true {
-                                    event.upcast::<Event>().PreventDefault();
+                            if object.is::<Window>() || object.is::<WorkerGlobalScope>() {
+                                let cx = object.global().get_cx();
+                                rooted!(in(*cx) let error = event.Error(cx));
+                                let return_value = handler.Call_(
+                                    object,
+                                    EventOrString::String(event.Message()),
+                                    Some(event.Filename()),
+                                    Some(event.Lineno()),
+                                    Some(event.Colno()),
+                                    Some(error.handle()),
+                                    exception_handle,
+                                );
+                                // Step 4
+                                if let Ok(return_value) = return_value {
+                                    rooted!(in(*cx) let return_value = return_value);
+                                    if return_value.handle().is_boolean() &&
+                                        return_value.handle().to_boolean() == true
+                                    {
+                                        event.upcast::<Event>().PreventDefault();
+                                    }
                                 }
+                                return;
                             }
-                            return;
                         }
 
-                        let _ = handler.Call_(object, EventOrString::Event(Root::from_ref(event)),
-                                              None, None, None, None, exception_handle);
-                    }
+                        let _ = handler.Call_(
+                            object,
+                            EventOrString::Event(DomRoot::from_ref(event)),
+                            None,
+                            None,
+                            None,
+                            None,
+                            exception_handle,
+                        );
+                    },
 
                     CommonEventHandler::BeforeUnloadEventHandler(ref handler) => {
                         if let Some(event) = event.downcast::<BeforeUnloadEvent>() {
-                            let rv = event.ReturnValue();
-
-                            if let Ok(value) = handler.Call_(object,
-                                                             event.upcast::<Event>(),
-                                                             exception_handle) {
-                                match value {
-                                    Some(value) => {
-                                        if rv.is_empty() {
-                                            event.SetReturnValue(value);
-                                        }
-                                    }
-                                    None => {
-                                        event.upcast::<Event>().PreventDefault();
+                            // Step 5
+                            if let Ok(value) =
+                                handler.Call_(object, event.upcast::<Event>(), exception_handle)
+                            {
+                                let rv = event.ReturnValue();
+                                if let Some(v) = value {
+                                    if rv.is_empty() {
+                                        event.SetReturnValue(v);
                                     }
+                                    event.upcast::<Event>().PreventDefault();
                                 }
                             }
+                        } else {
+                            // Step 5, "Otherwise" clause
+                            let _ =
+                                handler.Call_(object, event.upcast::<Event>(), exception_handle);
                         }
-                    }
+                    },
 
                     CommonEventHandler::EventHandler(ref handler) => {
                         if let Ok(value) = handler.Call_(object, event, exception_handle) {
                             let cx = object.global().get_cx();
-                            rooted!(in(cx) let value = value);
+                            rooted!(in(*cx) let value = value);
                             let value = value.handle();
 
-                            //Step 4
-                            let should_cancel = match event.type_() {
-                                atom!("mouseover") => value.is_boolean() && value.to_boolean() == true,
-                                _ => value.is_boolean() && value.to_boolean() == false
-                            };
+                            //Step 5
+                            let should_cancel = value.is_boolean() && value.to_boolean() == false;
+
                             if should_cancel {
+                                // FIXME: spec says to set the cancelled flag directly
+                                // here, not just to prevent default;
+                                // can that ever make a difference?
                                 event.PreventDefault();
                             }
                         }
-                    }
+                    },
                 }
-            }
+            },
         }
     }
 }
 
-#[derive(Clone, DenyPublicFields, HeapSizeOf, JSTraceable, PartialEq)]
+// https://dom.spec.whatwg.org/#concept-event-listener
+// (as distinct from https://dom.spec.whatwg.org/#callbackdef-eventlistener)
+#[derive(Clone, DenyPublicFields, JSTraceable, MallocSizeOf)]
 /// A listener in a collection of event listeners.
 struct EventListenerEntry {
     phase: ListenerPhase,
-    listener: EventListenerType
+    listener: EventListenerType,
+    once: bool,
+}
+
+impl std::cmp::PartialEq for EventListenerEntry {
+    fn eq(&self, other: &Self) -> bool {
+        self.phase == other.phase && self.listener == other.listener
+    }
 }
 
-#[derive(JSTraceable, HeapSizeOf)]
+#[derive(JSTraceable, MallocSizeOf)]
 /// A mix of potentially uncompiled and compiled event listeners of the same type.
 struct EventListeners(Vec<EventListenerEntry>);
 
@@ -247,7 +298,11 @@ impl DerefMut for EventListeners {
 
 impl EventListeners {
     // https://html.spec.whatwg.org/multipage/#getting-the-current-value-of-the-event-handler
-    fn get_inline_listener(&mut self, owner: &EventTarget, ty: &Atom) -> Option<CommonEventHandler> {
+    fn get_inline_listener(
+        &mut self,
+        owner: &EventTarget,
+        ty: &Atom,
+    ) -> Option<CommonEventHandler> {
         for entry in &mut self.0 {
             if let EventListenerType::Inline(ref mut inline) = entry.listener {
                 // Step 1.1-1.8 and Step 2
@@ -260,234 +315,323 @@ impl EventListeners {
     }
 
     // https://html.spec.whatwg.org/multipage/#getting-the-current-value-of-the-event-handler
-    fn get_listeners(&mut self, phase: Option<ListenerPhase>, owner: &EventTarget, ty: &Atom)
-                     -> Vec<CompiledEventListener> {
-        self.0.iter_mut().filter_map(|entry| {
-            if phase.is_none() || Some(entry.phase) == phase {
-                // Step 1.1-1.8, 2
-                entry.listener.get_compiled_listener(owner, ty)
-            } else {
-                None
-            }
-        }).collect()
+    fn get_listeners(
+        &mut self,
+        phase: Option<ListenerPhase>,
+        owner: &EventTarget,
+        ty: &Atom,
+    ) -> Vec<CompiledEventListener> {
+        self.0
+            .iter_mut()
+            .filter_map(|entry| {
+                if phase.is_none() || Some(entry.phase) == phase {
+                    // Step 1.1-1.8, 2
+                    entry.listener.get_compiled_listener(owner, ty)
+                } else {
+                    None
+                }
+            })
+            .collect()
+    }
+
+    fn has_listeners(&self) -> bool {
+        // TODO: add, and take into account, a 'removed' field?
+        // https://dom.spec.whatwg.org/#event-listener-removed
+        self.0.len() > 0
     }
 }
 
 #[dom_struct]
 pub struct EventTarget {
     reflector_: Reflector,
-    handlers: DOMRefCell<HashMap<Atom, EventListeners, BuildHasherDefault<FnvHasher>>>,
+    handlers: DomRefCell<HashMap<Atom, EventListeners, BuildHasherDefault<FnvHasher>>>,
 }
 
 impl EventTarget {
     pub fn new_inherited() -> EventTarget {
         EventTarget {
             reflector_: Reflector::new(),
-            handlers: DOMRefCell::new(Default::default()),
+            handlers: DomRefCell::new(Default::default()),
         }
     }
 
-    pub fn get_listeners_for(&self,
-                             type_: &Atom,
-                             specific_phase: Option<ListenerPhase>)
-                             -> Vec<CompiledEventListener> {
-        self.handlers.borrow_mut().get_mut(type_).map_or(vec![], |listeners| {
-            listeners.get_listeners(specific_phase, self, type_)
-        })
+    fn new(global: &GlobalScope) -> DomRoot<EventTarget> {
+        reflect_dom_object(Box::new(EventTarget::new_inherited()), global)
     }
 
-    pub fn dispatch_event_with_target(&self,
-                                      target: &EventTarget,
-                                      event: &Event) -> EventStatus {
-        event.dispatch(self, Some(target))
+    #[allow(non_snake_case)]
+    pub fn Constructor(global: &GlobalScope) -> Fallible<DomRoot<EventTarget>> {
+        Ok(EventTarget::new(global))
+    }
+
+    pub fn has_listeners_for(&self, type_: &Atom) -> bool {
+        match self.handlers.borrow().get(type_) {
+            Some(listeners) => listeners.has_listeners(),
+            None => false,
+        }
+    }
+
+    pub fn get_listeners_for(
+        &self,
+        type_: &Atom,
+        specific_phase: Option<ListenerPhase>,
+    ) -> Vec<CompiledEventListener> {
+        self.handlers
+            .borrow_mut()
+            .get_mut(type_)
+            .map_or(vec![], |listeners| {
+                listeners.get_listeners(specific_phase, self, type_)
+            })
     }
 
     pub fn dispatch_event(&self, event: &Event) -> EventStatus {
-        event.dispatch(self, None)
+        if let Some(window) = self.global().downcast::<Window>() {
+            if window.has_document() {
+                assert!(window.Document().can_invoke_script());
+            }
+        };
+        event.dispatch(self, false)
     }
 
     pub fn remove_all_listeners(&self) {
         *self.handlers.borrow_mut() = Default::default();
     }
 
-    /// https://html.spec.whatwg.org/multipage/#event-handler-attributes:event-handlers-11
-    fn set_inline_event_listener(&self,
-                                 ty: Atom,
-                                 listener: Option<InlineEventListener>) {
+    /// <https://html.spec.whatwg.org/multipage/#event-handler-attributes:event-handlers-11>
+    fn set_inline_event_listener(&self, ty: Atom, listener: Option<InlineEventListener>) {
         let mut handlers = self.handlers.borrow_mut();
         let entries = match handlers.entry(ty) {
             Occupied(entry) => entry.into_mut(),
-            Vacant(entry) => entry.insert(EventListeners(vec!())),
+            Vacant(entry) => entry.insert(EventListeners(vec![])),
         };
 
-        let idx = entries.iter().position(|ref entry| {
-            match entry.listener {
-                EventListenerType::Inline(_) => true,
-                _ => false,
-            }
+        let idx = entries.iter().position(|ref entry| match entry.listener {
+            EventListenerType::Inline(_) => true,
+            _ => false,
         });
 
         match idx {
-            Some(idx) => {
-                entries[idx].listener =
-                    EventListenerType::Inline(listener.unwrap_or(InlineEventListener::Null));
-            }
+            Some(idx) => match listener {
+                // Replace if there's something to replace with,
+                // but remove entirely if there isn't.
+                Some(listener) => {
+                    entries[idx].listener = EventListenerType::Inline(listener);
+                },
+                None => {
+                    entries.remove(idx);
+                },
+            },
             None => {
                 if let Some(listener) = listener {
                     entries.push(EventListenerEntry {
                         phase: ListenerPhase::Bubbling,
                         listener: EventListenerType::Inline(listener),
+                        once: false,
                     });
                 }
-            }
+            },
+        }
+    }
+
+    pub fn remove_listener_if_once(&self, ty: &Atom, listener: &Rc<EventListener>) {
+        let mut handlers = self.handlers.borrow_mut();
+
+        let listener = EventListenerType::Additive(listener.clone());
+        for entries in handlers.get_mut(ty) {
+            entries.drain_filter(|e| e.listener == listener && e.once);
         }
     }
 
     fn get_inline_event_listener(&self, ty: &Atom) -> Option<CommonEventHandler> {
         let mut handlers = self.handlers.borrow_mut();
-        handlers.get_mut(ty).and_then(|entry| entry.get_inline_listener(self, ty))
+        handlers
+            .get_mut(ty)
+            .and_then(|entry| entry.get_inline_listener(self, ty))
     }
 
     /// Store the raw uncompiled event handler for on-demand compilation later.
-    /// https://html.spec.whatwg.org/multipage/#event-handler-attributes:event-handler-content-attributes-3
-    pub fn set_event_handler_uncompiled(&self,
-                                        url: ServoUrl,
-                                        line: usize,
-                                        ty: &str,
-                                        source: DOMString) {
+    /// <https://html.spec.whatwg.org/multipage/#event-handler-attributes:event-handler-content-attributes-3>
+    pub fn set_event_handler_uncompiled(
+        &self,
+        url: ServoUrl,
+        line: usize,
+        ty: &str,
+        source: DOMString,
+    ) {
         let handler = InternalRawUncompiledHandler {
             source: source,
             line: line,
             url: url,
         };
-        self.set_inline_event_listener(Atom::from(ty),
-                                       Some(InlineEventListener::Uncompiled(handler)));
+        self.set_inline_event_listener(
+            Atom::from(ty),
+            Some(InlineEventListener::Uncompiled(handler)),
+        );
     }
 
     // https://html.spec.whatwg.org/multipage/#getting-the-current-value-of-the-event-handler
+    // step 3
     #[allow(unsafe_code)]
-    fn get_compiled_event_handler(&self,
-                                  handler: InternalRawUncompiledHandler,
-                                  ty: &Atom)
-                                  -> Option<CommonEventHandler> {
-        // Step 1.1
+    fn get_compiled_event_handler(
+        &self,
+        handler: InternalRawUncompiledHandler,
+        ty: &Atom,
+    ) -> Option<CommonEventHandler> {
+        // Step 3.1
         let element = self.downcast::<Element>();
         let document = match element {
             Some(element) => document_from_node(element),
             None => self.downcast::<Window>().unwrap().Document(),
         };
 
-        // Step 1.2
+        // Step 3.2
         if !document.is_scripting_enabled() {
             return None;
         }
 
-        // Step 1.3
+        // Step 3.3
         let body: Vec<u16> = handler.source.encode_utf16().collect();
 
-        // TODO step 1.5 (form owner)
+        // Step 3.4 is handler.line
+
+        // Step 3.5
+        let form_owner = element
+            .and_then(|e| e.as_maybe_form_control())
+            .and_then(|f| f.form_owner());
 
-        // Step 1.6
+        // Step 3.6 TODO: settings objects not implemented
+
+        // Step 3.7 is written as though we call the parser separately
+        // from the compiler; since we just call CompileFunction with
+        // source text, we handle parse errors later
+
+        // Step 3.8 TODO: settings objects not implemented
         let window = document.window();
+        let _ac = enter_realm(&*window);
+
+        // Step 3.9
 
-        let url_serialized = CString::new(handler.url.to_string()).unwrap();
-        let name = CString::new(&**ty).unwrap();
+        let name = CString::new(format!("on{}", &**ty)).unwrap();
 
-        static mut ARG_NAMES: [*const c_char; 1] = [b"event\0" as *const u8 as *const c_char];
-        static mut ERROR_ARG_NAMES: [*const c_char; 5] = [b"event\0" as *const u8 as *const c_char,
-                                                          b"source\0" as *const u8 as *const c_char,
-                                                          b"lineno\0" as *const u8 as *const c_char,
-                                                          b"colno\0" as *const u8 as *const c_char,
-                                                          b"error\0" as *const u8 as *const c_char];
-        // step 10
+        // Step 3.9, subsection ParameterList
+        const ARG_NAMES: &[*const c_char] = &[b"event\0" as *const u8 as *const c_char];
+        const ERROR_ARG_NAMES: &[*const c_char] = &[
+            b"event\0" as *const u8 as *const c_char,
+            b"source\0" as *const u8 as *const c_char,
+            b"lineno\0" as *const u8 as *const c_char,
+            b"colno\0" as *const u8 as *const c_char,
+            b"error\0" as *const u8 as *const c_char,
+        ];
         let is_error = ty == &atom!("error") && self.is::<Window>();
-        let args = unsafe {
-            if is_error {
-                &ERROR_ARG_NAMES[..]
-            } else {
-                &ARG_NAMES[..]
-            }
-        };
+        let args = if is_error { ERROR_ARG_NAMES } else { ARG_NAMES };
 
         let cx = window.get_cx();
-        let options = CompileOptionsWrapper::new(cx, url_serialized.as_ptr(), handler.line as u32);
-        // TODO step 1.10.1-3 (document, form owner, element in scope chain)
-
-        let scopechain = AutoObjectVectorWrapper::new(cx);
-
-        let _ac = JSAutoCompartment::new(cx, window.reflector().get_jsobject().get());
-        rooted!(in(cx) let mut handler = ptr::null_mut());
-        let rv = unsafe {
-            CompileFunction(cx,
-                            scopechain.ptr,
-                            options.ptr,
-                            name.as_ptr(),
-                            args.len() as u32,
-                            args.as_ptr(),
-                            body.as_ptr(),
-                            body.len() as size_t,
-                            handler.handle_mut())
+        let options = unsafe {
+            CompileOptionsWrapper::new(*cx, &handler.url.to_string(), handler.line as u32)
         };
-        if !rv || handler.get().is_null() {
-            // Step 1.8.2
+
+        // Step 3.9, subsection Scope steps 1-6
+        let scopechain = RootedObjectVectorWrapper::new(*cx);
+
+        if let Some(element) = element {
+            scopechain.append(document.reflector().get_jsobject().get());
+            if let Some(form_owner) = form_owner {
+                scopechain.append(form_owner.reflector().get_jsobject().get());
+            }
+            scopechain.append(element.reflector().get_jsobject().get());
+        }
+
+        rooted!(in(*cx) let mut handler = unsafe {
+            CompileFunction(
+                *cx,
+                scopechain.handle(),
+                options.ptr,
+                name.as_ptr(),
+                args.len() as u32,
+                args.as_ptr(),
+                &mut transform_u16_to_source_text(&body),
+            )
+        });
+        if handler.get().is_null() {
+            // Step 3.7
             unsafe {
-                let _ac = JSAutoCompartment::new(cx, self.reflector().get_jsobject().get());
+                let ar = enter_realm(&*self);
                 // FIXME(#13152): dispatch error event.
-                report_pending_exception(cx, false);
+                report_pending_exception(*cx, false, InRealm::Entered(&ar));
             }
-            // Step 1.8.1 / 1.8.3
             return None;
         }
 
-        // TODO step 1.11-13
+        // Step 3.10 happens when we drop _ac
+
+        // TODO Step 3.11
+
+        // Step 3.12
         let funobj = unsafe { JS_GetFunctionObject(handler.get()) };
         assert!(!funobj.is_null());
         // Step 1.14
         if is_error {
-            Some(CommonEventHandler::ErrorEventHandler(OnErrorEventHandlerNonNull::new(cx, funobj)))
+            Some(CommonEventHandler::ErrorEventHandler(unsafe {
+                OnErrorEventHandlerNonNull::new(cx, funobj)
+            }))
         } else {
             if ty == &atom!("beforeunload") {
-                Some(CommonEventHandler::BeforeUnloadEventHandler(
-                        OnBeforeUnloadEventHandlerNonNull::new(cx, funobj)))
+                Some(CommonEventHandler::BeforeUnloadEventHandler(unsafe {
+                    OnBeforeUnloadEventHandlerNonNull::new(cx, funobj)
+                }))
             } else {
-                Some(CommonEventHandler::EventHandler(EventHandlerNonNull::new(cx, funobj)))
+                Some(CommonEventHandler::EventHandler(unsafe {
+                    EventHandlerNonNull::new(cx, funobj)
+                }))
             }
         }
     }
 
-    pub fn set_event_handler_common<T: CallbackContainer>(
-        &self, ty: &str, listener: Option<Rc<T>>)
+    #[allow(unsafe_code)]
+    pub fn set_event_handler_common<T: CallbackContainer>(&self, ty: &str, listener: Option<Rc<T>>)
+    where
+        T: CallbackContainer,
     {
         let cx = self.global().get_cx();
 
-        let event_listener = listener.map(|listener|
-                                          InlineEventListener::Compiled(
-                                              CommonEventHandler::EventHandler(
-                                                  EventHandlerNonNull::new(cx, listener.callback()))));
+        let event_listener = listener.map(|listener| {
+            InlineEventListener::Compiled(CommonEventHandler::EventHandler(unsafe {
+                EventHandlerNonNull::new(cx, listener.callback())
+            }))
+        });
         self.set_inline_event_listener(Atom::from(ty), event_listener);
     }
 
-    pub fn set_error_event_handler<T: CallbackContainer>(
-        &self, ty: &str, listener: Option<Rc<T>>)
+    #[allow(unsafe_code)]
+    pub fn set_error_event_handler<T: CallbackContainer>(&self, ty: &str, listener: Option<Rc<T>>)
+    where
+        T: CallbackContainer,
     {
         let cx = self.global().get_cx();
 
-        let event_listener = listener.map(|listener|
-                                          InlineEventListener::Compiled(
-                                              CommonEventHandler::ErrorEventHandler(
-                                                  OnErrorEventHandlerNonNull::new(cx, listener.callback()))));
+        let event_listener = listener.map(|listener| {
+            InlineEventListener::Compiled(CommonEventHandler::ErrorEventHandler(unsafe {
+                OnErrorEventHandlerNonNull::new(cx, listener.callback())
+            }))
+        });
         self.set_inline_event_listener(Atom::from(ty), event_listener);
     }
 
-    pub fn set_beforeunload_event_handler<T: CallbackContainer>(&self, ty: &str,
-                                                                listener: Option<Rc<T>>) {
+    #[allow(unsafe_code)]
+    pub fn set_beforeunload_event_handler<T: CallbackContainer>(
+        &self,
+        ty: &str,
+        listener: Option<Rc<T>>,
+    ) where
+        T: CallbackContainer,
+    {
         let cx = self.global().get_cx();
 
-        let event_listener = listener.map(|listener|
-            InlineEventListener::Compiled(
-                CommonEventHandler::BeforeUnloadEventHandler(
-                    OnBeforeUnloadEventHandlerNonNull::new(cx, listener.callback())))
-        );
+        let event_listener = listener.map(|listener| {
+            InlineEventListener::Compiled(CommonEventHandler::BeforeUnloadEventHandler(unsafe {
+                OnBeforeUnloadEventHandlerNonNull::new(cx, listener.callback())
+            }))
+        });
         self.set_inline_event_listener(Atom::from(ty), event_listener);
     }
 
@@ -496,8 +640,9 @@ impl EventTarget {
         let cx = self.global().get_cx();
         let listener = self.get_inline_event_listener(&Atom::from(ty));
         unsafe {
-            listener.map(|listener|
-                         CallbackContainer::new(cx, listener.parent().callback_holder().get()))
+            listener.map(|listener| {
+                CallbackContainer::new(cx, listener.parent().callback_holder().get())
+            })
         }
     }
 
@@ -506,51 +651,51 @@ impl EventTarget {
     }
 
     // https://dom.spec.whatwg.org/#concept-event-fire
-    pub fn fire_event(&self, name: Atom) -> Root<Event> {
-        self.fire_event_with_params(name,
-                                    EventBubbles::DoesNotBubble,
-                                    EventCancelable::NotCancelable)
+    pub fn fire_event(&self, name: Atom) -> DomRoot<Event> {
+        self.fire_event_with_params(
+            name,
+            EventBubbles::DoesNotBubble,
+            EventCancelable::NotCancelable,
+        )
     }
 
     // https://dom.spec.whatwg.org/#concept-event-fire
-    pub fn fire_bubbling_event(&self, name: Atom) -> Root<Event> {
-        self.fire_event_with_params(name,
-                                    EventBubbles::Bubbles,
-                                    EventCancelable::NotCancelable)
+    pub fn fire_bubbling_event(&self, name: Atom) -> DomRoot<Event> {
+        self.fire_event_with_params(name, EventBubbles::Bubbles, EventCancelable::NotCancelable)
     }
 
     // https://dom.spec.whatwg.org/#concept-event-fire
-    pub fn fire_cancelable_event(&self, name: Atom) -> Root<Event> {
-        self.fire_event_with_params(name,
-                                    EventBubbles::DoesNotBubble,
-                                    EventCancelable::Cancelable)
+    pub fn fire_cancelable_event(&self, name: Atom) -> DomRoot<Event> {
+        self.fire_event_with_params(
+            name,
+            EventBubbles::DoesNotBubble,
+            EventCancelable::Cancelable,
+        )
     }
 
     // https://dom.spec.whatwg.org/#concept-event-fire
-    pub fn fire_bubbling_cancelable_event(&self, name: Atom) -> Root<Event> {
-        self.fire_event_with_params(name,
-                                    EventBubbles::Bubbles,
-                                    EventCancelable::Cancelable)
+    pub fn fire_bubbling_cancelable_event(&self, name: Atom) -> DomRoot<Event> {
+        self.fire_event_with_params(name, EventBubbles::Bubbles, EventCancelable::Cancelable)
     }
 
     // https://dom.spec.whatwg.org/#concept-event-fire
-    pub fn fire_event_with_params(&self,
-                                  name: Atom,
-                                  bubbles: EventBubbles,
-                                  cancelable: EventCancelable)
-                                  -> Root<Event> {
+    pub fn fire_event_with_params(
+        &self,
+        name: Atom,
+        bubbles: EventBubbles,
+        cancelable: EventCancelable,
+    ) -> DomRoot<Event> {
         let event = Event::new(&self.global(), name, bubbles, cancelable);
         event.fire(self);
         event
     }
-}
-
-impl EventTargetMethods for EventTarget {
     // https://dom.spec.whatwg.org/#dom-eventtarget-addeventlistener
-    fn AddEventListener(&self,
-                        ty: DOMString,
-                        listener: Option<Rc<EventListener>>,
-                        capture: bool) {
+    pub fn add_event_listener(
+        &self,
+        ty: DOMString,
+        listener: Option<Rc<EventListener>>,
+        options: AddEventListenerOptions,
+    ) {
         let listener = match listener {
             Some(l) => l,
             None => return,
@@ -558,13 +703,18 @@ impl EventTargetMethods for EventTarget {
         let mut handlers = self.handlers.borrow_mut();
         let entry = match handlers.entry(Atom::from(ty)) {
             Occupied(entry) => entry.into_mut(),
-            Vacant(entry) => entry.insert(EventListeners(vec!())),
+            Vacant(entry) => entry.insert(EventListeners(vec![])),
         };
 
-        let phase = if capture { ListenerPhase::Capturing } else { ListenerPhase::Bubbling };
+        let phase = if options.parent.capture {
+            ListenerPhase::Capturing
+        } else {
+            ListenerPhase::Bubbling
+        };
         let new_entry = EventListenerEntry {
             phase: phase,
-            listener: EventListenerType::Additive(listener)
+            listener: EventListenerType::Additive(listener),
+            once: options.once,
         };
         if !entry.contains(&new_entry) {
             entry.push(new_entry);
@@ -572,10 +722,12 @@ impl EventTargetMethods for EventTarget {
     }
 
     // https://dom.spec.whatwg.org/#dom-eventtarget-removeeventlistener
-    fn RemoveEventListener(&self,
-                           ty: DOMString,
-                           listener: Option<Rc<EventListener>>,
-                           capture: bool) {
+    pub fn remove_event_listener(
+        &self,
+        ty: DOMString,
+        listener: Option<Rc<EventListener>>,
+        options: EventListenerOptions,
+    ) {
         let ref listener = match listener {
             Some(l) => l,
             None => return,
@@ -583,16 +735,43 @@ impl EventTargetMethods for EventTarget {
         let mut handlers = self.handlers.borrow_mut();
         let entry = handlers.get_mut(&Atom::from(ty));
         for entry in entry {
-            let phase = if capture { ListenerPhase::Capturing } else { ListenerPhase::Bubbling };
+            let phase = if options.capture {
+                ListenerPhase::Capturing
+            } else {
+                ListenerPhase::Bubbling
+            };
             let old_entry = EventListenerEntry {
                 phase: phase,
-                listener: EventListenerType::Additive(listener.clone())
+                listener: EventListenerType::Additive(listener.clone()),
+                once: false,
             };
             if let Some(position) = entry.iter().position(|e| *e == old_entry) {
                 entry.remove(position);
             }
         }
     }
+}
+
+impl EventTargetMethods for EventTarget {
+    // https://dom.spec.whatwg.org/#dom-eventtarget-addeventlistener
+    fn AddEventListener(
+        &self,
+        ty: DOMString,
+        listener: Option<Rc<EventListener>>,
+        options: AddEventListenerOptionsOrBoolean,
+    ) {
+        self.add_event_listener(ty, listener, options.into())
+    }
+
+    // https://dom.spec.whatwg.org/#dom-eventtarget-removeeventlistener
+    fn RemoveEventListener(
+        &self,
+        ty: DOMString,
+        listener: Option<Rc<EventListener>>,
+        options: EventListenerOptionsOrBoolean,
+    ) {
+        self.remove_event_listener(ty, listener, options.into())
+    }
 
     // https://dom.spec.whatwg.org/#dom-eventtarget-dispatchevent
     fn DispatchEvent(&self, event: &Event) -> Fallible<bool> {
@@ -602,13 +781,34 @@ impl EventTargetMethods for EventTarget {
         event.set_trusted(false);
         Ok(match self.dispatch_event(event) {
             EventStatus::Canceled => false,
-            EventStatus::NotCanceled => true
+            EventStatus::NotCanceled => true,
         })
     }
 }
 
 impl VirtualMethods for EventTarget {
-    fn super_type(&self) -> Option<&VirtualMethods> {
+    fn super_type(&self) -> Option<&dyn VirtualMethods> {
         None
     }
 }
+
+impl From<AddEventListenerOptionsOrBoolean> for AddEventListenerOptions {
+    fn from(options: AddEventListenerOptionsOrBoolean) -> Self {
+        match options {
+            AddEventListenerOptionsOrBoolean::AddEventListenerOptions(options) => options,
+            AddEventListenerOptionsOrBoolean::Boolean(capture) => Self {
+                parent: EventListenerOptions { capture },
+                once: false,
+            },
+        }
+    }
+}
+
+impl From<EventListenerOptionsOrBoolean> for EventListenerOptions {
+    fn from(options: EventListenerOptionsOrBoolean) -> Self {
+        match options {
+            EventListenerOptionsOrBoolean::EventListenerOptions(options) => options,
+            EventListenerOptionsOrBoolean::Boolean(capture) => Self { capture },
+        }
+    }
+}