Remove needless '&self mut' from VirtualMethods trait.

src/components/script/dom/attr.rs

@@ -66,8 +66,8 @@ impl Attr {
     }
 
     pub fn set_value(&mut self, set_type: AttrSettingType, value: DOMString) {
-        let mut owner = self.owner.get().root();
+        let owner = self.owner.get().root();
-        let node: &mut JSRef<Node> = NodeCast::from_mut_ref(&mut *owner);
+        let node: &JSRef<Node> = NodeCast::from_ref(&*owner);
         let namespace_is_null = self.namespace == namespace::Null;
 
         match set_type {

src/components/script/dom/element.rs

@@ -319,8 +319,7 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
 
                 if namespace == namespace::Null {
                     let removed_raw_value = self.deref().attrs.borrow().get(idx).root().Value();
-                    let mut self_alias = self.clone();
+                    vtable_for(NodeCast::from_ref(self))
-                    vtable_for(NodeCast::from_mut_ref(&mut self_alias))
                         .before_remove_attr(local_name.clone(), removed_raw_value);
                 }
 
@@ -715,14 +714,14 @@ pub fn get_attribute_parts(name: DOMString) -> (Option<String>, String) {
 }
 
 impl<'a> VirtualMethods for JSRef<'a, Element> {
-    fn super_type<'a>(&'a mut self) -> Option<&'a mut VirtualMethods:> {
+    fn super_type<'a>(&'a self) -> Option<&'a VirtualMethods:> {
-        let node: &mut JSRef<Node> = NodeCast::from_mut_ref(self);
+        let node: &JSRef<Node> = NodeCast::from_ref(self);
-        Some(node as &mut VirtualMethods:)
+        Some(node as &VirtualMethods:)
     }
 
