Convert various helper traits from &JSRef to JSRef

I converted them all with a few exceptions:

- Methods that were used by trait objects, since trait objects don't
  work with `self` methods.
- Methods that take an &'b JSRef<'a, T> and return an &'b. In reality,
  many (all?) could return an &'a instead, but this isn't allowed by the
  Deref trait.
- Methods that internally rely on the same issue with Deref.
- I left out the traits involved in layout entirely, even though not all
  of their methods suffer from one of the above problems.

There will probably be solutions to all of these problems in the future.

components/script/dom/attr.rs

@@ -147,14 +147,14 @@ impl<'a> AttrMethods for JSRef<'a, Attr> {
 }
 
 pub trait AttrHelpers {
-    fn set_value(&self, set_type: AttrSettingType, value: AttrValue);
+    fn set_value(self, set_type: AttrSettingType, value: AttrValue);
     fn value<'a>(&'a self) -> Ref<'a, AttrValue>;
     fn local_name<'a>(&'a self) -> &'a Atom;
-    fn summarize(&self) -> AttrInfo;
+    fn summarize(self) -> AttrInfo;
 }
 
 impl<'a> AttrHelpers for JSRef<'a, Attr> {
-    fn set_value(&self, set_type: AttrSettingType, value: AttrValue) {
+    fn set_value(self, set_type: AttrSettingType, value: AttrValue) {
         let owner = self.owner.root();
         let node: JSRef<Node> = NodeCast::from_ref(*owner);
         let namespace_is_null = self.namespace == namespace::Null;
@@ -187,7 +187,7 @@ impl<'a> AttrHelpers for JSRef<'a, Attr> {
         &self.local_name
     }
 
-    fn summarize(&self) -> AttrInfo {
+    fn summarize(self) -> AttrInfo {
         AttrInfo {
             namespace: self.namespace.to_str().to_string(),
             name: self.Name(),

components/script/dom/dedicatedworkerglobalscope.rs

@@ -175,11 +175,11 @@ impl<'a> DedicatedWorkerGlobalScopeMethods for JSRef<'a, DedicatedWorkerGlobalSc
 }
 
 trait PrivateDedicatedWorkerGlobalScopeHelpers {
-    fn delayed_release_worker(&self);
+    fn delayed_release_worker(self);
 }
 
 impl<'a> PrivateDedicatedWorkerGlobalScopeHelpers for JSRef<'a, DedicatedWorkerGlobalScope> {
-    fn delayed_release_worker(&self) {
+    fn delayed_release_worker(self) {
         let ScriptChan(ref sender) = self.parent_sender;
         sender.send(WorkerRelease(*self.worker));
     }

components/script/dom/document.rs

@@ -150,16 +150,16 @@ impl CollectionFilter for AppletsFilter {
 
 pub trait DocumentHelpers {
     fn url<'a>(&'a self) -> &'a Url;
-    fn quirks_mode(&self) -> QuirksMode;
+    fn quirks_mode(self) -> QuirksMode;
-    fn set_quirks_mode(&self, mode: QuirksMode);
+    fn set_quirks_mode(self, mode: QuirksMode);
-    fn set_last_modified(&self, value: DOMString);
+    fn set_last_modified(self, value: DOMString);
-    fn set_encoding_name(&self, name: DOMString);
+    fn set_encoding_name(self, name: DOMString);
-    fn content_changed(&self);
+    fn content_changed(self);
-    fn damage_and_reflow(&self, damage: DocumentDamageLevel);
+    fn damage_and_reflow(self, damage: DocumentDamageLevel);
-    fn wait_until_safe_to_modify_dom(&self);
+    fn wait_until_safe_to_modify_dom(self);
-    fn unregister_named_element(&self, to_unregister: JSRef<Element>, id: DOMString);
+    fn unregister_named_element(self, to_unregister: JSRef<Element>, id: DOMString);
-    fn register_named_element(&self, element: JSRef<Element>, id: DOMString);
+    fn register_named_element(self, element: JSRef<Element>, id: DOMString);
-    fn load_anchor_href(&self, href: DOMString);
+    fn load_anchor_href(self, href: DOMString);
 }
 
 impl<'a> DocumentHelpers for JSRef<'a, Document> {
@@ -167,37 +167,37 @@ impl<'a> DocumentHelpers for JSRef<'a, Document> {
         &*self.url
     }
 
-    fn quirks_mode(&self) -> QuirksMode {
+    fn quirks_mode(self) -> QuirksMode {
         self.quirks_mode.deref().get()
     }
 
-    fn set_quirks_mode(&self, mode: QuirksMode) {
+    fn set_quirks_mode(self, mode: QuirksMode) {
         self.quirks_mode.deref().set(mode);
     }
 
-    fn set_last_modified(&self, value: DOMString) {
+    fn set_last_modified(self, value: DOMString) {
         *self.last_modified.deref().borrow_mut() = Some(value);
     }
 
-    fn set_encoding_name(&self, name: DOMString) {
+    fn set_encoding_name(self, name: DOMString) {
         *self.encoding_name.deref().borrow_mut() = name;
     }
 
-    fn content_changed(&self) {
+    fn content_changed(self) {
         self.damage_and_reflow(ContentChangedDocumentDamage);
     }
 
-    fn damage_and_reflow(&self, damage: DocumentDamageLevel) {
+    fn damage_and_reflow(self, damage: DocumentDamageLevel) {
         self.window.root().damage_and_reflow(damage);
     }
 
-    fn wait_until_safe_to_modify_dom(&self) {
+    fn wait_until_safe_to_modify_dom(self) {
         self.window.root().wait_until_safe_to_modify_dom();
     }
 
 
     /// Remove any existing association between the provided id and any elements in this document.
-    fn unregister_named_element(&self,
+    fn unregister_named_element(self,
                                 to_unregister: JSRef<Element>,
                                 id: DOMString) {
         let mut idmap = self.idmap.deref().borrow_mut();
@@ -218,7 +218,7 @@ impl<'a> DocumentHelpers for JSRef<'a, Document> {
     }
 
     /// Associate an element present in this document with the provided id.
-    fn register_named_element(&self,
+    fn register_named_element(self,
                               element: JSRef<Element>,
                               id: DOMString) {
         assert!({
@@ -261,7 +261,7 @@ impl<'a> DocumentHelpers for JSRef<'a, Document> {
         idmap.insert(id, elements);
     }
 
-    fn load_anchor_href(&self, href: DOMString) {
+    fn load_anchor_href(self, href: DOMString) {
         let window = self.window.root();
         window.load_url(href);
     }
@@ -329,12 +329,12 @@ impl Reflectable for Document {
 }
 
 trait PrivateDocumentHelpers {
-    fn createNodeList(&self, callback: |node: JSRef<Node>| -> bool) -> Temporary<NodeList>;
+    fn createNodeList(self, callback: |node: JSRef<Node>| -> bool) -> Temporary<NodeList>;
-    fn get_html_element(&self) -> Option<Temporary<HTMLHtmlElement>>;
+    fn get_html_element(self) -> Option<Temporary<HTMLHtmlElement>>;
 }
 
 impl<'a> PrivateDocumentHelpers for JSRef<'a, Document> {
-    fn createNodeList(&self, callback: |node: JSRef<Node>| -> bool) -> Temporary<NodeList> {
+    fn createNodeList(self, callback: |node: JSRef<Node>| -> bool) -> Temporary<NodeList> {
         let window = self.window.root();
 
         match self.GetDocumentElement().root() {
@@ -355,7 +355,7 @@ impl<'a> PrivateDocumentHelpers for JSRef<'a, Document> {
 
     }
 
-    fn get_html_element(&self) -> Option<Temporary<HTMLHtmlElement>> {
+    fn get_html_element(self) -> Option<Temporary<HTMLHtmlElement>> {
         self.GetDocumentElement().root().filtered(|root| {
             let root: JSRef<Node> = NodeCast::from_ref(**root);
             root.type_id() == ElementNodeTypeId(HTMLHtmlElementTypeId)

components/script/dom/domtokenlist.rs

@@ -49,17 +49,17 @@ impl Reflectable for DOMTokenList {
 }
 
 trait PrivateDOMTokenListHelpers {
-    fn attribute(&self) -> Option<Temporary<Attr>>;
+    fn attribute(self) -> Option<Temporary<Attr>>;
-    fn check_token_exceptions<'a>(&self, token: &'a str) -> Fallible<&'a str>;
+    fn check_token_exceptions<'a>(self, token: &'a str) -> Fallible<&'a str>;
 }
 
 impl<'a> PrivateDOMTokenListHelpers for JSRef<'a, DOMTokenList> {
-    fn attribute(&self) -> Option<Temporary<Attr>> {
+    fn attribute(self) -> Option<Temporary<Attr>> {
         let element = self.element.root();
         element.deref().get_attribute(Null, self.local_name)
     }
 
-    fn check_token_exceptions<'a>(&self, token: &'a str) -> Fallible<&'a str> {
+    fn check_token_exceptions<'a>(self, token: &'a str) -> Fallible<&'a str> {
         match token {
             "" => Err(Syntax),
             token if token.find(HTML_SPACE_CHARACTERS).is_some() => Err(InvalidCharacter),

components/script/dom/element.rs

@@ -241,8 +241,8 @@ pub trait ElementHelpers {
     fn html_element_in_html_document(&self) -> bool;
     fn get_local_name<'a>(&'a self) -> &'a Atom;
     fn get_namespace<'a>(&'a self) -> &'a Namespace;
-    fn summarize(&self) -> Vec<AttrInfo>;
+    fn summarize(self) -> Vec<AttrInfo>;
-    fn is_void(&self) -> bool;
+    fn is_void(self) -> bool;
 }
 
 impl<'a> ElementHelpers for JSRef<'a, Element> {
@@ -259,7 +259,7 @@ impl<'a> ElementHelpers for JSRef<'a, Element> {
         &self.deref().namespace
     }
 
-    fn summarize(&self) -> Vec<AttrInfo> {
+    fn summarize(self) -> Vec<AttrInfo> {
         let attrs = self.Attributes().root();
         let mut i = 0;
         let mut summarized = vec!();
@@ -289,45 +289,45 @@ impl<'a> ElementHelpers for JSRef<'a, Element> {
 pub trait AttributeHandlers {
     /// Returns the attribute with given namespace and case-sensitive local
     /// name, if any.
-    fn get_attribute(&self, namespace: Namespace, local_name: &str)
+    fn get_attribute(self, namespace: Namespace, local_name: &str)
                      -> Option<Temporary<Attr>>;
-    fn set_attribute_from_parser(&self, local_name: Atom,
+    fn set_attribute_from_parser(self, local_name: Atom,
                                  value: DOMString, namespace: Namespace,
                                  prefix: Option<DOMString>);
-    fn set_attribute(&self, name: &str, value: AttrValue);
+    fn set_attribute(self, name: &str, value: AttrValue);
-    fn do_set_attribute(&self, local_name: Atom, value: AttrValue,
+    fn do_set_attribute(self, local_name: Atom, value: AttrValue,
                         name: Atom, namespace: Namespace,
                         prefix: Option<DOMString>, cb: |JSRef<Attr>| -> bool);
-    fn parse_attribute(&self, namespace: &Namespace, local_name: &Atom,
+    fn parse_attribute(self, namespace: &Namespace, local_name: &Atom,
                        value: DOMString) -> AttrValue;
 
-    fn remove_attribute(&self, namespace: Namespace, name: &str);
+    fn remove_attribute(self, namespace: Namespace, name: &str);
-    fn notify_attribute_changed(&self, local_name: &Atom);
+    fn notify_attribute_changed(self, local_name: &Atom);
     fn has_class(&self, name: &str) -> bool;
 
-    fn set_atomic_attribute(&self, name: &str, value: DOMString);
+    fn set_atomic_attribute(self, name: &str, value: DOMString);
 
     // http://www.whatwg.org/html/#reflecting-content-attributes-in-idl-attributes
-    fn has_attribute(&self, name: &str) -> bool;
+    fn has_attribute(self, name: &str) -> bool;
-    fn set_bool_attribute(&self, name: &str, value: bool);
+    fn set_bool_attribute(self, name: &str, value: bool);
-    fn get_url_attribute(&self, name: &str) -> DOMString;
+    fn get_url_attribute(self, name: &str) -> DOMString;
-    fn set_url_attribute(&self, name: &str, value: DOMString);
+    fn set_url_attribute(self, name: &str, value: DOMString);
-    fn get_string_attribute(&self, name: &str) -> DOMString;
+    fn get_string_attribute(self, name: &str) -> DOMString;
-    fn set_string_attribute(&self, name: &str, value: DOMString);
+    fn set_string_attribute(self, name: &str, value: DOMString);
-    fn set_tokenlist_attribute(&self, name: &str, value: DOMString);
+    fn set_tokenlist_attribute(self, name: &str, value: DOMString);
-    fn get_uint_attribute(&self, name: &str) -> u32;
+    fn get_uint_attribute(self, name: &str) -> u32;
-    fn set_uint_attribute(&self, name: &str, value: u32);
+    fn set_uint_attribute(self, name: &str, value: u32);
 }
 
 impl<'a> AttributeHandlers for JSRef<'a, Element> {
-    fn get_attribute(&self, namespace: Namespace, local_name: &str) -> Option<Temporary<Attr>> {
+    fn get_attribute(self, namespace: Namespace, local_name: &str) -> Option<Temporary<Attr>> {
         let local_name = Atom::from_slice(local_name);
         self.attrs.borrow().iter().map(|attr| attr.root()).find(|attr| {
             *attr.local_name() == local_name && attr.namespace == namespace
         }).map(|x| Temporary::from_rooted(*x))
     }
 
-    fn set_attribute_from_parser(&self, local_name: Atom,
+    fn set_attribute_from_parser(self, local_name: Atom,
                                  value: DOMString, namespace: Namespace,
                                  prefix: Option<DOMString>) {
         let name = match prefix {
@@ -341,11 +341,11 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
         self.do_set_attribute(local_name, value, name, namespace, prefix, |_| false)
     }
 
-    fn set_attribute(&self, name: &str, value: AttrValue) {
+    fn set_attribute(self, name: &str, value: AttrValue) {
         assert!(name == name.to_ascii_lower().as_slice());
         assert!(!name.contains(":"));
 
-        let node: JSRef<Node> = NodeCast::from_ref(*self);
+        let node: JSRef<Node> = NodeCast::from_ref(self);
         node.wait_until_safe_to_modify_dom();
 
         let name = Atom::from_slice(name);
@@ -353,7 +353,7 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
             namespace::Null, None, |attr| *attr.local_name() == name);
     }
 
-    fn do_set_attribute(&self, local_name: Atom, value: AttrValue,
+    fn do_set_attribute(self, local_name: Atom, value: AttrValue,
                         name: Atom, namespace: Namespace,
                         prefix: Option<DOMString>, cb: |JSRef<Attr>| -> bool) {
         let idx = self.deref().attrs.borrow().iter()
@@ -362,9 +362,9 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
         let (idx, set_type) = match idx {
             Some(idx) => (idx, ReplacedAttr),
             None => {
-                let window = window_from_node(*self).root();
+                let window = window_from_node(self).root();
                 let attr = Attr::new(*window, local_name, value.clone(),
-                                     name, namespace.clone(), prefix, *self);
+                                     name, namespace.clone(), prefix, self);
                 self.deref().attrs.borrow_mut().push_unrooted(&attr);
                 (self.deref().attrs.borrow().len() - 1, FirstSetAttr)
             }
@@ -373,17 +373,17 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
         (*self.deref().attrs.borrow())[idx].root().set_value(set_type, value);
     }
 
-    fn parse_attribute(&self, namespace: &Namespace, local_name: &Atom,
+    fn parse_attribute(self, namespace: &Namespace, local_name: &Atom,
                        value: DOMString) -> AttrValue {
         if *namespace == namespace::Null {
-            vtable_for(&NodeCast::from_ref(*self))
+            vtable_for(&NodeCast::from_ref(self))
                 .parse_plain_attribute(local_name.as_slice(), value)
         } else {
             StringAttrValue(value)
         }
     }
 
-    fn remove_attribute(&self, namespace: Namespace, name: &str) {
+    fn remove_attribute(self, namespace: Namespace, name: &str) {
         let (_, local_name) = get_attribute_parts(name);
         let local_name = Atom::from_slice(local_name);
 
@@ -395,13 +395,13 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
             None => (),
             Some(idx) => {
                 {
-                    let node: JSRef<Node> = NodeCast::from_ref(*self);
+                    let node: JSRef<Node> = NodeCast::from_ref(self);
                     node.wait_until_safe_to_modify_dom();
                 }
 
                 if namespace == namespace::Null {
                     let removed_raw_value = (*self.deref().attrs.borrow())[idx].root().Value();
-                    vtable_for(&NodeCast::from_ref(*self))
+                    vtable_for(&NodeCast::from_ref(self))
                         .before_remove_attr(&local_name,
                                             removed_raw_value);
                 }
@@ -411,8 +411,8 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
         };
     }
 
-    fn notify_attribute_changed(&self, local_name: &Atom) {
+    fn notify_attribute_changed(self, local_name: &Atom) {
-        let node: JSRef<Node> = NodeCast::from_ref(*self);
+        let node: JSRef<Node> = NodeCast::from_ref(self);
         if node.is_in_doc() {
             let damage = match local_name.as_slice() {
                 "style" | "id" | "class" => MatchSelectorsDocumentDamage,
@@ -431,13 +431,13 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
         }).unwrap_or(false)
     }
 
-    fn set_atomic_attribute(&self, name: &str, value: DOMString) {
+    fn set_atomic_attribute(self, name: &str, value: DOMString) {
         assert!(name == name.to_ascii_lower().as_slice());
         let value = AttrValue::from_atomic(value);
         self.set_attribute(name, value);
     }
 
-    fn has_attribute(&self, name: &str) -> bool {
+    fn has_attribute(self, name: &str) -> bool {
         let name = match self.html_element_in_html_document() {
             true => Atom::from_slice(name.to_ascii_lower().as_slice()),
             false => Atom::from_slice(name)
@@ -447,7 +447,7 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
         })
     }
 
-    fn set_bool_attribute(&self, name: &str, value: bool) {
+    fn set_bool_attribute(self, name: &str, value: bool) {
         if self.has_attribute(name) == value { return; }
         if value {
             self.set_string_attribute(name, String::new());
@@ -456,16 +456,16 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
         }
     }
 
-    fn get_url_attribute(&self, name: &str) -> DOMString {
+    fn get_url_attribute(self, name: &str) -> DOMString {
         assert!(name == name.to_ascii_lower().as_slice());
         // XXX Resolve URL.
         self.get_string_attribute(name)
     }
-    fn set_url_attribute(&self, name: &str, value: DOMString) {
+    fn set_url_attribute(self, name: &str, value: DOMString) {
         self.set_string_attribute(name, value);
     }
 
-    fn get_string_attribute(&self, name: &str) -> DOMString {
+    fn get_string_attribute(self, name: &str) -> DOMString {
         assert!(name == name.to_ascii_lower().as_slice());
         match self.get_attribute(Null, name) {
             Some(x) => {
@@ -475,17 +475,17 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
             None => "".to_string()
         }
     }
-    fn set_string_attribute(&self, name: &str, value: DOMString) {
+    fn set_string_attribute(self, name: &str, value: DOMString) {
         assert!(name == name.to_ascii_lower().as_slice());
         self.set_attribute(name, StringAttrValue(value));
     }
 
-    fn set_tokenlist_attribute(&self, name: &str, value: DOMString) {
+    fn set_tokenlist_attribute(self, name: &str, value: DOMString) {
         assert!(name == name.to_ascii_lower().as_slice());
         self.set_attribute(name, AttrValue::from_tokenlist(value));
     }
 
-    fn get_uint_attribute(&self, name: &str) -> u32 {
+    fn get_uint_attribute(self, name: &str) -> u32 {
         assert!(name == name.to_ascii_lower().as_slice());
         let attribute = self.get_attribute(Null, name).root();
         match attribute {
@@ -498,7 +498,7 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
             None => 0,
         }
     }
-    fn set_uint_attribute(&self, name: &str, value: u32) {
+    fn set_uint_attribute(self, name: &str, value: u32) {
         assert!(name == name.to_ascii_lower().as_slice());
         self.set_attribute(name, UIntAttrValue(value.to_string(), value));
     }

components/script/dom/eventtarget.rs

@@ -94,37 +94,37 @@ impl EventTarget {
 }
 
 pub trait EventTargetHelpers {
-    fn dispatch_event_with_target<'a>(&self,
+    fn dispatch_event_with_target(self,
-                                      target: Option<JSRef<'a, EventTarget>>,
+                                  target: Option<JSRef<EventTarget>>,
                                   event: JSRef<Event>) -> Fallible<bool>;
-    fn set_inline_event_listener(&self,
+    fn set_inline_event_listener(self,
                                  ty: DOMString,
                                  listener: Option<EventListener>);
-    fn get_inline_event_listener(&self, ty: DOMString) -> Option<EventListener>;
+    fn get_inline_event_listener(self, ty: DOMString) -> Option<EventListener>;
-    fn set_event_handler_uncompiled(&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>(&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 get_event_handler_common<T: CallbackContainer>(self, ty: &str) -> Option<T>;
 
-    fn has_handlers(&self) -> bool;
+    fn has_handlers(self) -> bool;
 }
 
 impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
-    fn dispatch_event_with_target<'b>(&self,
+    fn dispatch_event_with_target(self,
-                                      target: Option<JSRef<'b, EventTarget>>,
+                                  target: Option<JSRef<EventTarget>>,
                                   event: JSRef<Event>) -> Fallible<bool> {
         if event.deref().dispatching.deref().get() || !event.deref().initialized.deref().get() {
             return Err(InvalidState);
         }
-        Ok(dispatch_event(*self, target, event))
+        Ok(dispatch_event(self, target, event))
     }
 
-    fn set_inline_event_listener(&self,
+    fn set_inline_event_listener(self,
                                  ty: DOMString,
                                  listener: Option<EventListener>) {
         let mut handlers = self.handlers.deref().borrow_mut();
@@ -156,7 +156,7 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
         }
     }
 
-    fn get_inline_event_listener(&self, ty: DOMString) -> Option<EventListener> {
+    fn get_inline_event_listener(self, ty: DOMString) -> Option<EventListener> {
         let handlers = self.handlers.deref().borrow();
         let entries = handlers.find(&ty);
         entries.and_then(|entries| entries.iter().find(|entry| {
@@ -167,7 +167,7 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
         }).map(|entry| entry.listener.get_listener()))
     }
 
-    fn set_event_handler_uncompiled(&self,
+    fn set_event_handler_uncompiled(self,
                                     cx: *mut JSContext,
                                     url: Url,
                                     scope: *mut JSObject,
@@ -207,19 +207,19 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
     }
 
     fn set_event_handler_common<T: CallbackContainer>(
-        &self, ty: &str, listener: Option<T>)
+        self, ty: &str, listener: Option<T>)
     {
         let event_listener = listener.map(|listener|
                                           EventListener::new(listener.callback()));
         self.set_inline_event_listener(ty.to_string(), event_listener);
     }
 
-    fn get_event_handler_common<T: CallbackContainer>(&self, ty: &str) -> Option<T> {
+    fn get_event_handler_common<T: CallbackContainer>(self, ty: &str) -> Option<T> {
         let listener = self.get_inline_event_listener(ty.to_string());
         listener.map(|listener| CallbackContainer::new(listener.parent.callback()))
     }
 
-    fn has_handlers(&self) -> bool {
+    fn has_handlers(self) -> bool {
         !self.handlers.deref().borrow().is_empty()
     }
 }

components/script/dom/htmlanchorelement.rs

@@ -50,19 +50,19 @@ impl HTMLAnchorElement {
 }
 
 trait PrivateHTMLAnchorElementHelpers {
-    fn handle_event_impl(&self, event: JSRef<Event>);
+    fn handle_event_impl(self, event: JSRef<Event>);
 }
 
 impl<'a> PrivateHTMLAnchorElementHelpers for JSRef<'a, HTMLAnchorElement> {
-    fn handle_event_impl(&self, event: JSRef<Event>) {
+    fn handle_event_impl(self, event: JSRef<Event>) {
         if "click" == event.Type().as_slice() && !event.DefaultPrevented() {
-            let element: JSRef<Element> = ElementCast::from_ref(*self);
+            let element: JSRef<Element> = ElementCast::from_ref(self);
             let attr = element.get_attribute(Null, "href").root();
             match attr {
                 Some(ref href) => {
                     let value = href.Value();
                     debug!("clicked on link to {:s}", value);
-                    let node: JSRef<Node> = NodeCast::from_ref(*self);
+                    let node: JSRef<Node> = NodeCast::from_ref(self);
                     let doc = node.owner_doc().root();
                     doc.load_anchor_href(value);
                 }

components/script/dom/htmlelement.rs

@@ -52,12 +52,12 @@ impl HTMLElement {
 }
 
 trait PrivateHTMLElementHelpers {
-    fn is_body_or_frameset(&self) -> bool;
+    fn is_body_or_frameset(self) -> bool;
 }
 
 impl<'a> PrivateHTMLElementHelpers for JSRef<'a, HTMLElement> {
-    fn is_body_or_frameset(&self) -> bool {
+    fn is_body_or_frameset(self) -> bool {
-        let eventtarget: JSRef<EventTarget> = EventTargetCast::from_ref(*self);
+        let eventtarget: JSRef<EventTarget> = EventTargetCast::from_ref(self);
         eventtarget.is_htmlbodyelement() || eventtarget.is_htmlframesetelement()
     }
 }

components/script/dom/htmliframeelement.rs

@@ -62,32 +62,32 @@ pub struct IFrameSize {
 }
 
 pub trait HTMLIFrameElementHelpers {
-    fn is_sandboxed(&self) -> bool;
+    fn is_sandboxed(self) -> bool;
-    fn get_url(&self) -> Option<Url>;
+    fn get_url(self) -> Option<Url>;
     /// http://www.whatwg.org/html/#process-the-iframe-attributes
-    fn process_the_iframe_attributes(&self);
+    fn process_the_iframe_attributes(self);
 }
 
 impl<'a> HTMLIFrameElementHelpers for JSRef<'a, HTMLIFrameElement> {
-    fn is_sandboxed(&self) -> bool {
+    fn is_sandboxed(self) -> bool {
         self.sandbox.deref().get().is_some()
     }
 
-    fn get_url(&self) -> Option<Url> {
+    fn get_url(self) -> Option<Url> {
-        let element: JSRef<Element> = ElementCast::from_ref(*self);
+        let element: JSRef<Element> = ElementCast::from_ref(self);
         element.get_attribute(Null, "src").root().and_then(|src| {
             let url = src.deref().value();
             if url.as_slice().is_empty() {
                 None
             } else {
-                let window = window_from_node(*self).root();
+                let window = window_from_node(self).root();
                 UrlParser::new().base_url(&window.deref().page().get_url())
                     .parse(url.as_slice()).ok()
             }
         })
     }
 
-    fn process_the_iframe_attributes(&self) {
+    fn process_the_iframe_attributes(self) {
         let url = match self.get_url() {
             Some(url) => url.clone(),
             None => Url::parse("about:blank").unwrap(),
@@ -100,7 +100,7 @@ impl<'a> HTMLIFrameElementHelpers for JSRef<'a, HTMLIFrameElement> {
         };
 
         // Subpage Id
-        let window = window_from_node(*self).root();
+        let window = window_from_node(self).root();
         let page = window.deref().page();
         let subpage_id = page.get_next_subpage_id();
 

components/script/dom/htmlimageelement.rs

@@ -39,14 +39,14 @@ impl HTMLImageElementDerived for EventTarget {
 }
 
 trait PrivateHTMLImageElementHelpers {
-    fn update_image(&self, value: Option<(DOMString, &Url)>);
+    fn update_image(self, value: Option<(DOMString, &Url)>);
 }
 
 impl<'a> PrivateHTMLImageElementHelpers for JSRef<'a, HTMLImageElement> {
     /// Makes the local `image` member match the status of the `src` attribute and starts
     /// prefetching the image. This method must be called after `src` is changed.
-    fn update_image(&self, value: Option<(DOMString, &Url)>) {
+    fn update_image(self, value: Option<(DOMString, &Url)>) {
-        let node: JSRef<Node> = NodeCast::from_ref(*self);
+        let node: JSRef<Node> = NodeCast::from_ref(self);
         let document = node.owner_doc().root();
         let window = document.deref().window.root();
         let image_cache = &window.image_cache_task;

components/script/dom/htmllinkelement.rs

@@ -114,12 +114,12 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLLinkElement> {
 }
 
 trait PrivateHTMLLinkElementHelpers {
-    fn handle_stylesheet_url(&self, href: &str);
+    fn handle_stylesheet_url(self, href: &str);
 }
 
 impl<'a> PrivateHTMLLinkElementHelpers for JSRef<'a, HTMLLinkElement> {
-    fn handle_stylesheet_url(&self, href: &str) {
+    fn handle_stylesheet_url(self, href: &str) {
-        let window = window_from_node(*self).root();
+        let window = window_from_node(self).root();
         match UrlParser::new().base_url(&window.deref().page().get_url()).parse(href) {
             Ok(url) => {
                 let LayoutChan(ref layout_chan) = *window.deref().page().layout_chan;

components/script/dom/htmlscriptelement.rs

@@ -48,7 +48,7 @@ impl HTMLScriptElement {
 pub trait HTMLScriptElementHelpers {
     /// Prepare a script (<http://www.whatwg.org/html/#prepare-a-script>),
     /// steps 6 and 7.
-    fn is_javascript(&self) -> bool;
+    fn is_javascript(self) -> bool;
 }
 
 /// Supported script types as defined by
@@ -73,8 +73,8 @@ static SCRIPT_JS_MIMES: StaticStringVec = &[
 ];
 
 impl<'a> HTMLScriptElementHelpers for JSRef<'a, HTMLScriptElement> {
-    fn is_javascript(&self) -> bool {
+    fn is_javascript(self) -> bool {
-        let element: JSRef<Element> = ElementCast::from_ref(*self);
+        let element: JSRef<Element> = ElementCast::from_ref(self);
         match element.get_attribute(Null, "type").root().map(|s| s.Value()) {
             Some(ref s) if s.is_empty() => {
                 // type attr exists, but empty means js

components/script/dom/htmlstyleelement.rs

@@ -44,12 +44,12 @@ impl HTMLStyleElement {
 }
 
 pub trait StyleElementHelpers {
-    fn parse_own_css(&self);
+    fn parse_own_css(self);
 }
 
 impl<'a> StyleElementHelpers for JSRef<'a, HTMLStyleElement> {
-    fn parse_own_css(&self) {
+    fn parse_own_css(self) {
-        let node: JSRef<Node> = NodeCast::from_ref(*self);
+        let node: JSRef<Node> = NodeCast::from_ref(self);
         assert!(node.is_in_doc());
 
         let win = window_from_node(node).root();

components/script/dom/performancetiming.rs

@@ -43,11 +43,11 @@ impl<'a> PerformanceTimingMethods for JSRef<'a, PerformanceTiming> {
 }
 
 pub trait PerformanceTimingHelpers {
-    fn NavigationStartPrecise(&self) -> f64;
+    fn NavigationStartPrecise(self) -> f64;
 }
 
 impl<'a> PerformanceTimingHelpers for JSRef<'a, PerformanceTiming> {
-    fn NavigationStartPrecise(&self) -> f64 {
+    fn NavigationStartPrecise(self) -> f64 {
         self.navigationStartPrecise
     }
 }

components/script/dom/treewalker.rs

@@ -133,24 +133,24 @@ impl Reflectable for TreeWalker {
 type NodeAdvancer<'a, 'b> = |node: JSRef<'a, Node>|: 'b -> Option<Temporary<Node>>;
 
 trait PrivateTreeWalkerHelpers<'a, 'b> {
-    fn traverse_children(&self,
+    fn traverse_children(self,
                          next_child: NodeAdvancer<'a, 'b>,
                          next_sibling: NodeAdvancer<'a, 'b>)
                          -> Fallible<Option<Temporary<Node>>>;
-    fn traverse_siblings(&self,
+    fn traverse_siblings(self,
                          next_child: NodeAdvancer<'a, 'b>,
                          next_sibling: NodeAdvancer<'a, 'b>)
                          -> Fallible<Option<Temporary<Node>>>;
-    fn is_root_node(&self, node: JSRef<'a, Node>) -> bool;
+    fn is_root_node(self, node: JSRef<'a, Node>) -> bool;
-    fn is_current_node(&self, node: JSRef<'a, Node>) -> bool;
+    fn is_current_node(self, node: JSRef<'a, Node>) -> bool;
-    fn first_following_node_not_following_root(&self, node: JSRef<'a, Node>)
+    fn first_following_node_not_following_root(self, node: JSRef<'a, Node>)
                                                -> Option<Temporary<Node>>;
-    fn accept_node(&self, node: JSRef<'a, Node>) -> Fallible<u16>;
+    fn accept_node(self, node: JSRef<'a, Node>) -> Fallible<u16>;
 }
 
 impl<'a, 'b> PrivateTreeWalkerHelpers<'a, 'b> for JSRef<'a, TreeWalker> {
     // http://dom.spec.whatwg.org/#concept-traverse-children
-    fn traverse_children(&self,
+    fn traverse_children(self,
                          next_child: NodeAdvancer<'a, 'b>,
                          next_sibling: NodeAdvancer<'a, 'b>)
                          -> Fallible<Option<Temporary<Node>>> {
@@ -229,7 +229,7 @@ impl<'a, 'b> PrivateTreeWalkerHelpers<'a, 'b> for JSRef<'a, TreeWalker> {
     }
 
     // http://dom.spec.whatwg.org/#concept-traverse-siblings
-    fn traverse_siblings(&self,
+    fn traverse_siblings(self,
                          next_child: NodeAdvancer<'a, 'b>,
                          next_sibling: NodeAdvancer<'a, 'b>)
                          -> Fallible<Option<Temporary<Node>>> {
@@ -293,7 +293,7 @@ impl<'a, 'b> PrivateTreeWalkerHelpers<'a, 'b> for JSRef<'a, TreeWalker> {
     }
 
     // http://dom.spec.whatwg.org/#concept-tree-following
-    fn first_following_node_not_following_root(&self, node: JSRef<'a, Node>)
+    fn first_following_node_not_following_root(self, node: JSRef<'a, Node>)
                                                -> Option<Temporary<Node>> {
         // "An object A is following an object B if A and B are in the same tree
         //  and A comes after B in tree order."
@@ -320,7 +320,7 @@ impl<'a, 'b> PrivateTreeWalkerHelpers<'a, 'b> for JSRef<'a, TreeWalker> {
     }
 
     // http://dom.spec.whatwg.org/#concept-node-filter
-    fn accept_node(&self, node: JSRef<'a, Node>) -> Fallible<u16> {
+    fn accept_node(self, node: JSRef<'a, Node>) -> Fallible<u16> {
         // "To filter node run these steps:"
         // "1. Let n be node's nodeType attribute value minus 1."
         let n: uint = node.NodeType() as uint - 1;
@@ -336,32 +336,32 @@ impl<'a, 'b> PrivateTreeWalkerHelpers<'a, 'b> for JSRef<'a, TreeWalker> {
         match self.filter {
             FilterNone => Ok(NodeFilterConstants::FILTER_ACCEPT),
             FilterNative(f) => Ok((*f)(node)),
-            FilterJS(callback) => callback.AcceptNode_(*self, node, RethrowExceptions)
+            FilterJS(callback) => callback.AcceptNode_(self, node, RethrowExceptions)
         }
     }
 
-    fn is_root_node(&self, node: JSRef<'a, Node>) -> bool {
+    fn is_root_node(self, node: JSRef<'a, Node>) -> bool {
         JS::from_rooted(node) == self.root_node
     }
 
-    fn is_current_node(&self, node: JSRef<'a, Node>) -> bool {
+    fn is_current_node(self, node: JSRef<'a, Node>) -> bool {
         JS::from_rooted(node) == self.current_node.get()
     }
 }
 
 pub trait TreeWalkerHelpers<'a> {
-    fn parent_node(&self) -> Fallible<Option<Temporary<Node>>>;
+    fn parent_node(self) -> Fallible<Option<Temporary<Node>>>;
-    fn first_child(&self) -> Fallible<Option<Temporary<Node>>>;
+    fn first_child(self) -> Fallible<Option<Temporary<Node>>>;
-    fn last_child(&self) -> Fallible<Option<Temporary<Node>>>;
+    fn last_child(self) -> Fallible<Option<Temporary<Node>>>;
-    fn next_sibling(&self) -> Fallible<Option<Temporary<Node>>>;
+    fn next_sibling(self) -> Fallible<Option<Temporary<Node>>>;
-    fn prev_sibling(&self) -> Fallible<Option<Temporary<Node>>>;
+    fn prev_sibling(self) -> Fallible<Option<Temporary<Node>>>;
-    fn next_node(&self) -> Fallible<Option<Temporary<Node>>>;
+    fn next_node(self) -> Fallible<Option<Temporary<Node>>>;
-    fn prev_node(&self) -> Fallible<Option<Temporary<Node>>>;
+    fn prev_node(self) -> Fallible<Option<Temporary<Node>>>;
 }
 
 impl<'a> TreeWalkerHelpers<'a> for JSRef<'a, TreeWalker> {
     // http://dom.spec.whatwg.org/#dom-treewalker-parentnode
-    fn parent_node(&self) -> Fallible<Option<Temporary<Node>>> {
+    fn parent_node(self) -> Fallible<Option<Temporary<Node>>> {
         // "1. Let node be the value of the currentNode attribute."
         let mut node = self.current_node.get().root().clone();
         // "2. While node is not null and is not root, run these substeps:"
@@ -389,35 +389,35 @@ impl<'a> TreeWalkerHelpers<'a> for JSRef<'a, TreeWalker> {
     }
 
     // http://dom.spec.whatwg.org/#dom-treewalker-firstchild
-    fn first_child(&self) -> Fallible<Option<Temporary<Node>>> {
+    fn first_child(self) -> Fallible<Option<Temporary<Node>>> {
         // "The firstChild() method must traverse children of type first."
         self.traverse_children(|node| node.first_child(),
                                |node| node.next_sibling())
     }
 
     // http://dom.spec.whatwg.org/#dom-treewalker-lastchild
-    fn last_child(&self) -> Fallible<Option<Temporary<Node>>> {
+    fn last_child(self) -> Fallible<Option<Temporary<Node>>> {
         // "The lastChild() method must traverse children of type last."
         self.traverse_children(|node| node.last_child(),
                                |node| node.prev_sibling())
     }
 
     // http://dom.spec.whatwg.org/#dom-treewalker-nextsibling
-    fn next_sibling(&self) -> Fallible<Option<Temporary<Node>>> {
+    fn next_sibling(self) -> Fallible<Option<Temporary<Node>>> {
         // "The nextSibling() method must traverse siblings of type next."
         self.traverse_siblings(|node| node.first_child(),
                                |node| node.next_sibling())
     }
 
     // http://dom.spec.whatwg.org/#dom-treewalker-previoussibling
-    fn prev_sibling(&self) -> Fallible<Option<Temporary<Node>>> {
+    fn prev_sibling(self) -> Fallible<Option<Temporary<Node>>> {
         // "The previousSibling() method must traverse siblings of type previous."
         self.traverse_siblings(|node| node.last_child(),
                                |node| node.prev_sibling())
     }
 
     // http://dom.spec.whatwg.org/#dom-treewalker-previousnode
-    fn prev_node(&self) -> Fallible<Option<Temporary<Node>>> {
+    fn prev_node(self) -> Fallible<Option<Temporary<Node>>> {
         // "1. Let node be the value of the currentNode attribute."
         let mut node = self.current_node.get().root().clone();
         // "2. While node is not root, run these substeps:"
@@ -478,7 +478,7 @@ impl<'a> TreeWalkerHelpers<'a> for JSRef<'a, TreeWalker> {
     }
 
     // http://dom.spec.whatwg.org/#dom-treewalker-nextnode
-    fn next_node(&self) -> Fallible<Option<Temporary<Node>>> {
+    fn next_node(self) -> Fallible<Option<Temporary<Node>>> {
         // "1. Let node be the value of the currentNode attribute."
         let mut node = self.current_node.get().root().clone();
         // "2. Let result be FILTER_ACCEPT."

components/script/dom/window.rs

@@ -364,21 +364,21 @@ impl Reflectable for Window {
 }
 
 pub trait WindowHelpers {
-    fn damage_and_reflow(&self, damage: DocumentDamageLevel);
+    fn damage_and_reflow(self, damage: DocumentDamageLevel);
-    fn flush_layout(&self, goal: ReflowGoal);
+    fn flush_layout(self, goal: ReflowGoal);
-    fn wait_until_safe_to_modify_dom(&self);
+    fn wait_until_safe_to_modify_dom(self);
-    fn init_browser_context(&self, doc: JSRef<Document>);
+    fn init_browser_context(self, doc: JSRef<Document>);
-    fn load_url(&self, href: DOMString);
+    fn load_url(self, href: DOMString);
-    fn handle_fire_timer(&self, timer_id: TimerId, cx: *mut JSContext);
+    fn handle_fire_timer(self, timer_id: TimerId, cx: *mut JSContext);
-    fn evaluate_js_with_result(&self, code: &str) -> JSVal;
+    fn evaluate_js_with_result(self, code: &str) -> JSVal;
 }
 
 trait PrivateWindowHelpers {
-    fn set_timeout_or_interval(&self, callback: JSVal, timeout: i32, is_interval: bool) -> i32;
+    fn set_timeout_or_interval(self, callback: JSVal, timeout: i32, is_interval: bool) -> i32;
 }
 
 impl<'a> WindowHelpers for JSRef<'a, Window> {
-    fn evaluate_js_with_result(&self, code: &str) -> JSVal {
+    fn evaluate_js_with_result(self, code: &str) -> JSVal {
         let global = self.reflector().get_jsobject();
         let code: Vec<u16> = code.as_slice().utf16_units().collect();
         let mut rval = UndefinedValue();
@@ -397,27 +397,27 @@ impl<'a> WindowHelpers for JSRef<'a, Window> {
         })
     }
 
-    fn damage_and_reflow(&self, damage: DocumentDamageLevel) {
+    fn damage_and_reflow(self, damage: DocumentDamageLevel) {
         self.page().damage(damage);
         self.page().avoided_reflows.set(self.page().avoided_reflows.get() + 1);
     }
 
-    fn flush_layout(&self, goal: ReflowGoal) {
+    fn flush_layout(self, goal: ReflowGoal) {
         self.page().flush_layout(goal);
     }
 
-    fn wait_until_safe_to_modify_dom(&self) {
+    fn wait_until_safe_to_modify_dom(self) {
         // FIXME: This disables concurrent layout while we are modifying the DOM, since
         //        our current architecture is entirely unsafe in the presence of races.
         self.page().join_layout();
     }
 
-    fn init_browser_context(&self, doc: JSRef<Document>) {
+    fn init_browser_context(self, doc: JSRef<Document>) {
         *self.browser_context.deref().borrow_mut() = Some(BrowserContext::new(doc));
     }
 
     /// Commence a new URL load which will either replace this window or scroll to a fragment.
-    fn load_url(&self, href: DOMString) {
+    fn load_url(self, href: DOMString) {
         let base_url = self.page().get_url();
         debug!("current page url is {:?}", base_url);
         let url = UrlParser::new().base_url(&base_url).parse(href.as_slice());
@@ -431,7 +431,7 @@ impl<'a> WindowHelpers for JSRef<'a, Window> {
         }
     }
 
-    fn handle_fire_timer(&self, timer_id: TimerId, cx: *mut JSContext) {
+    fn handle_fire_timer(self, timer_id: TimerId, cx: *mut JSContext) {
         let this_value = self.reflector().get_jsobject();
 
         let data = match self.active_timers.deref().borrow().find(&timer_id) {
@@ -455,7 +455,7 @@ impl<'a> WindowHelpers for JSRef<'a, Window> {
 }
 
 impl<'a> PrivateWindowHelpers for JSRef<'a, Window> {
-    fn set_timeout_or_interval(&self, callback: JSVal, timeout: i32, is_interval: bool) -> i32 {
+    fn set_timeout_or_interval(self, callback: JSVal, timeout: i32, is_interval: bool) -> i32 {
         let timeout = cmp::max(0, timeout) as u64;
         let handle = self.next_timer_handle.deref().get();
         self.next_timer_handle.deref().set(handle + 1);

components/script/dom/xmlhttprequest.rs

@@ -692,23 +692,23 @@ impl TrustedXHRAddress {
 
 
 trait PrivateXMLHttpRequestHelpers {
-    unsafe fn to_trusted(&self) -> TrustedXHRAddress;
+    unsafe fn to_trusted(self) -> TrustedXHRAddress;
-    fn release_once(&self);
+    fn release_once(self);
-    fn change_ready_state(&self, XMLHttpRequestState);
+    fn change_ready_state(self, XMLHttpRequestState);
-    fn process_partial_response(&self, progress: XHRProgress);
+    fn process_partial_response(self, progress: XHRProgress);
-    fn insert_trusted_header(&self, name: String, value: String);
+    fn insert_trusted_header(self, name: String, value: String);
-    fn dispatch_progress_event(&self, upload: bool, type_: DOMString, loaded: u64, total: Option<u64>);
+    fn dispatch_progress_event(self, upload: bool, type_: DOMString, loaded: u64, total: Option<u64>);
-    fn dispatch_upload_progress_event(&self, type_: DOMString, partial_load: Option<u64>);
+    fn dispatch_upload_progress_event(self, type_: DOMString, partial_load: Option<u64>);
-    fn dispatch_response_progress_event(&self, type_: DOMString);
+    fn dispatch_response_progress_event(self, type_: DOMString);
-    fn text_response(&self) -> DOMString;
+    fn text_response(self) -> DOMString;
-    fn set_timeout(&self, timeout:u32);
+    fn set_timeout(self, timeout:u32);
-    fn cancel_timeout(&self);
+    fn cancel_timeout(self);
-    fn filter_response_headers(&self) -> ResponseHeaderCollection;
+    fn filter_response_headers(self) -> ResponseHeaderCollection;
 }
 
 impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
     // Creates a trusted address to the object, and roots it. Always pair this with a release()
-    unsafe fn to_trusted(&self) -> TrustedXHRAddress {
+    unsafe fn to_trusted(self) -> TrustedXHRAddress {
         if self.pinned_count.deref().get() == 0 {
             JS_AddObjectRoot(self.global.root().root_ref().get_cx(), self.reflector().rootable());
         }
@@ -717,7 +717,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
         TrustedXHRAddress(self.deref() as *const XMLHttpRequest as *const libc::c_void)
     }
 
-    fn release_once(&self) {
+    fn release_once(self) {
         if self.sync.deref().get() {
             // Lets us call this at various termination cases without having to
             // check self.sync every time, since the pinning mechanism only is
@@ -734,18 +734,18 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
         }
     }
 
-    fn change_ready_state(&self, rs: XMLHttpRequestState) {
+    fn change_ready_state(self, rs: XMLHttpRequestState) {
         assert!(self.ready_state.deref().get() != rs)
         self.ready_state.deref().set(rs);
         let global = self.global.root();
         let event = Event::new(&global.root_ref(),
                                "readystatechange".to_string(),
                                false, true).root();
-        let target: JSRef<EventTarget> = EventTargetCast::from_ref(*self);
+        let target: JSRef<EventTarget> = EventTargetCast::from_ref(self);
         target.dispatch_event_with_target(None, *event).ok();
     }
 
-    fn process_partial_response(&self, progress: XHRProgress) {
+    fn process_partial_response(self, progress: XHRProgress) {
         match progress {
             HeadersReceivedMsg(headers, status) => {
                 // For synchronous requests, this should not fire any events, and just store data
@@ -845,7 +845,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
         }
     }
 
-    fn insert_trusted_header(&self, name: String, value: String) {
+    fn insert_trusted_header(self, name: String, value: String) {
         // Insert a header without checking spec-compliance
         // Use for hardcoded headers
         let mut collection = self.request_headers.deref().borrow_mut();
@@ -857,7 +857,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
         collection.insert(maybe_header.unwrap());
     }
 
-    fn dispatch_progress_event(&self, upload: bool, type_: DOMString, loaded: u64, total: Option<u64>) {
+    fn dispatch_progress_event(self, upload: bool, type_: DOMString, loaded: u64, total: Option<u64>) {
         let global = self.global.root();
         let upload_target = *self.upload.root();
         let progressevent = ProgressEvent::new(&global.root_ref(),
@@ -867,25 +867,25 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
         let target: JSRef<EventTarget> = if upload {
             EventTargetCast::from_ref(upload_target)
         } else {
-            EventTargetCast::from_ref(*self)
+            EventTargetCast::from_ref(self)
         };
         let event: JSRef<Event> = EventCast::from_ref(*progressevent);
         target.dispatch_event_with_target(None, event).ok();
     }
 
-    fn dispatch_upload_progress_event(&self, type_: DOMString, partial_load: Option<u64>) {
+    fn dispatch_upload_progress_event(self, type_: DOMString, partial_load: Option<u64>) {
         // If partial_load is None, loading has completed and we can just use the value from the request body
 
         let total = self.request_body_len.get() as u64;
         self.dispatch_progress_event(true, type_, partial_load.unwrap_or(total), Some(total));
     }
 
-    fn dispatch_response_progress_event(&self, type_: DOMString) {
+    fn dispatch_response_progress_event(self, type_: DOMString) {
         let len = self.response.deref().borrow().len() as u64;
         let total = self.response_headers.deref().borrow().content_length.map(|x| {x as u64});
         self.dispatch_progress_event(false, type_, len, total);
     }
-    fn set_timeout(&self, timeout: u32) {
+    fn set_timeout(self, timeout: u32) {
         // Sets up the object to timeout in a given number of milliseconds
         // This will cancel all previous timeouts
         let oneshot = self.timer.deref().borrow_mut().oneshot(timeout as u64);
@@ -916,7 +916,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
         }
     );
     }
-    fn cancel_timeout(&self) {
+    fn cancel_timeout(self) {
         // Cancels timeouts on the object, if any
         if self.timeout_pinned.deref().get() {
             self.timeout_pinned.deref().set(false);
@@ -925,7 +925,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
         // oneshot() closes the previous channel, canceling the timeout
         self.timer.deref().borrow_mut().oneshot(0);
     }
-    fn text_response(&self) -> DOMString {
+    fn text_response(self) -> DOMString {
         let mut encoding = UTF_8 as EncodingRef;
         match self.response_headers.deref().borrow().content_type {
             Some(ref x) => {
@@ -941,7 +941,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
         // the result should be fine. XXXManishearth have a closer look at this later
         encoding.decode(self.response.deref().borrow().as_slice(), DecodeReplace).unwrap().to_string()
     }
-    fn filter_response_headers(&self) -> ResponseHeaderCollection {
+    fn filter_response_headers(self) -> ResponseHeaderCollection {
         // http://fetch.spec.whatwg.org/#concept-response-header-list
         let mut headers = ResponseHeaderCollection::new();
         for header in self.response_headers.deref().borrow().iter() {