17 files changed, 196 insertions, 196 deletions

diff --git a/components/script/dom/attr.rs b/components/script/dom/attr.rs
index bf6880d1026..2da30a8c58c 100644
--- a/components/script/dom/attr.rs
+++ b/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(),
diff --git a/components/script/dom/dedicatedworkerglobalscope.rs b/components/script/dom/dedicatedworkerglobalscope.rs
index f707f6f8d55..4050e157dad 100644
--- a/components/script/dom/dedicatedworkerglobalscope.rs
+++ b/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));
     }
diff --git a/components/script/dom/document.rs b/components/script/dom/document.rs
index e9f16bc60e2..601a4c6162c 100644
--- a/components/script/dom/document.rs
+++ b/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 set_quirks_mode(&self, mode: QuirksMode);
-    fn set_last_modified(&self, value: DOMString);
-    fn set_encoding_name(&self, name: DOMString);
-    fn content_changed(&self);
-    fn damage_and_reflow(&self, damage: DocumentDamageLevel);
-    fn wait_until_safe_to_modify_dom(&self);
-    fn unregister_named_element(&self, to_unregister: JSRef<Element>, id: DOMString);
-    fn register_named_element(&self, element: JSRef<Element>, id: DOMString);
-    fn load_anchor_href(&self, href: DOMString);
+    fn quirks_mode(self) -> QuirksMode;
+    fn set_quirks_mode(self, mode: QuirksMode);
+    fn set_last_modified(self, value: DOMString);
+    fn set_encoding_name(self, name: DOMString);
+    fn content_changed(self);
+    fn damage_and_reflow(self, damage: DocumentDamageLevel);
+    fn wait_until_safe_to_modify_dom(self);
+    fn unregister_named_element(self, to_unregister: JSRef<Element>, id: DOMString);
+    fn register_named_element(self, element: JSRef<Element>, id: 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 get_html_element(&self) -> Option<Temporary<HTMLHtmlElement>>;
+    fn createNodeList(self, callback: |node: JSRef<Node>| -> bool) -> Temporary<NodeList>;
+    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)
diff --git a/components/script/dom/domtokenlist.rs b/components/script/dom/domtokenlist.rs
index fc4fefb3ec0..8e44de023b9 100644
--- a/components/script/dom/domtokenlist.rs
+++ b/components/script/dom/domtokenlist.rs
@@ -49,17 +49,17 @@ impl Reflectable for DOMTokenList {
 }
 
 trait PrivateDOMTokenListHelpers {
-    fn attribute(&self) -> Option<Temporary<Attr>>;
-    fn check_token_exceptions<'a>(&self, token: &'a str) -> Fallible<&'a str>;
+    fn attribute(self) -> Option<Temporary<Attr>>;
+    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),
diff --git a/components/script/dom/element.rs b/components/script/dom/element.rs
index 4101c7e074e..612188f7be1 100644
--- a/components/script/dom/element.rs
+++ b/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 is_void(&self) -> bool;
+    fn summarize(self) -> Vec<AttrInfo>;
+    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 do_set_attribute(&self, local_name: Atom, value: AttrValue,
+    fn set_attribute(self, name: &str, 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 notify_attribute_changed(&self, local_name: &Atom);
+    fn remove_attribute(self, namespace: Namespace, name: &str);
+    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 set_bool_attribute(&self, name: &str, value: bool);
-    fn get_url_attribute(&self, name: &str) -> DOMString;
-    fn set_url_attribute(&self, name: &str, value: DOMString);
-    fn get_string_attribute(&self, name: &str) -> DOMString;
-    fn set_string_attribute(&self, name: &str, value: DOMString);
-    fn set_tokenlist_attribute(&self, name: &str, value: DOMString);
-    fn get_uint_attribute(&self, name: &str) -> u32;
-    fn set_uint_attribute(&self, name: &str, value: u32);
+    fn has_attribute(self, name: &str) -> bool;
+    fn set_bool_attribute(self, name: &str, value: bool);
+    fn get_url_attribute(self, name: &str) -> DOMString;
+    fn set_url_attribute(self, name: &str, value: DOMString);
+    fn get_string_attribute(self, name: &str) -> DOMString;
+    fn set_string_attribute(self, name: &str, value: DOMString);
+    fn set_tokenlist_attribute(self, name: &str, value: DOMString);
+    fn get_uint_attribute(self, name: &str) -> 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) {
-        let node: JSRef<Node> = NodeCast::from_ref(*self);
+    fn notify_attribute_changed(self, local_name: &Atom) {
+        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));
     }