-    fn after_set_attr(&mut self, name: DOMString, value: DOMString) {
+    fn after_set_attr(&self, name: DOMString, value: DOMString) {
         match self.super_type() {
-            Some(ref mut s) => s.after_set_attr(name.clone(), value.clone()),
+            Some(ref s) => s.after_set_attr(name.clone(), value.clone()),
             _ => (),
         }
 
@@ -730,7 +729,8 @@ impl<'a> VirtualMethods for JSRef<'a, Element> {
             "style" => {
                 let doc = document_from_node(self).root();
                 let base_url = doc.deref().url().clone();
-                self.deref_mut().style_attribute = Some(style::parse_style_attribute(value.as_slice(), &base_url))
+                let mut self_alias = self.clone();
+                self_alias.deref_mut().style_attribute = Some(style::parse_style_attribute(value.as_slice(), &base_url))
             }
             "id" => {
                 let node: &JSRef<Node> = NodeCast::from_ref(self);
@@ -745,15 +745,16 @@ impl<'a> VirtualMethods for JSRef<'a, Element> {
         self.notify_attribute_changed(name);
     }
 
-    fn before_remove_attr(&mut self, name: DOMString, value: DOMString) {
+    fn before_remove_attr(&self, name: DOMString, value: DOMString) {
         match self.super_type() {
-            Some(ref mut s) => s.before_remove_attr(name.clone(), value.clone()),
+            Some(ref s) => s.before_remove_attr(name.clone(), value.clone()),
             _ => (),
         }
 
         match name.as_slice() {
             "style" => {
-                self.deref_mut().style_attribute = None
+                let mut self_alias = self.clone();
+                self_alias.deref_mut().style_attribute = None
             }
             "id" => {
                 let node: &JSRef<Node> = NodeCast::from_ref(self);
@@ -768,9 +769,9 @@ impl<'a> VirtualMethods for JSRef<'a, Element> {
         self.notify_attribute_changed(name);
     }
 
-    fn bind_to_tree(&mut self) {
+    fn bind_to_tree(&self) {
         match self.super_type() {
-            Some(ref mut s) => s.bind_to_tree(),
+            Some(ref s) => s.bind_to_tree(),
             _ => (),
         }
 
@@ -783,9 +784,9 @@ impl<'a> VirtualMethods for JSRef<'a, Element> {
         }
     }
 
-    fn unbind_from_tree(&mut self) {
+    fn unbind_from_tree(&self) {
         match self.super_type() {
-            Some(ref mut s) => s.unbind_from_tree(),
+            Some(ref s) => s.unbind_from_tree(),
             _ => (),
         }
 

src/components/script/dom/eventdispatcher.rs

@@ -118,7 +118,7 @@ pub fn dispatch_event<'a, 'b>(target: &JSRef<'a, EventTarget>,
     let target = event.GetTarget().root();
     match target {
         Some(mut target) => {
-            let node: Option<&mut JSRef<Node>> = NodeCast::to_mut_ref(&mut *target);
+            let node: Option<&JSRef<Node>> = NodeCast::to_ref(&mut *target);
             match node {
                 Some(node) =>{
                     let vtable = vtable_for(node);

src/components/script/dom/eventtarget.rs

@@ -267,7 +267,7 @@ impl Reflectable for EventTarget {
 }
 
 impl<'a> VirtualMethods for JSRef<'a, EventTarget> {
-    fn super_type<'a>(&'a mut self) -> Option<&'a mut VirtualMethods:> {
+    fn super_type<'a>(&'a self) -> Option<&'a VirtualMethods:> {
         None
     }
 }

src/components/script/dom/htmlanchorelement.rs

@@ -68,12 +68,12 @@ impl<'a> PrivateHTMLAnchorElementHelpers for JSRef<'a, HTMLAnchorElement> {
 }
 
 impl<'a> VirtualMethods for JSRef<'a, HTMLAnchorElement> {
-    fn super_type<'a>(&'a mut self) -> Option<&'a mut VirtualMethods:> {
+    fn super_type<'a>(&'a self) -> Option<&'a VirtualMethods:> {
-        let htmlelement: &mut JSRef<HTMLElement> = HTMLElementCast::from_mut_ref(self);
+        let htmlelement: &JSRef<HTMLElement> = HTMLElementCast::from_ref(self);
-        Some(htmlelement as &mut VirtualMethods:)
+        Some(htmlelement as &VirtualMethods:)
     }
 
-    fn handle_event(&mut self, event: &JSRef<Event>) {
+    fn handle_event(&self, event: &JSRef<Event>) {
         match self.super_type() {
             Some(s) => {
                 s.handle_event(event);

src/components/script/dom/htmlbodyelement.rs

@@ -59,14 +59,14 @@ impl<'a> HTMLBodyElementMethods for JSRef<'a, HTMLBodyElement> {
 }
 
 impl<'a> VirtualMethods for JSRef<'a, HTMLBodyElement> {
-    fn super_type<'a>(&'a mut self) -> Option<&'a mut VirtualMethods:> {
+    fn super_type<'a>(&'a self) -> Option<&'a VirtualMethods:> {
-        let element: &mut JSRef<HTMLElement> = HTMLElementCast::from_mut_ref(self);
+        let element: &JSRef<HTMLElement> = HTMLElementCast::from_ref(self);
-        Some(element as &mut VirtualMethods:)
+        Some(element as &VirtualMethods:)
     }
 
-    fn after_set_attr(&mut self, name: DOMString, value: DOMString) {
+    fn after_set_attr(&self, name: DOMString, value: DOMString) {
         match self.super_type() {
-            Some(ref mut s) => s.after_set_attr(name.clone(), value.clone()),
+            Some(ref s) => s.after_set_attr(name.clone(), value.clone()),
             _ => (),
         }
 
@@ -80,11 +80,12 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLBodyElement> {
             let (cx, url, reflector) = (window.get_cx(),
                                         window.get_url(),
                                         window.reflector().get_jsobject());
+            let mut self_alias = self.clone();
             let evtarget: &mut JSRef<EventTarget> =
                 if forwarded_events.iter().any(|&event| name.as_slice() == event) {
                     EventTargetCast::from_mut_ref(&mut *window)
                 } else {
-                    EventTargetCast::from_mut_ref(self)
+                    EventTargetCast::from_mut_ref(&mut self_alias)
                 };
             evtarget.set_event_handler_uncompiled(cx, url, reflector,
                                                   name.as_slice().slice_from(2),

src/components/script/dom/htmlelement.rs

@@ -80,8 +80,8 @@ impl<'a> HTMLElementMethods for JSRef<'a, HTMLElement> {
 }
 
 impl<'a> VirtualMethods for JSRef<'a, HTMLElement> {
-    fn super_type<'a>(&'a mut self) -> Option<&'a mut VirtualMethods:> {
+    fn super_type<'a>(&'a self) -> Option<&'a VirtualMethods:> {
-        let element: &mut JSRef<Element> = ElementCast::from_mut_ref(self);
+        let element: &JSRef<Element> = ElementCast::from_ref(self);
-        Some(element as &mut VirtualMethods:)
+        Some(element as &VirtualMethods:)
     }
 }

src/components/script/dom/htmliframeelement.rs

@@ -122,14 +122,14 @@ impl<'a> HTMLIFrameElementMethods for JSRef<'a, HTMLIFrameElement> {
 }
 
 impl<'a> VirtualMethods for JSRef<'a, HTMLIFrameElement> {
-    fn super_type<'a>(&'a mut self) -> Option<&'a mut VirtualMethods:> {
+    fn super_type<'a>(&'a self) -> Option<&'a VirtualMethods:> {
-        let htmlelement: &mut JSRef<HTMLElement> = HTMLElementCast::from_mut_ref(self);
+        let htmlelement: &JSRef<HTMLElement> = HTMLElementCast::from_ref(self);
-        Some(htmlelement as &mut VirtualMethods:)
+        Some(htmlelement as &VirtualMethods:)
     }
 
-    fn after_set_attr(&mut self, name: DOMString, value: DOMString) {
+    fn after_set_attr(&self, name: DOMString, value: DOMString) {
         match self.super_type() {
-            Some(ref mut s) => s.after_set_attr(name.clone(), value.clone()),
+            Some(ref s) => s.after_set_attr(name.clone(), value.clone()),
             _ => (),
         }
 
@@ -146,24 +146,26 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLIFrameElement> {
                     _ => AllowNothing
                 } as u8;
             }
-            self.deref_mut().sandbox = Some(modes);
+            let mut self_alias = self.clone();
+            self_alias.deref_mut().sandbox = Some(modes);
         }
     }
 
-    fn before_remove_attr(&mut self, name: DOMString, value: DOMString) {
+    fn before_remove_attr(&self, name: DOMString, value: DOMString) {
         match self.super_type() {
-            Some(ref mut s) => s.before_remove_attr(name.clone(), value),
+            Some(ref s) => s.before_remove_attr(name.clone(), value),
             _ => (),
         }
 
         if "sandbox" == name.as_slice() {
-            self.deref_mut().sandbox = None;
+            let mut self_alias = self.clone();
+            self_alias.deref_mut().sandbox = None;
         }
     }
 
-    fn bind_to_tree(&mut self) {
+    fn bind_to_tree(&self) {
         match self.super_type() {
-            Some(ref mut s) => s.bind_to_tree(),
+            Some(ref s) => s.bind_to_tree(),
             _ => (),
         }
 
@@ -180,7 +182,8 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLIFrameElement> {
                 let page = window.deref().page();
                 let subpage_id = page.get_next_subpage_id();
 
-                self.deref_mut().size = Some(IFrameSize {
+                let mut self_alias = self.clone();
+                self_alias.deref_mut().size = Some(IFrameSize {
                     pipeline_id: page.id,
                     subpage_id: subpage_id,
                 });

src/components/script/dom/htmlimageelement.rs

@@ -239,32 +239,34 @@ impl<'a> HTMLImageElementMethods for JSRef<'a, HTMLImageElement> {
 }
 
 impl<'a> VirtualMethods for JSRef<'a, HTMLImageElement> {
-    fn super_type<'a>(&'a mut self) -> Option<&'a mut VirtualMethods:> {
+    fn super_type<'a>(&'a self) -> Option<&'a VirtualMethods:> {
-        let htmlelement: &mut JSRef<HTMLElement> = HTMLElementCast::from_mut_ref(self);
+        let htmlelement: &JSRef<HTMLElement> = HTMLElementCast::from_ref(self);
-        Some(htmlelement as &mut VirtualMethods:)
+        Some(htmlelement as &VirtualMethods:)
     }
 
-    fn after_set_attr(&mut self, name: DOMString, value: DOMString) {
+    fn after_set_attr(&self, name: DOMString, value: DOMString) {
         match self.super_type() {
-            Some(ref mut s) => s.after_set_attr(name.clone(), value.clone()),
+            Some(ref s) => s.after_set_attr(name.clone(), value.clone()),
             _ => (),
         }
 
         if "src" == name.as_slice() {
             let window = window_from_node(self).root();
             let url = Some(window.deref().get_url());
-            self.update_image(Some(value), url);
+            let mut self_alias = self.clone();
+            self_alias.update_image(Some(value), url);
         }
     }
 
-    fn before_remove_attr(&mut self, name: DOMString, value: DOMString) {
+    fn before_remove_attr(&self, name: DOMString, value: DOMString) {
         match self.super_type() {
-            Some(ref mut s) => s.before_remove_attr(name.clone(), value.clone()),
+            Some(ref s) => s.before_remove_attr(name.clone(), value.clone()),
             _ => (),
         }
 
         if "src" == name.as_slice() {
-            self.update_image(None, None);
+            let mut self_alias = self.clone();
+            self_alias.update_image(None, None);
         }
     }
 }

src/components/script/dom/htmlobjectelement.rs

@@ -85,14 +85,14 @@ impl<'a> HTMLObjectElementMethods for JSRef<'a, HTMLObjectElement> {
 }
 
 impl<'a> VirtualMethods for JSRef<'a, HTMLObjectElement> {
-    fn super_type<'a>(&'a mut self) -> Option<&'a mut VirtualMethods:> {
+    fn super_type<'a>(&'a self) -> Option<&'a VirtualMethods:> {
-        let htmlelement: &mut JSRef<HTMLElement> = HTMLElementCast::from_mut_ref(self);
+        let htmlelement: &JSRef<HTMLElement> = HTMLElementCast::from_ref(self);
-        Some(htmlelement as &mut VirtualMethods:)
+        Some(htmlelement as &VirtualMethods:)
     }
 
-    fn after_set_attr(&mut self, name: DOMString, value: DOMString) {
+    fn after_set_attr(&self, name: DOMString, value: DOMString) {
         match self.super_type() {
-            Some(ref mut s) => s.after_set_attr(name.clone(), value),
+            Some(ref s) => s.after_set_attr(name.clone(), value),
             _ => (),
         }
 

src/components/script/dom/htmlstyleelement.rs

@@ -60,14 +60,14 @@ impl<'a> StyleElementHelpers for JSRef<'a, HTMLStyleElement> {
 }
 
 impl<'a> VirtualMethods for JSRef<'a, HTMLStyleElement> {
-    fn super_type<'a>(&'a mut self) -> Option<&'a mut VirtualMethods:> {
+    fn super_type<'a>(&'a self) -> Option<&'a VirtualMethods:> {
-        let htmlelement: &mut JSRef<HTMLElement> = HTMLElementCast::from_mut_ref(self);
+        let htmlelement: &JSRef<HTMLElement> = HTMLElementCast::from_ref(self);
-        Some(htmlelement as &mut VirtualMethods:)
+        Some(htmlelement as &VirtualMethods:)
     }
 
-    fn child_inserted(&mut self, child: &JSRef<Node>) {
+    fn child_inserted(&self, child: &JSRef<Node>) {
         match self.super_type() {
-            Some(ref mut s) => s.child_inserted(child),
+            Some(ref s) => s.child_inserted(child),
             _ => (),
         }
         self.parse_own_css();

src/components/script/dom/node.rs

@@ -236,13 +236,13 @@ impl<'a> PrivateNodeHelpers for JSRef<'a, Node> {
         let document = document_from_node(self).root();
 
         if self.is_in_doc() {
-            for mut node in self.traverse_preorder() {
+            for node in self.traverse_preorder() {
-                vtable_for(&mut node).bind_to_tree();
+                vtable_for(&node).bind_to_tree();
             }
         }
 
-        let mut parent = self.parent_node().root();
+        let parent = self.parent_node().root();
-        parent.as_mut().map(|parent| vtable_for(&mut **parent).child_inserted(self));
+        parent.map(|parent| vtable_for(&*parent).child_inserted(self));
 
         document.deref().content_changed();
     }
@@ -252,9 +252,9 @@ impl<'a> PrivateNodeHelpers for JSRef<'a, Node> {
         assert!(self.parent_node().is_none());
         let document = document_from_node(self).root();
 
-        for mut node in self.traverse_preorder() {
+        for node in self.traverse_preorder() {
             // XXX how about if the node wasn't in the tree in the first place?
-            vtable_for(&mut node).unbind_from_tree();
+            vtable_for(&node).unbind_from_tree();
         }
 
         document.deref().content_changed();
@@ -1895,8 +1895,8 @@ pub fn window_from_node<T: NodeBase>(derived: &JSRef<T>) -> Temporary<Window> {
 }
 
 impl<'a> VirtualMethods for JSRef<'a, Node> {
-    fn super_type<'a>(&'a mut self) -> Option<&'a mut VirtualMethods:> {
+    fn super_type<'a>(&'a self) -> Option<&'a VirtualMethods:> {
-        let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self);
+        let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
-        Some(eventtarget as &mut VirtualMethods:)
+        Some(eventtarget as &VirtualMethods:)
     }
 }

src/components/script/dom/virtualmethods.rs

@@ -30,52 +30,52 @@ use servo_util::str::DOMString;
 pub trait VirtualMethods {
     /// Returns self as the superclass of the implementation for this trait,
     /// if any.
-    fn super_type<'a>(&'a mut self) -> Option<&'a mut VirtualMethods:>;
+    fn super_type<'a>(&'a self) -> Option<&'a VirtualMethods:>;
 
     /// Called when changing or adding attributes, after the attribute's value
     /// has been updated.
-    fn after_set_attr(&mut self, name: DOMString, value: DOMString) {
+    fn after_set_attr(&self, name: DOMString, value: DOMString) {
         match self.super_type() {
-            Some(ref mut s) => s.after_set_attr(name, value),
+            Some(ref s) => s.after_set_attr(name, value),
             _ => (),
         }
     }
 
     /// Called when changing or removing attributes, before any modification
     /// has taken place.
-    fn before_remove_attr(&mut self, name: DOMString, value: DOMString) {
+    fn before_remove_attr(&self, name: DOMString, value: DOMString) {
         match self.super_type() {
-            Some(ref mut s) => s.before_remove_attr(name, value),
+            Some(ref s) => s.before_remove_attr(name, value),
             _ => (),
         }
     }
 
     /// Called when a Node is appended to a tree that is part of a Document.
-    fn bind_to_tree(&mut self) {
+    fn bind_to_tree(&self) {
         match self.super_type() {
-            Some(ref mut s) => s.bind_to_tree(),
+            Some(ref s) => s.bind_to_tree(),
             _ => (),
         }
     }
 
     /// Called when a Node is removed from a tree that is part of a Document.
-    fn unbind_from_tree(&mut self) {
+    fn unbind_from_tree(&self) {
         match self.super_type() {
-            Some(ref mut s) => s.unbind_from_tree(),
+            Some(ref s) => s.unbind_from_tree(),
             _ => (),
         }
     }
 
     /// Called on the parent when a node is added to its child list.
-    fn child_inserted(&mut self, child: &JSRef<Node>) {
+    fn child_inserted(&self, child: &JSRef<Node>) {
         match self.super_type() {
-            Some(ref mut s) => s.child_inserted(child),
+            Some(ref s) => s.child_inserted(child),
             _ => (),
         }
     }
 
     /// Called during event dispatch after the bubbling phase completes.
-    fn handle_event(&mut self, event: &JSRef<Event>) {
+    fn handle_event(&self, event: &JSRef<Event>) {
         match self.super_type() {
             Some(s) => {
                 s.handle_event(event);
@@ -89,42 +89,42 @@ pub trait VirtualMethods {
 /// method call on the trait object will invoke the corresponding method on the
 /// concrete type, propagating up the parent hierarchy unless otherwise
 /// interrupted.
-pub fn vtable_for<'a>(node: &'a mut JSRef<Node>) -> &'a mut VirtualMethods: {
+pub fn vtable_for<'a>(node: &'a JSRef<Node>) -> &'a VirtualMethods: {
     match node.type_id() {
         ElementNodeTypeId(HTMLAnchorElementTypeId) => {
-            let element: &mut JSRef<HTMLAnchorElement> = HTMLAnchorElementCast::to_mut_ref(node).unwrap();
+            let element: &JSRef<HTMLAnchorElement> = HTMLAnchorElementCast::to_ref(node).unwrap();
-            element as &mut VirtualMethods:
+            element as &VirtualMethods:
         }
         ElementNodeTypeId(HTMLBodyElementTypeId) => {
-            let element: &mut JSRef<HTMLBodyElement> = HTMLBodyElementCast::to_mut_ref(node).unwrap();
+            let element: &JSRef<HTMLBodyElement> = HTMLBodyElementCast::to_ref(node).unwrap();
-            element as &mut VirtualMethods:
+            element as &VirtualMethods:
         }
         ElementNodeTypeId(HTMLImageElementTypeId) => {
-            let element: &mut JSRef<HTMLImageElement> = HTMLImageElementCast::to_mut_ref(node).unwrap();
+            let element: &JSRef<HTMLImageElement> = HTMLImageElementCast::to_ref(node).unwrap();
-            element as &mut VirtualMethods:
+            element as &VirtualMethods:
         }
         ElementNodeTypeId(HTMLIFrameElementTypeId) => {
-            let element: &mut JSRef<HTMLIFrameElement> = HTMLIFrameElementCast::to_mut_ref(node).unwrap();
+            let element: &JSRef<HTMLIFrameElement> = HTMLIFrameElementCast::to_ref(node).unwrap();
-            element as &mut VirtualMethods:
+            element as &VirtualMethods:
         }
         ElementNodeTypeId(HTMLObjectElementTypeId) => {
-            let element: &mut JSRef<HTMLObjectElement> = HTMLObjectElementCast::to_mut_ref(node).unwrap();
+            let element: &JSRef<HTMLObjectElement> = HTMLObjectElementCast::to_ref(node).unwrap();
-            element as &mut VirtualMethods:
+            element as &VirtualMethods:
         }
         ElementNodeTypeId(HTMLStyleElementTypeId) => {
-            let element: &mut JSRef<HTMLStyleElement> = HTMLStyleElementCast::to_mut_ref(node).unwrap();
+            let element: &JSRef<HTMLStyleElement> = HTMLStyleElementCast::to_ref(node).unwrap();
-            element as &mut VirtualMethods:
+            element as &VirtualMethods:
         }
         ElementNodeTypeId(ElementTypeId) => {
-            let element: &mut JSRef<Element> = ElementCast::to_mut_ref(node).unwrap();
+            let element: &JSRef<Element> = ElementCast::to_ref(node).unwrap();
-            element as &mut VirtualMethods:
+            element as &VirtualMethods:
         }
         ElementNodeTypeId(_) => {
-            let element: &mut JSRef<HTMLElement> = HTMLElementCast::to_mut_ref(node).unwrap();
+            let element: &JSRef<HTMLElement> = HTMLElementCast::to_ref(node).unwrap();
-            element as &mut VirtualMethods:
+            element as &VirtualMethods:
         }
         _ => {
-            node as &mut VirtualMethods:
+            node as &VirtualMethods:
         }
     }
 }