Use internal mutability for EventTarget.

8 files changed, 111 insertions, 96 deletions

diff --git a/src/components/script/dom/document.rs b/src/components/script/dom/document.rs
index 3a0fa2e7f3b..1830936e6bd 100644
--- a/src/components/script/dom/document.rs
+++ b/src/components/script/dom/document.rs
@@ -331,9 +331,9 @@ pub trait DocumentMethods {
     fn Children(&self) -> Temporary<HTMLCollection>;
     fn QuerySelector(&self, selectors: DOMString) -> Fallible<Option<Temporary<Element>>>;
     fn GetOnclick(&self) -> Option<EventHandlerNonNull>;
-    fn SetOnclick(&mut self, listener: Option<EventHandlerNonNull>);
+    fn SetOnclick(&self, listener: Option<EventHandlerNonNull>);
     fn GetOnload(&self) -> Option<EventHandlerNonNull>;
-    fn SetOnload(&mut self, listener: Option<EventHandlerNonNull>);
+    fn SetOnload(&self, listener: Option<EventHandlerNonNull>);
 }
 
 impl<'a> DocumentMethods for JSRef<'a, Document> {
@@ -826,8 +826,8 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
         eventtarget.get_event_handler_common("click")
     }
 
-    fn SetOnclick(&mut self, listener: Option<EventHandlerNonNull>) {
-        let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self);
+    fn SetOnclick(&self, listener: Option<EventHandlerNonNull>) {
+        let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
         eventtarget.set_event_handler_common("click", listener)
     }
 
@@ -836,8 +836,8 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
         eventtarget.get_event_handler_common("load")
     }
 
-    fn SetOnload(&mut self, listener: Option<EventHandlerNonNull>) {
-        let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self);
+    fn SetOnload(&self, listener: Option<EventHandlerNonNull>) {
+        let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
         eventtarget.set_event_handler_common("load", listener)
     }
 }
diff --git a/src/components/script/dom/eventtarget.rs b/src/components/script/dom/eventtarget.rs
index 185913be1dd..7a192d58ab6 100644
--- a/src/components/script/dom/eventtarget.rs
+++ b/src/components/script/dom/eventtarget.rs
@@ -7,6 +7,7 @@ use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
 use dom::bindings::codegen::Bindings::EventListenerBinding::EventListener;
 use dom::bindings::error::{Fallible, InvalidState};
 use dom::bindings::js::JSRef;
+use dom::bindings::trace::Traceable;
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::event::Event;
 use dom::eventdispatcher::dispatch_event;