diff --git a/components/script/dom/eventtarget.rs b/components/script/dom/eventtarget.rs
index d2c2dcb7585..ebe904bc476 100644
--- a/components/script/dom/eventtarget.rs
+++ b/components/script/dom/eventtarget.rs
@@ -94,37 +94,37 @@ impl EventTarget {
 }
 
 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(&self,
+    fn dispatch_event_with_target(self,
+                                  target: Option<JSRef<EventTarget>>,
+                                  event: JSRef<Event>) -> Fallible<bool>;
+    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(&self,
+    fn get_inline_event_listener(self, ty: DOMString) -> Option<EventListener>;
+    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,
-                                      target: Option<JSRef<'b, EventTarget>>,
-                                      event: JSRef<Event>) -> Fallible<bool> {
+    fn dispatch_event_with_target(self,
+                                  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()
     }
 }
diff --git a/components/script/dom/htmlanchorelement.rs b/components/script/dom/htmlanchorelement.rs
index 728b9c07fb6..6414c7d0c3c 100644
--- a/components/script/dom/htmlanchorelement.rs
+++ b/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);
                 }
diff --git a/components/script/dom/htmlelement.rs b/components/script/dom/htmlelement.rs
index 4d9dccab7c9..1ae99e4367e 100644
--- a/components/script/dom/htmlelement.rs
+++ b/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 {
-        let eventtarget: JSRef<EventTarget> = EventTargetCast::from_ref(*self);
+    fn is_body_or_frameset(self) -> bool {
+        let eventtarget: JSRef<EventTarget> = EventTargetCast::from_ref(self);
         eventtarget.is_htmlbodyelement() || eventtarget.is_htmlframesetelement()
     }
 }
