Remove helper traits

Now that JSRef<T> is gone, there is no need to have helper traits.

On components/script/*.rs:

    # Remove imports.
    /^ *use dom::[a-z]+::\{.*Helpers/ {
        s/\{(Raw[^L]|[^L][^a])[a-zA-Z]+Helpers, /\{/
        s/, (Raw[^L]|[^L][^a])[a-zA-Z]+Helpers([,}])/\2/g
        s/\{([a-zA-Z]+)\}/\1/
        /\{\}/d
        s/::self;$/;/
    }
    /^ *use dom::[a-z]+::\{?(Raw[^L]|[^L][^a])[a-zA-Z]+Helpers\}?;$/d

On components/script/dom/*.rs:

    # Ignore layout things.
    /^(pub )?(impl|trait).*Layout.* \{/,/^}$/ { P; D; }

    # Delete helpers traits.
    /^(pub )?trait ([^L][^ ]|L[^a])[^ ]+Helpers(<'a>)? \{$/,/^\}$/D

    # Patch private helpers.
    /^impl.*Private.*Helpers/,/^\}$/ {
        s/^impl<'a> Private([^L][^ ]|L[^a])[^ ]+Helpers(<'a>)? for &'a ([^ ]+) \{$/impl \3 {/
        /^ *(unsafe )?fn .*\(self.*[<&]'a/ {
            s/&'a /\&/g
            s/<'a, /</g
        }
        /^ *(unsafe )?fn /s/\(self([,)])/\(\&self\1/
    }

    # Patch public helpers.
    /^impl.*Helpers/,/^\}$/ {
        s/^impl(<'a>)? ([^L][^ ]|L[^a])[^ ]+Helpers(<'a>)? for (&'a )?([^ ]+) \{$/impl \5 {/
        /^ *(unsafe )?fn .*\(self.*[<&]'a/ {
            s/&'a /\&/g
            s/<'a, /</g
        }
        /^ *(unsafe )?fn .*\(&?self[,)]/s/(unsafe )?fn/pub &/
        /^ *pub (unsafe )?fn /s/\(self([,)])/\(\&self\1/
    }

The few error cases were then fixed by hand.

1 files changed, 11 insertions, 32 deletions

diff --git a/components/script/dom/eventtarget.rs b/components/script/dom/eventtarget.rs
index c492919da82..ed50a6b0fa9 100644
--- a/components/script/dom/eventtarget.rs
+++ b/components/script/dom/eventtarget.rs
@@ -10,7 +10,7 @@ use dom::bindings::codegen::Bindings::EventTargetBinding::EventTargetMethods;
 use dom::bindings::error::Error::InvalidState;
 use dom::bindings::error::{Fallible, report_pending_exception};
 use dom::bindings::utils::{Reflectable, Reflector};
-use dom::event::{Event, EventHelpers};
+use dom::event::Event;
 use dom::eventdispatcher::dispatch_event;
 use dom::node::NodeTypeId;
 use dom::virtualmethods::VirtualMethods;
@@ -165,40 +165,19 @@ impl EventTarget {
     }
 }
 
-pub trait EventTargetHelpers {
-    fn dispatch_event_with_target(self,
-                                  target: &EventTarget,
-                                  event: &Event) -> bool;
-    fn dispatch_event(self, event: &Event) -> bool;
-    fn set_inline_event_listener(self,
-                                 ty: DOMString,
-                                 listener: Option<Rc<EventHandler>>);
-    fn get_inline_event_listener(self, ty: DOMString) -> Option<Rc<EventHandler>>;
-    fn set_event_handler_uncompiled(self,
-                                    cx: *mut JSContext,
-                                    url: Url,
-                                    scope: HandleObject,
-                                    ty: &str,
-                                    source: DOMString);
-    fn set_event_handler_common<T: CallbackContainer>(self, ty: &str,
-                                                      listener: Option<Rc<T>>);
-    fn get_event_handler_common<T: CallbackContainer>(self, ty: &str) -> Option<Rc<T>>;
-
-    fn has_handlers(self) -> bool;
-}
 
-impl<'a> EventTargetHelpers for &'a EventTarget {
-    fn dispatch_event_with_target(self,
+impl EventTarget {
+    pub fn dispatch_event_with_target(&self,
                                   target: &EventTarget,
                                   event: &Event) -> bool {
         dispatch_event(self, Some(target), event)
     }
 
-    fn dispatch_event(self, event: &Event) -> bool {
+    pub fn dispatch_event(&self, event: &Event) -> bool {
         dispatch_event(self, None, event)
     }
 
-    fn set_inline_event_listener(self,
+    pub fn set_inline_event_listener(&self,
                                  ty: DOMString,
                                  listener: Option<Rc<EventHandler>>) {
         let mut handlers = self.handlers.borrow_mut();
@@ -234,7 +213,7 @@ impl<'a> EventTargetHelpers for &'a EventTarget {
         }
     }
 
-    fn get_inline_event_listener(self, ty: DOMString) -> Option<Rc<EventHandler>> {
+    pub fn get_inline_event_listener(&self, ty: DOMString) -> Option<Rc<EventHandler>> {
         let handlers = self.handlers.borrow();
         let entries = handlers.get(&ty);
         entries.and_then(|entries| entries.iter().filter_map(|entry| {
@@ -246,7 +225,7 @@ impl<'a> EventTargetHelpers for &'a EventTarget {
     }
 
     #[allow(unsafe_code)]
-    fn set_event_handler_uncompiled(self,
+    pub fn set_event_handler_uncompiled(&self,
                                     cx: *mut JSContext,
                                     url: Url,
                                     scope: HandleObject,
@@ -287,20 +266,20 @@ impl<'a> EventTargetHelpers for &'a EventTarget {
         self.set_event_handler_common(ty, Some(EventHandlerNonNull::new(funobj)));
     }
 
-    fn set_event_handler_common<T: CallbackContainer>(
-        self, ty: &str, listener: Option<Rc<T>>)
+    pub fn set_event_handler_common<T: CallbackContainer>(
+        &self, ty: &str, listener: Option<Rc<T>>)
     {
         let event_listener = listener.map(|listener|
                                           EventHandlerNonNull::new(listener.callback()));
         self.set_inline_event_listener(ty.to_owned(), event_listener);
     }
 
-    fn get_event_handler_common<T: CallbackContainer>(self, ty: &str) -> Option<Rc<T>> {
+    pub fn get_event_handler_common<T: CallbackContainer>(&self, ty: &str) -> Option<Rc<T>> {
         let listener = self.get_inline_event_listener(ty.to_owned());
         listener.map(|listener| CallbackContainer::new(listener.parent.callback()))
     }
 
-    fn has_handlers(self) -> bool {
+    pub fn has_handlers(&self) -> bool {
         !self.handlers.borrow().is_empty()
     }
 }