@@ -17,6 +18,7 @@ use js::jsapi::{JS_CompileUCFunction, JS_GetFunctionObject, JS_CloneFunctionObje
 use js::jsapi::{JSContext, JSObject};
 use servo_util::str::DOMString;
 use libc::{c_char, size_t};
+use std::cell::RefCell;
 use std::ptr;
 use url::Url;
 
@@ -59,7 +61,7 @@ pub struct EventListenerEntry {
 pub struct EventTarget {
     pub type_id: EventTargetTypeId,
     pub reflector_: Reflector,
-    pub handlers: HashMap<DOMString, Vec<EventListenerEntry>>,
+    handlers: Traceable<RefCell<HashMap<DOMString, Vec<EventListenerEntry>>>>,
 }
 
 impl EventTarget {
@@ -67,19 +69,19 @@ impl EventTarget {
         EventTarget {
             type_id: type_id,
             reflector_: Reflector::new(),
-            handlers: HashMap::new(),
+            handlers: Traceable::new(RefCell::new(HashMap::new())),
         }
     }
 
     pub fn get_listeners(&self, type_: &str) -> Option<Vec<EventListener>> {
-        self.handlers.find_equiv(&type_).map(|listeners| {
+        self.handlers.deref().borrow().find_equiv(&type_).map(|listeners| {
             listeners.iter().map(|entry| entry.listener.get_listener()).collect()
         })
     }
 
     pub fn get_listeners_for(&self, type_: &str, desired_phase: ListenerPhase)
         -> Option<Vec<EventListener>> {
-        self.handlers.find_equiv(&type_).map(|listeners| {
+        self.handlers.deref().borrow().find_equiv(&type_).map(|listeners| {
             let filtered = listeners.iter().filter(|entry| entry.phase == desired_phase);
             filtered.map(|entry| entry.listener.get_listener()).collect()
         })
@@ -90,19 +92,21 @@ pub trait EventTargetHelpers {
     fn dispatch_event_with_target<'a>(&self,
                                       target: Option<JSRef<'a, EventTarget>>,
                                       event: &JSRef<Event>) -> Fallible<bool>;
-    fn set_inline_event_listener(&mut self,
+    fn set_inline_event_listener(&self,
                                  ty: DOMString,
                                  listener: Option<EventListener>);
     fn get_inline_event_listener(&self, ty: DOMString) -> Option<EventListener>;
-    fn set_event_handler_uncompiled(&mut self,
+    fn set_event_handler_uncompiled(&self,
                                     cx: *mut JSContext,
                                     url: Url,
                                     scope: *mut JSObject,
                                     ty: &str,
                                     source: DOMString);
-    fn set_event_handler_common<T: CallbackContainer>(&mut self, ty: &str,
+    fn set_event_handler_common<T: CallbackContainer>(&self, ty: &str,
                                                       listener: Option<T>);
     fn get_event_handler_common<T: CallbackContainer>(&self, ty: &str) -> Option<T>;
+
+    fn has_handlers(&self) -> bool;
 }
 
 impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
@@ -115,10 +119,11 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
         Ok(dispatch_event(self, target, event))
     }
 
-    fn set_inline_event_listener(&mut self,
+    fn set_inline_event_listener(&self,
                                  ty: DOMString,
                                  listener: Option<EventListener>) {
-        let entries = self.handlers.find_or_insert_with(ty, |_| vec!());
+        let mut handlers = self.handlers.deref().borrow_mut();
+        let entries = handlers.find_or_insert_with(ty, |_| vec!());
         let idx = entries.iter().position(|&entry| {
             match entry.listener {
                 Inline(_) => true,
@@ -147,7 +152,8 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
     }
 
     fn get_inline_event_listener(&self, ty: DOMString) -> Option<EventListener> {
-        let entries = self.handlers.find(&ty);
+        let handlers = self.handlers.deref().borrow();
+        let entries = handlers.find(&ty);
         entries.and_then(|entries| entries.iter().find(|entry| {
             match entry.listener {
                 Inline(_) => true,
@@ -156,7 +162,7 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
         }).map(|entry| entry.listener.get_listener()))
     }
 
-    fn set_event_handler_uncompiled(&mut self,
+    fn set_event_handler_uncompiled(&self,
                                     cx: *mut JSContext,
                                     url: Url,
                                     scope: *mut JSObject,
@@ -188,7 +194,7 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
     }
 
     fn set_event_handler_common<T: CallbackContainer>(
-        &mut self, ty: &str, listener: Option<T>)
+        &self, ty: &str, listener: Option<T>)
     {
         let event_listener = listener.map(|listener|
                                           EventListener::new(listener.callback()));
@@ -199,14 +205,18 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
         let listener = self.get_inline_event_listener(ty.to_string());
         listener.map(|listener| CallbackContainer::new(listener.parent.callback()))
     }
+
+    fn has_handlers(&self) -> bool {
+        !self.handlers.deref().borrow().is_empty()
+    }
 }
 
 pub trait EventTargetMethods {
-    fn AddEventListener(&mut self,
+    fn AddEventListener(&self,
                         ty: DOMString,
                         listener: Option<EventListener>,
                         capture: bool);
-    fn RemoveEventListener(&mut self,
+    fn RemoveEventListener(&self,
                            ty: DOMString,
                            listener: Option<EventListener>,
                            capture: bool);
@@ -214,40 +224,48 @@ pub trait EventTargetMethods {
 }
 
 impl<'a> EventTargetMethods for JSRef<'a, EventTarget> {
-    fn AddEventListener(&mut self,
+    fn AddEventListener(&self,
                         ty: DOMString,
                         listener: Option<EventListener>,
                         capture: bool) {
-        for &listener in listener.iter() {
-            let entry = self.handlers.find_or_insert_with(ty.clone(), |_| vec!());
-            let phase = if capture { Capturing } else { Bubbling };
-            let new_entry = EventListenerEntry {
-                phase: phase,
-                listener: Additive(listener)
-            };
-            if entry.as_slice().position_elem(&new_entry).is_none() {
-                entry.push(new_entry);
-            }
+        match listener {
+            Some(listener) => {
+                let mut handlers = self.handlers.deref().borrow_mut();
+                let entry = handlers.find_or_insert_with(ty, |_| vec!());
+                let phase = if capture { Capturing } else { Bubbling };
+                let new_entry = EventListenerEntry {
+                    phase: phase,
+                    listener: Additive(listener)
+                };
+                if entry.as_slice().position_elem(&new_entry).is_none() {
+                    entry.push(new_entry);
+                }
+            },
+            _ => (),
         }
     }
 
-    fn RemoveEventListener(&mut self,
+    fn RemoveEventListener(&self,
                            ty: DOMString,
                            listener: Option<EventListener>,
                            capture: bool) {
-        for &listener in listener.iter() {
-            let mut entry = self.handlers.find_mut(&ty);
-            for entry in entry.mut_iter() {
-                let phase = if capture { Capturing } else { Bubbling };
-                let old_entry = EventListenerEntry {
-                    phase: phase,
-                    listener: Additive(listener)
-                };
-                let position = entry.as_slice().position_elem(&old_entry);
-                for &position in position.iter() {
-                    entry.remove(position);
+        match listener {
+            Some(listener) => {
+                let mut handlers = self.handlers.deref().borrow_mut();
+                let mut entry = handlers.find_mut(&ty);
+                for entry in entry.mut_iter() {
+                    let phase = if capture { Capturing } else { Bubbling };
+                    let old_entry = EventListenerEntry {
+                        phase: phase,
+                        listener: Additive(listener)
+                    };
+                    let position = entry.as_slice().position_elem(&old_entry);
+                    for &position in position.iter() {
+                        entry.remove(position);
+                    }
                 }
-            }
+            },
+            _ => (),
         }
     }
 
diff --git a/src/components/script/dom/htmlbodyelement.rs b/src/components/script/dom/htmlbodyelement.rs
index e94f15a8d47..6e82d78fa50 100644
--- a/src/components/script/dom/htmlbodyelement.rs
+++ b/src/components/script/dom/htmlbodyelement.rs
@@ -80,12 +80,11 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLBodyElement> {
             let (cx, url, reflector) = (window.get_cx(),
                                         window.get_url(),
                                         window.reflector().get_jsobject());
-            let mut self_alias = self.clone();
-            let evtarget: &mut JSRef<EventTarget> =
+            let evtarget: &JSRef<EventTarget> =
                 if forwarded_events.iter().any(|&event| name.as_slice() == event) {
-                    EventTargetCast::from_mut_ref(&mut *window)
+                    EventTargetCast::from_ref(&*window)
                 } else {
-                    EventTargetCast::from_mut_ref(&mut self_alias)
+                    EventTargetCast::from_ref(self)
                 };
             evtarget.set_event_handler_uncompiled(cx, url, reflector,
                                                   name.as_slice().slice_from(2),
diff --git a/src/components/script/dom/htmlelement.rs b/src/components/script/dom/htmlelement.rs
index 29ac184987b..5168b822669 100644
--- a/src/components/script/dom/htmlelement.rs
+++ b/src/components/script/dom/htmlelement.rs
@@ -59,9 +59,9 @@ impl<'a> PrivateHTMLElementHelpers for JSRef<'a, HTMLElement> {
 
 pub trait HTMLElementMethods {
     fn GetOnclick(&self) -> Option<EventHandlerNonNull>;
-    fn SetOnclick(&mut self, listener: Option<EventHandlerNonNull>);
+    fn SetOnclick(&self, listener: Option<EventHandlerNonNull>);
     fn GetOnload(&self) -> Option<EventHandlerNonNull>;
-    fn SetOnload(&mut self, listener: Option<EventHandlerNonNull>);
+    fn SetOnload(&self, listener: Option<EventHandlerNonNull>);
 }
 
 impl<'a> HTMLElementMethods for JSRef<'a, HTMLElement> {
@@ -70,8 +70,8 @@ impl<'a> HTMLElementMethods for JSRef<'a, HTMLElement> {
         eventtarget.get_event_handler_common("click")
     }
 
-    fn SetOnclick(&mut self, listener: Option<EventHandlerNonNull>) {
-        let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self);
+    fn SetOnclick(&self, listener: Option<EventHandlerNonNull>) {
+        let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
         eventtarget.set_event_handler_common("click", listener)
     }
 
@@ -84,10 +84,10 @@ impl<'a> HTMLElementMethods for JSRef<'a, HTMLElement> {
         }
     }
 
-    fn SetOnload(&mut self, listener: Option<EventHandlerNonNull>) {
+    fn SetOnload(&self, listener: Option<EventHandlerNonNull>) {
         if self.is_body_or_frameset() {
-            let mut win = window_from_node(self).root();
-            win.SetOnload(listener)
+            let win = window_from_node(self).root();
+            win.deref().SetOnload(listener)
         }
     }
 }
@@ -109,9 +109,7 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLElement> {
             let (cx, url, reflector) = (window.get_cx(),
                                         window.get_url(),
                                         window.reflector().get_jsobject());
-            let mut self_alias = self.clone();
-            let evtarget: &mut JSRef<EventTarget> =
-                EventTargetCast::from_mut_ref(&mut self_alias);
+            let evtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
             evtarget.set_event_handler_uncompiled(cx, url, reflector,
                                                   name.as_slice().slice_from(2),
                                                   value);
diff --git a/src/components/script/dom/window.rs b/src/components/script/dom/window.rs
index 16e3f39dbba..098d118d3aa 100644
--- a/src/components/script/dom/window.rs
+++ b/src/components/script/dom/window.rs
@@ -130,13 +130,13 @@ pub trait WindowMethods {
     fn Self(&self) -> Temporary<Window>;
     fn Performance(&self) -> Temporary<Performance>;
     fn GetOnclick(&self) -> Option<EventHandlerNonNull>;
-    fn SetOnclick(&mut self, listener: Option<EventHandlerNonNull>);
+    fn SetOnclick(&self, listener: Option<EventHandlerNonNull>);
     fn GetOnload(&self) -> Option<EventHandlerNonNull>;
-    fn SetOnload(&mut self, listener: Option<EventHandlerNonNull>);
+    fn SetOnload(&self, listener: Option<EventHandlerNonNull>);
     fn GetOnunload(&self) -> Option<EventHandlerNonNull>;
-    fn SetOnunload(&mut self, listener: Option<EventHandlerNonNull>);
+    fn SetOnunload(&self, listener: Option<EventHandlerNonNull>);
     fn GetOnerror(&self) -> Option<OnErrorEventHandlerNonNull>;
-    fn SetOnerror(&mut self, listener: Option<OnErrorEventHandlerNonNull>);
+    fn SetOnerror(&self, listener: Option<OnErrorEventHandlerNonNull>);
     fn Debug(&self, message: DOMString);
     fn Gc(&self);
 }
@@ -224,8 +224,8 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
         eventtarget.get_event_handler_common("click")
     }
 
-    fn SetOnclick(&mut self, listener: Option<EventHandlerNonNull>) {
-        let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self);
+    fn SetOnclick(&self, listener: Option<EventHandlerNonNull>) {
+        let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
         eventtarget.set_event_handler_common("click", listener)
     }
 
@@ -234,8 +234,8 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
         eventtarget.get_event_handler_common("load")
     }
 
-    fn SetOnload(&mut self, listener: Option<EventHandlerNonNull>) {
-        let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self);
+    fn SetOnload(&self, listener: Option<EventHandlerNonNull>) {
+        let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
         eventtarget.set_event_handler_common("load", listener)
     }
 
@@ -244,8 +244,8 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
         eventtarget.get_event_handler_common("unload")
     }
 
-    fn SetOnunload(&mut self, listener: Option<EventHandlerNonNull>) {
-        let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self);
+    fn SetOnunload(&self, listener: Option<EventHandlerNonNull>) {
+        let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
         eventtarget.set_event_handler_common("unload", listener)
     }
 
@@ -254,8 +254,8 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
         eventtarget.get_event_handler_common("error")
     }
 
-    fn SetOnerror(&mut self, listener: Option<OnErrorEventHandlerNonNull>) {
-        let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self);
+    fn SetOnerror(&self, listener: Option<OnErrorEventHandlerNonNull>) {
+        let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
         eventtarget.set_event_handler_common("error", listener)
     }
 
diff --git a/src/components/script/dom/xmlhttprequest.rs b/src/components/script/dom/xmlhttprequest.rs
index e780e03ae77..f3d76acca39 100644
--- a/src/components/script/dom/xmlhttprequest.rs
+++ b/src/components/script/dom/xmlhttprequest.rs
@@ -225,7 +225,7 @@ impl XMLHttpRequest {
 
 pub trait XMLHttpRequestMethods<'a> {
     fn GetOnreadystatechange(&self) -> Option<EventHandlerNonNull>;
-    fn SetOnreadystatechange(&mut self, listener: Option<EventHandlerNonNull>);
+    fn SetOnreadystatechange(&self, listener: Option<EventHandlerNonNull>);
     fn ReadyState(&self) -> u16;
     fn Open(&mut self, _method: ByteString, _url: DOMString) -> ErrorResult;
     fn Open_(&mut self, _method: ByteString, _url: DOMString, _async: bool,
@@ -257,8 +257,8 @@ impl<'a> XMLHttpRequestMethods<'a> for JSRef<'a, XMLHttpRequest> {
         eventtarget.get_event_handler_common("readystatechange")
     }
 
-    fn SetOnreadystatechange(&mut self, listener: Option<EventHandlerNonNull>) {
-        let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self);
+    fn SetOnreadystatechange(&self, listener: Option<EventHandlerNonNull>) {
+        let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
         eventtarget.set_event_handler_common("readystatechange", listener)
     }
 
@@ -431,7 +431,7 @@ impl<'a> XMLHttpRequestMethods<'a> for JSRef<'a, XMLHttpRequest> {
             // Step 8
             let upload_target = &*self.upload.get().root().unwrap();
             let event_target: &JSRef<EventTarget> = EventTargetCast::from_ref(upload_target);
-            if  event_target.handlers.iter().len() > 0 {
+            if event_target.has_handlers() {
                 self.upload_events = true;
             }
 
diff --git a/src/components/script/dom/xmlhttprequesteventtarget.rs b/src/components/script/dom/xmlhttprequesteventtarget.rs
index d64c2af8690..29f77c62149 100644
--- a/src/components/script/dom/xmlhttprequesteventtarget.rs
+++ b/src/components/script/dom/xmlhttprequesteventtarget.rs
@@ -44,19 +44,19 @@ impl Reflectable for XMLHttpRequestEventTarget {
 
 pub trait XMLHttpRequestEventTargetMethods {
     fn GetOnloadstart(&self) -> Option<EventHandlerNonNull>;
-    fn SetOnloadstart(&mut self, listener: Option<EventHandlerNonNull>);
+    fn SetOnloadstart(&self, listener: Option<EventHandlerNonNull>);
     fn GetOnprogress(&self) -> Option<EventHandlerNonNull>;
-    fn SetOnprogress(&mut self, listener: Option<EventHandlerNonNull>);
+    fn SetOnprogress(&self, listener: Option<EventHandlerNonNull>);
     fn GetOnabort(&self) -> Option<EventHandlerNonNull>;
-    fn SetOnabort(&mut self, listener: Option<EventHandlerNonNull>);
+    fn SetOnabort(&self, listener: Option<EventHandlerNonNull>);
     fn GetOnerror(&self) -> Option<EventHandlerNonNull>;
-    fn SetOnerror(&mut self, listener: Option<EventHandlerNonNull>);
+    fn SetOnerror(&self, listener: Option<EventHandlerNonNull>);
     fn GetOnload(&self) -> Option<EventHandlerNonNull>;
-    fn SetOnload(&mut self, listener: Option<EventHandlerNonNull>);
+    fn SetOnload(&self, listener: Option<EventHandlerNonNull>);
     fn GetOntimeout(&self) -> Option<EventHandlerNonNull>;
-    fn SetOntimeout(&mut self, listener: Option<EventHandlerNonNull>);
+    fn SetOntimeout(&self, listener: Option<EventHandlerNonNull>);
     fn GetOnloadend(&self) -> Option<EventHandlerNonNull>;
-    fn SetOnloadend(&mut self, listener: Option<EventHandlerNonNull>);
+    fn SetOnloadend(&self, listener: Option<EventHandlerNonNull>);
 }
 
 impl<'a> XMLHttpRequestEventTargetMethods for JSRef<'a, XMLHttpRequestEventTarget> {
@@ -65,8 +65,8 @@ impl<'a> XMLHttpRequestEventTargetMethods for JSRef<'a, XMLHttpRequestEventTarge
         eventtarget.get_event_handler_common("loadstart")
     }
 
-    fn SetOnloadstart(&mut self, listener: Option<EventHandlerNonNull>) {
-        let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self);
+    fn SetOnloadstart(&self, listener: Option<EventHandlerNonNull>) {
+        let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
         eventtarget.set_event_handler_common("loadstart", listener)
     }
 
@@ -75,8 +75,8 @@ impl<'a> XMLHttpRequestEventTargetMethods for JSRef<'a, XMLHttpRequestEventTarge
         eventtarget.get_event_handler_common("progress")
     }
 
-    fn SetOnprogress(&mut self, listener: Option<EventHandlerNonNull>) {
-        let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self);
+    fn SetOnprogress(&self, listener: Option<EventHandlerNonNull>) {
+        let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
         eventtarget.set_event_handler_common("progress", listener)
     }
 
@@ -85,8 +85,8 @@ impl<'a> XMLHttpRequestEventTargetMethods for JSRef<'a, XMLHttpRequestEventTarge
         eventtarget.get_event_handler_common("abort")
     }
 
-    fn SetOnabort(&mut self, listener: Option<EventHandlerNonNull>) {
-        let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self);
+    fn SetOnabort(&self, listener: Option<EventHandlerNonNull>) {
+        let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
         eventtarget.set_event_handler_common("abort", listener)
     }
 
@@ -95,8 +95,8 @@ impl<'a> XMLHttpRequestEventTargetMethods for JSRef<'a, XMLHttpRequestEventTarge
         eventtarget.get_event_handler_common("error")
     }
 
-    fn SetOnerror(&mut self, listener: Option<EventHandlerNonNull>) {
-        let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self);
+    fn SetOnerror(&self, listener: Option<EventHandlerNonNull>) {
+        let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
         eventtarget.set_event_handler_common("error", listener)
     }
 
@@ -105,8 +105,8 @@ impl<'a> XMLHttpRequestEventTargetMethods for JSRef<'a, XMLHttpRequestEventTarge
         eventtarget.get_event_handler_common("load")
     }
 
-    fn SetOnload(&mut self, listener: Option<EventHandlerNonNull>) {
-        let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self);
+    fn SetOnload(&self, listener: Option<EventHandlerNonNull>) {
+        let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
         eventtarget.set_event_handler_common("load", listener)
     }
 
@@ -115,8 +115,8 @@ impl<'a> XMLHttpRequestEventTargetMethods for JSRef<'a, XMLHttpRequestEventTarge
         eventtarget.get_event_handler_common("timeout")
     }
 
-    fn SetOntimeout(&mut self, listener: Option<EventHandlerNonNull>) {
-        let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self);
+    fn SetOntimeout(&self, listener: Option<EventHandlerNonNull>) {
+        let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
         eventtarget.set_event_handler_common("timeout", listener)
     }
 
@@ -125,8 +125,8 @@ impl<'a> XMLHttpRequestEventTargetMethods for JSRef<'a, XMLHttpRequestEventTarge
         eventtarget.get_event_handler_common("loadend")
     }
 
-    fn SetOnloadend(&mut self, listener: Option<EventHandlerNonNull>) {
-        let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self);
+    fn SetOnloadend(&self, listener: Option<EventHandlerNonNull>) {
+        let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
         eventtarget.set_event_handler_common("loadend", listener)
     }
 }
diff --git a/src/components/script/script_task.rs b/src/components/script/script_task.rs
index df1a0a3bd96..73ad372b4d4 100644
--- a/src/components/script/script_task.rs
+++ b/src/components/script/script_task.rs
@@ -1094,7 +1094,7 @@ impl ScriptTask {
                                                    0i32).root();
                         let event: &JSRef<Event> = EventCast::from_ref(&*uievent);
 
-                        let wintarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(&mut *window);
+                        let wintarget: &JSRef<EventTarget> = EventTargetCast::from_ref(&*window);
                         let _ = wintarget.dispatch_event_with_target(None, event);
                     }
                     None => ()