diff --git a/components/script/dom/htmliframeelement.rs b/components/script/dom/htmliframeelement.rs
index 0c2e5d4d6b4..0079f51fb30 100644
--- a/components/script/dom/htmliframeelement.rs
+++ b/components/script/dom/htmliframeelement.rs
@@ -62,32 +62,32 @@ pub struct IFrameSize {
 }
 
 pub trait HTMLIFrameElementHelpers {
-    fn is_sandboxed(&self) -> bool;
-    fn get_url(&self) -> Option<Url>;
+    fn is_sandboxed(self) -> bool;
+    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> {
-        let element: JSRef<Element> = ElementCast::from_ref(*self);
+    fn get_url(self) -> Option<Url> {
+        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();
 
diff --git a/components/script/dom/htmlimageelement.rs b/components/script/dom/htmlimageelement.rs
index faac2c8d037..91fcad5603c 100644
--- a/components/script/dom/htmlimageelement.rs
+++ b/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)>) {
-        let node: JSRef<Node> = NodeCast::from_ref(*self);
+    fn update_image(self, value: Option<(DOMString, &Url)>) {
+        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;
diff --git a/components/script/dom/htmllinkelement.rs b/components/script/dom/htmllinkelement.rs
index 6b88948fe02..46050c8ca82 100644
--- a/components/script/dom/htmllinkelement.rs
+++ b/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) {
-        let window = window_from_node(*self).root();
+    fn handle_stylesheet_url(self, href: &str) {
+        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;
diff --git a/components/script/dom/htmlscriptelement.rs b/components/script/dom/htmlscriptelement.rs
index d16fc56d72f..d733cbb45ea 100644
--- a/components/script/dom/htmlscriptelement.rs
+++ b/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 {
-        let element: JSRef<Element> = ElementCast::from_ref(*self);
+    fn is_javascript(self) -> bool {
+        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
diff --git a/components/script/dom/htmlstyleelement.rs b/components/script/dom/htmlstyleelement.rs
index 52ccfde5488..3dea1745240 100644
--- a/components/script/dom/htmlstyleelement.rs
+++ b/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) {
-        let node: JSRef<Node> = NodeCast::from_ref(*self);
+    fn parse_own_css(self) {
+        let node: JSRef<Node> = NodeCast::from_ref(self);
         assert!(node.is_in_doc());
 
         let win = window_from_node(node).root();
diff --git a/components/script/dom/performancetiming.rs b/components/script/dom/performancetiming.rs
index 299c6eb6b16..25773ac42c9 100644
--- a/components/script/dom/performancetiming.rs
+++ b/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
     }
 }
diff --git a/components/script/dom/treewalker.rs b/components/script/dom/treewalker.rs
index e1d49be408f..cac3776e0ac 100644
--- a/components/script/dom/treewalker.rs
+++ b/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_current_node(&self, node: JSRef<'a, Node>) -> bool;
-    fn first_following_node_not_following_root(&self, node: JSRef<'a, Node>)
+    fn is_root_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>)
                                                -> 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 first_child(&self) -> Fallible<Option<Temporary<Node>>>;
-    fn last_child(&self) -> Fallible<Option<Temporary<Node>>>;
-    fn next_sibling(&self) -> Fallible<Option<Temporary<Node>>>;
-    fn prev_sibling(&self) -> Fallible<Option<Temporary<Node>>>;
-    fn next_node(&self) -> Fallible<Option<Temporary<Node>>>;
-    fn prev_node(&self) -> Fallible<Option<Temporary<Node>>>;
+    fn parent_node(self) -> Fallible<Option<Temporary<Node>>>;
+    fn first_child(self) -> Fallible<Option<Temporary<Node>>>;
+    fn last_child(self) -> Fallible<Option<Temporary<Node>>>;
+    fn next_sibling(self) -> Fallible<Option<Temporary<Node>>>;
+    fn prev_sibling(self) -> Fallible<Option<Temporary<Node>>>;
+    fn next_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."
diff --git a/components/script/dom/window.rs b/components/script/dom/window.rs
index fd147aaefdf..631dfbec858 100644
--- a/components/script/dom/window.rs
+++ b/components/script/dom/window.rs
@@ -364,21 +364,21 @@ impl Reflectable for Window {
 }
 
 pub trait WindowHelpers {
-    fn damage_and_reflow(&self, damage: DocumentDamageLevel);
-    fn flush_layout(&self, goal: ReflowGoal);
-    fn wait_until_safe_to_modify_dom(&self);
-    fn init_browser_context(&self, doc: JSRef<Document>);
-    fn load_url(&self, href: DOMString);
-    fn handle_fire_timer(&self, timer_id: TimerId, cx: *mut JSContext);
-    fn evaluate_js_with_result(&self, code: &str) -> JSVal;
+    fn damage_and_reflow(self, damage: DocumentDamageLevel);
+    fn flush_layout(self, goal: ReflowGoal);
+    fn wait_until_safe_to_modify_dom(self);
+    fn init_browser_context(self, doc: JSRef<Document>);
+    fn load_url(self, href: DOMString);
+    fn handle_fire_timer(self, timer_id: TimerId, cx: *mut JSContext);
+    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);
diff --git a/components/script/dom/xmlhttprequest.rs b/components/script/dom/xmlhttprequest.rs
index 3afbe1ecb72..42ff2f483cb 100644
--- a/components/script/dom/xmlhttprequest.rs
+++ b/components/script/dom/xmlhttprequest.rs
@@ -692,23 +692,23 @@ impl TrustedXHRAddress {
 
 
 trait PrivateXMLHttpRequestHelpers {
-    unsafe fn to_trusted(&self) -> TrustedXHRAddress;
-    fn release_once(&self);
-    fn change_ready_state(&self, XMLHttpRequestState);
-    fn process_partial_response(&self, progress: XHRProgress);
-    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_upload_progress_event(&self, type_: DOMString, partial_load: Option<u64>);
-    fn dispatch_response_progress_event(&self, type_: DOMString);
-    fn text_response(&self) -> DOMString;
-    fn set_timeout(&self, timeout:u32);
-    fn cancel_timeout(&self);
-    fn filter_response_headers(&self) -> ResponseHeaderCollection;
+    unsafe fn to_trusted(self) -> TrustedXHRAddress;
+    fn release_once(self);
+    fn change_ready_state(self, XMLHttpRequestState);
+    fn process_partial_response(self, progress: XHRProgress);
+    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_upload_progress_event(self, type_: DOMString, partial_load: Option<u64>);
+    fn dispatch_response_progress_event(self, type_: DOMString);
+    fn text_response(self) -> DOMString;
+    fn set_timeout(self, timeout:u32);
+    fn cancel_timeout(self);
+    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() {