Merge pull request #3433 from zwarich/jsref-self-helpers

More progress in the &JSRef -> JSRef conversion

1 files changed, 98 insertions, 98 deletions

diff --git a/components/script/dom/element.rs b/components/script/dom/element.rs
index 143f025fc72..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!();
@@ -271,7 +271,7 @@ impl<'a> ElementHelpers for JSRef<'a, Element> {
         summarized
     }
 
-   fn is_void(&self) -> bool {
+   fn is_void(self) -> bool {
         if self.namespace != namespace::HTML {
             return false
         }
@@ -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));
     }
@@ -506,24 +506,24 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
 
 impl<'a> ElementMethods for JSRef<'a, Element> {
     // http://dom.spec.whatwg.org/#dom-element-namespaceuri
-    fn GetNamespaceURI(&self) -> Option<DOMString> {
+    fn GetNamespaceURI(self) -> Option<DOMString> {
         match self.namespace {
             Null => None,
             ref ns => Some(ns.to_str().to_string())
         }
     }
 
-    fn LocalName(&self) -> DOMString {
+    fn LocalName(self) -> DOMString {
         self.local_name.as_slice().to_string()
     }
 
     // http://dom.spec.whatwg.org/#dom-element-prefix
-    fn GetPrefix(&self) -> Option<DOMString> {
+    fn GetPrefix(self) -> Option<DOMString> {
         self.prefix.clone()
     }
 
     // http://dom.spec.whatwg.org/#dom-element-tagname
-    fn TagName(&self) -> DOMString {
+    fn TagName(self) -> DOMString {
         let qualified_name = match self.prefix {
             Some(ref prefix) => format!("{}:{}", prefix, self.local_name).into_maybe_owned(),
             None => self.local_name.as_slice().into_maybe_owned()
@@ -536,31 +536,31 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
     }
 
     // http://dom.spec.whatwg.org/#dom-element-id
-    fn Id(&self) -> DOMString {
+    fn Id(self) -> DOMString {
         self.get_string_attribute("id")
     }
 
     // http://dom.spec.whatwg.org/#dom-element-id
-    fn SetId(&self, id: DOMString) {
+    fn SetId(self, id: DOMString) {
         self.set_atomic_attribute("id", id);
     }
 
     // http://dom.spec.whatwg.org/#dom-element-classname
-    fn ClassName(&self) -> DOMString {
+    fn ClassName(self) -> DOMString {
         self.get_string_attribute("class")
     }
 
     // http://dom.spec.whatwg.org/#dom-element-classname
-    fn SetClassName(&self, class: DOMString) {
+    fn SetClassName(self, class: DOMString) {
         self.set_tokenlist_attribute("class", class);
     }
 
     // http://dom.spec.whatwg.org/#dom-element-classlist
-    fn ClassList(&self) -> Temporary<DOMTokenList> {
+    fn ClassList(self) -> Temporary<DOMTokenList> {
         match self.class_list.get() {
             Some(class_list) => Temporary::new(class_list),
             None => {
-                let class_list = DOMTokenList::new(*self, "class").root();
+                let class_list = DOMTokenList::new(self, "class").root();
                 self.class_list.assign(Some(class_list.deref().clone()));
                 Temporary::from_rooted(*class_list)
             }
@@ -568,24 +568,24 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
     }
 
     // http://dom.spec.whatwg.org/#dom-element-attributes
-    fn Attributes(&self) -> Temporary<NamedNodeMap> {
+    fn Attributes(self) -> Temporary<NamedNodeMap> {
         match self.attr_list.get() {
             None => (),
             Some(ref list) => return Temporary::new(list.clone()),
         }
 
         let doc = {
-            let node: JSRef<Node> = NodeCast::from_ref(*self);
+            let node: JSRef<Node> = NodeCast::from_ref(self);
             node.owner_doc().root()
         };
         let window = doc.deref().window.root();
-        let list = NamedNodeMap::new(*window, *self);
+        let list = NamedNodeMap::new(*window, self);
         self.attr_list.assign(Some(list));
         Temporary::new(self.attr_list.get().get_ref().clone())
     }
 
     // http://dom.spec.whatwg.org/#dom-element-getattribute
-    fn GetAttribute(&self, name: DOMString) -> Option<DOMString> {
+    fn GetAttribute(self, name: DOMString) -> Option<DOMString> {
         let name = if self.html_element_in_html_document() {
             name.as_slice().to_ascii_lower()
         } else {
@@ -596,7 +596,7 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
     }
 
     // http://dom.spec.whatwg.org/#dom-element-getattributens
-    fn GetAttributeNS(&self,
+    fn GetAttributeNS(self,
                       namespace: Option<DOMString>,
                       local_name: DOMString) -> Option<DOMString> {
         let namespace = Namespace::from_str(null_str_as_empty_ref(&namespace));
@@ -605,11 +605,11 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
     }
 
     // http://dom.spec.whatwg.org/#dom-element-setattribute
-    fn SetAttribute(&self,
+    fn SetAttribute(self,
                     name: DOMString,
                     value: DOMString) -> ErrorResult {
         {
-            let node: JSRef<Node> = NodeCast::from_ref(*self);
+            let node: JSRef<Node> = NodeCast::from_ref(self);
             node.wait_until_safe_to_modify_dom();
         }
 
@@ -636,12 +636,12 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
     }
 
     // http://dom.spec.whatwg.org/#dom-element-setattributens
-    fn SetAttributeNS(&self,
+    fn SetAttributeNS(self,
                       namespace_url: Option<DOMString>,
                       name: DOMString,
                       value: DOMString) -> ErrorResult {
         {
-            let node: JSRef<Node> = NodeCast::from_ref(*self);
+            let node: JSRef<Node> = NodeCast::from_ref(self);
             node.wait_until_safe_to_modify_dom();
         }
 
@@ -705,7 +705,7 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
     }
 
     // http://dom.spec.whatwg.org/#dom-element-removeattribute
-    fn RemoveAttribute(&self, name: DOMString) {
+    fn RemoveAttribute(self, name: DOMString) {
         let name = if self.html_element_in_html_document() {
             name.as_slice().to_ascii_lower()
         } else {
@@ -715,7 +715,7 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
     }
 
     // http://dom.spec.whatwg.org/#dom-element-removeattributens
-    fn RemoveAttributeNS(&self,
+    fn RemoveAttributeNS(self,
                          namespace: Option<DOMString>,
                          localname: DOMString) {
         let namespace = Namespace::from_str(null_str_as_empty_ref(&namespace));
@@ -723,38 +723,38 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
     }
 
     // http://dom.spec.whatwg.org/#dom-element-hasattribute
-    fn HasAttribute(&self,
+    fn HasAttribute(self,
                     name: DOMString) -> bool {
         self.has_attribute(name.as_slice())
     }
 
     // http://dom.spec.whatwg.org/#dom-element-hasattributens
-    fn HasAttributeNS(&self,
+    fn HasAttributeNS(self,
                       namespace: Option<DOMString>,
                       local_name: DOMString) -> bool {
         self.GetAttributeNS(namespace, local_name).is_some()
     }
 
-    fn GetElementsByTagName(&self, localname: DOMString) -> Temporary<HTMLCollection> {
-        let window = window_from_node(*self).root();
-        HTMLCollection::by_tag_name(*window, NodeCast::from_ref(*self), localname)
+    fn GetElementsByTagName(self, localname: DOMString) -> Temporary<HTMLCollection> {
+        let window = window_from_node(self).root();
+        HTMLCollection::by_tag_name(*window, NodeCast::from_ref(self), localname)
     }
 
-    fn GetElementsByTagNameNS(&self, maybe_ns: Option<DOMString>,
+    fn GetElementsByTagNameNS(self, maybe_ns: Option<DOMString>,
                               localname: DOMString) -> Temporary<HTMLCollection> {
-        let window = window_from_node(*self).root();
-        HTMLCollection::by_tag_name_ns(*window, NodeCast::from_ref(*self), localname, maybe_ns)
+        let window = window_from_node(self).root();
+        HTMLCollection::by_tag_name_ns(*window, NodeCast::from_ref(self), localname, maybe_ns)
     }
 
-    fn GetElementsByClassName(&self, classes: DOMString) -> Temporary<HTMLCollection> {
-        let window = window_from_node(*self).root();
-        HTMLCollection::by_class_name(*window, NodeCast::from_ref(*self), classes)
+    fn GetElementsByClassName(self, classes: DOMString) -> Temporary<HTMLCollection> {
+        let window = window_from_node(self).root();
+        HTMLCollection::by_class_name(*window, NodeCast::from_ref(self), classes)
     }
 
     // http://dev.w3.org/csswg/cssom-view/#dom-element-getclientrects
-    fn GetClientRects(&self) -> Temporary<DOMRectList> {
-        let win = window_from_node(*self).root();
-        let node: JSRef<Node> = NodeCast::from_ref(*self);
+    fn GetClientRects(self) -> Temporary<DOMRectList> {
+        let win = window_from_node(self).root();
+        let node: JSRef<Node> = NodeCast::from_ref(self);
         let rects = node.get_content_boxes();
         let rects: Vec<Root<DOMRect>> = rects.iter().map(|r| {
             DOMRect::new(
@@ -769,9 +769,9 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
     }
 
     // http://dev.w3.org/csswg/cssom-view/#dom-element-getboundingclientrect
-    fn GetBoundingClientRect(&self) -> Temporary<DOMRect> {
-        let win = window_from_node(*self).root();
-        let node: JSRef<Node> = NodeCast::from_ref(*self);
+    fn GetBoundingClientRect(self) -> Temporary<DOMRect> {
+        let win = window_from_node(self).root();
+        let node: JSRef<Node> = NodeCast::from_ref(self);
         let rect = node.get_bounding_content_box();
         DOMRect::new(
             *win,
@@ -781,45 +781,45 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
             rect.origin.x + rect.size.width)
     }
 
-    fn GetInnerHTML(&self) -> Fallible<DOMString> {
+    fn GetInnerHTML(self) -> Fallible<DOMString> {
         //XXX TODO: XML case
-        Ok(serialize(&mut NodeIterator::new(NodeCast::from_ref(*self), false, false)))
+        Ok(serialize(&mut NodeIterator::new(NodeCast::from_ref(self), false, false)))
     }
 
-    fn GetOuterHTML(&self) -> Fallible<DOMString> {
-        Ok(serialize(&mut NodeIterator::new(NodeCast::from_ref(*self), true, false)))
+    fn GetOuterHTML(self) -> Fallible<DOMString> {
+        Ok(serialize(&mut NodeIterator::new(NodeCast::from_ref(self), true, false)))
     }
 
     // http://dom.spec.whatwg.org/#dom-parentnode-children
-    fn Children(&self) -> Temporary<HTMLCollection> {
-        let window = window_from_node(*self).root();
-        HTMLCollection::children(*window, NodeCast::from_ref(*self))
+    fn Children(self) -> Temporary<HTMLCollection> {
+        let window = window_from_node(self).root();
+        HTMLCollection::children(*window, NodeCast::from_ref(self))
     }
 
     // http://dom.spec.whatwg.org/#dom-parentnode-queryselector
-    fn QuerySelector(&self, selectors: DOMString) -> Fallible<Option<Temporary<Element>>> {
-        let root: JSRef<Node> = NodeCast::from_ref(*self);
+    fn QuerySelector(self, selectors: DOMString) -> Fallible<Option<Temporary<Element>>> {
+        let root: JSRef<Node> = NodeCast::from_ref(self);
         root.query_selector(selectors)
     }
 
     // http://dom.spec.whatwg.org/#dom-parentnode-queryselectorall
-    fn QuerySelectorAll(&self, selectors: DOMString) -> Fallible<Temporary<NodeList>> {
-        let root: JSRef<Node> = NodeCast::from_ref(*self);
+    fn QuerySelectorAll(self, selectors: DOMString) -> Fallible<Temporary<NodeList>> {
+        let root: JSRef<Node> = NodeCast::from_ref(self);
         root.query_selector_all(selectors)
     }
 
     // http://dom.spec.whatwg.org/#dom-childnode-remove
-    fn Remove(&self) {
-        let node: JSRef<Node> = NodeCast::from_ref(*self);
+    fn Remove(self) {
+        let node: JSRef<Node> = NodeCast::from_ref(self);
         node.remove_self();
     }
 
     // http://dom.spec.whatwg.org/#dom-element-matches
-    fn Matches(&self, selectors: DOMString) -> Fallible<bool> {
+    fn Matches(self, selectors: DOMString) -> Fallible<bool> {
         match parse_selector_list_from_str(selectors.as_slice()) {
             Err(()) => Err(Syntax),
             Ok(ref selectors) => {
-                let root: JSRef<Node> = NodeCast::from_ref(*self);
+                let root: JSRef<Node> = NodeCast::from_ref(self);
                 Ok(matches(selectors, &root, &mut None))
             }
         }