1 files changed, 44 insertions, 24 deletions

diff --git a/src/components/script/dom/eventtarget.rs b/src/components/script/dom/eventtarget.rs
index 5214aa0aa69..17c8e19b45c 100644
--- a/src/components/script/dom/eventtarget.rs
+++ b/src/components/script/dom/eventtarget.rs
@@ -2,7 +2,7 @@
  * 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::bindings::js::JS;
+use dom::bindings::js::JSRef;
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::bindings::error::{Fallible, InvalidState};
 use dom::bindings::codegen::BindingDeclarations::EventListenerBinding;
@@ -64,11 +64,42 @@ impl EventTarget {
             filtered.map(|entry| entry.listener).collect()
         })
     }
+}
+
+pub trait EventTargetHelpers {
+    fn dispatch_event_with_target<'a>(&self,
+                                      target: Option<JSRef<'a, EventTarget>>,
+                                      event: &mut JSRef<Event>) -> Fallible<bool>;
+}
+
+impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
+    fn dispatch_event_with_target<'b>(&self,
+                                      target: Option<JSRef<'b, EventTarget>>,
+                                      event: &mut JSRef<Event>) -> Fallible<bool> {
+        if event.deref().dispatching || !event.deref().initialized {
+            return Err(InvalidState);
+        }
+        Ok(dispatch_event(self, target, event))
+    }
+}
+
+pub trait EventTargetMethods {
+    fn AddEventListener(&mut self,
+                        ty: DOMString,
+                        listener: Option<EventListener>,
+                        capture: bool);
+    fn RemoveEventListener(&mut self,
+                           ty: DOMString,
+                           listener: Option<EventListener>,
+                           capture: bool);
+    fn DispatchEvent(&self, event: &mut JSRef<Event>) -> Fallible<bool>;
+}
 
-    pub fn AddEventListener(&mut self,
-                            ty: DOMString,
-                            listener: Option<EventListener>,
-                            capture: bool) {
+impl<'a> EventTargetMethods for JSRef<'a, EventTarget> {
+    fn AddEventListener(&mut 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 };
@@ -82,10 +113,10 @@ impl EventTarget {
         }
     }
 
-    pub fn RemoveEventListener(&mut self,
-                               ty: DOMString,
-                               listener: Option<EventListener>,
-                               capture: bool) {
+    fn RemoveEventListener(&mut 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() {
@@ -102,19 +133,8 @@ impl EventTarget {
         }
     }
 
-    pub fn DispatchEvent(&self, abstract_self: &JS<EventTarget>,
-                         event: &mut JS<Event>) -> Fallible<bool> {
-        self.dispatch_event_with_target(abstract_self, None, event)
-    }
-
-    pub fn dispatch_event_with_target(&self,
-                                      abstract_self: &JS<EventTarget>,
-                                      abstract_target: Option<JS<EventTarget>>,
-                                      event: &mut JS<Event>) -> Fallible<bool> {
-        if event.get().dispatching || !event.get().initialized {
-            return Err(InvalidState);
-        }
-        Ok(dispatch_event(abstract_self, abstract_target, event))
+    fn DispatchEvent(&self, event: &mut JSRef<Event>) -> Fallible<bool> {
+        self.dispatch_event_with_target(None, event)
     }
 }
 
@@ -128,8 +148,8 @@ impl Reflectable for EventTarget {
     }
 }
 
-impl VirtualMethods for JS<EventTarget> {
-    fn super_type(&self) -> Option<~VirtualMethods:> {
+impl<'a> VirtualMethods for JSRef<'a, EventTarget> {
+    fn super_type<'a>(&'a mut self) -> Option<&'a mut VirtualMethods:> {
         None
     }
 }