Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-03 20:50:07 +01:00
Code Issues Projects Releases Packages Wiki Activity

Remove needless '&self mut' from VirtualMethods trait.

Browse source
This commit is contained in:
Tetsuharu OHZEKI 2014-06-06 23:17:50 +09:00
parent d8483d2365
commit 2aa1554b0c
13 changed files with 109 additions and 102 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/components/script/dom/attr.rs
View file

@ -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 node: &mut JSRef<Node> = NodeCast::from_mut_ref(&mut *owner);
let owner = self.owner.get().root();
let node: &JSRef<Node> = NodeCast::from_ref(&*owner);
let namespace_is_null = self.namespace == namespace::Null;
match set_type {

31
src/components/script/dom/element.rs
View file

@ -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_mut_ref(&mut self_alias))
vtable_for(NodeCast::from_ref(self))
.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:> {
let node: &mut JSRef<Node> = NodeCast::from_mut_ref(self);
Some(node as &mut VirtualMethods:)
fn super_type<'a>(&'a self) -> Option<&'a VirtualMethods:> {
let node: &JSRef<Node> = NodeCast::from_ref(self);
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(),
_ => (),
}

2
src/components/script/dom/eventdispatcher.rs
View file

@ -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);

2
src/components/script/dom/eventtarget.rs
View file

@ -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
}
}

8
src/components/script/dom/htmlanchorelement.rs
View file

@ -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:> {
let htmlelement: &mut JSRef<HTMLElement> = HTMLElementCast::from_mut_ref(self);
Some(htmlelement as &mut VirtualMethods:)
fn super_type<'a>(&'a self) -> Option<&'a VirtualMethods:> {
let htmlelement: &JSRef<HTMLElement> = HTMLElementCast::from_ref(self);
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);

13
src/components/script/dom/htmlbodyelement.rs
View file

@ -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:> {
let element: &mut JSRef<HTMLElement> = HTMLElementCast::from_mut_ref(self);
Some(element as &mut VirtualMethods:)
fn super_type<'a>(&'a self) -> Option<&'a VirtualMethods:> {
let element: &JSRef<HTMLElement> = HTMLElementCast::from_ref(self);
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),

6
src/components/script/dom/htmlelement.rs
View file

@ -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:> {
let element: &mut JSRef<Element> = ElementCast::from_mut_ref(self);
Some(element as &mut VirtualMethods:)
fn super_type<'a>(&'a self) -> Option<&'a VirtualMethods:> {
let element: &JSRef<Element> = ElementCast::from_ref(self);
Some(element as &VirtualMethods:)
}
}

27
src/components/script/dom/htmliframeelement.rs
View file

@ -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:> {
let htmlelement: &mut JSRef<HTMLElement> = HTMLElementCast::from_mut_ref(self);
Some(htmlelement as &mut VirtualMethods:)
fn super_type<'a>(&'a self) -> Option<&'a VirtualMethods:> {
let htmlelement: &JSRef<HTMLElement> = HTMLElementCast::from_ref(self);
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,
});

20
src/components/script/dom/htmlimageelement.rs
View file

@ -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:> {
let htmlelement: &mut JSRef<HTMLElement> = HTMLElementCast::from_mut_ref(self);
Some(htmlelement as &mut VirtualMethods:)
fn super_type<'a>(&'a self) -> Option<&'a VirtualMethods:> {
let htmlelement: &JSRef<HTMLElement> = HTMLElementCast::from_ref(self);
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);
}
}
}

10
src/components/script/dom/htmlobjectelement.rs
View file

@ -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:> {
let htmlelement: &mut JSRef<HTMLElement> = HTMLElementCast::from_mut_ref(self);
Some(htmlelement as &mut VirtualMethods:)
fn super_type<'a>(&'a self) -> Option<&'a VirtualMethods:> {
let htmlelement: &JSRef<HTMLElement> = HTMLElementCast::from_ref(self);
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),
_ => (),
}

10
src/components/script/dom/htmlstyleelement.rs
View file

@ -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:> {
let htmlelement: &mut JSRef<HTMLElement> = HTMLElementCast::from_mut_ref(self);
Some(htmlelement as &mut VirtualMethods:)
fn super_type<'a>(&'a self) -> Option<&'a VirtualMethods:> {
let htmlelement: &JSRef<HTMLElement> = HTMLElementCast::from_ref(self);
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();

18
src/components/script/dom/node.rs
View file

@ -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() {
vtable_for(&mut node).bind_to_tree();
for node in self.traverse_preorder() {
vtable_for(&node).bind_to_tree();
}
}
let mut parent = self.parent_node().root();
parent.as_mut().map(|parent| vtable_for(&mut **parent).child_inserted(self));
let parent = self.parent_node().root();
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:> {
let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self);
Some(eventtarget as &mut VirtualMethods:)
fn super_type<'a>(&'a self) -> Option<&'a VirtualMethods:> {
let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
Some(eventtarget as &VirtualMethods:)
}
}

60
src/components/script/dom/virtualmethods.rs
View file

@ -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();
element as &mut VirtualMethods:
let element: &JSRef<HTMLAnchorElement> = HTMLAnchorElementCast::to_ref(node).unwrap();
element as &VirtualMethods:
}
ElementNodeTypeId(HTMLBodyElementTypeId) => {
let element: &mut JSRef<HTMLBodyElement> = HTMLBodyElementCast::to_mut_ref(node).unwrap();
element as &mut VirtualMethods:
let element: &JSRef<HTMLBodyElement> = HTMLBodyElementCast::to_ref(node).unwrap();
element as &VirtualMethods:
}
ElementNodeTypeId(HTMLImageElementTypeId) => {
let element: &mut JSRef<HTMLImageElement> = HTMLImageElementCast::to_mut_ref(node).unwrap();
element as &mut VirtualMethods:
let element: &JSRef<HTMLImageElement> = HTMLImageElementCast::to_ref(node).unwrap();
element as &VirtualMethods:
}
ElementNodeTypeId(HTMLIFrameElementTypeId) => {
let element: &mut JSRef<HTMLIFrameElement> = HTMLIFrameElementCast::to_mut_ref(node).unwrap();
element as &mut VirtualMethods:
let element: &JSRef<HTMLIFrameElement> = HTMLIFrameElementCast::to_ref(node).unwrap();
element as &VirtualMethods:
}
ElementNodeTypeId(HTMLObjectElementTypeId) => {
let element: &mut JSRef<HTMLObjectElement> = HTMLObjectElementCast::to_mut_ref(node).unwrap();
element as &mut VirtualMethods:
let element: &JSRef<HTMLObjectElement> = HTMLObjectElementCast::to_ref(node).unwrap();
element as &VirtualMethods:
}
ElementNodeTypeId(HTMLStyleElementTypeId) => {
let element: &mut JSRef<HTMLStyleElement> = HTMLStyleElementCast::to_mut_ref(node).unwrap();
element as &mut VirtualMethods:
let element: &JSRef<HTMLStyleElement> = HTMLStyleElementCast::to_ref(node).unwrap();
element as &VirtualMethods:
}
ElementNodeTypeId(ElementTypeId) => {
let element: &mut JSRef<Element> = ElementCast::to_mut_ref(node).unwrap();
element as &mut VirtualMethods:
let element: &JSRef<Element> = ElementCast::to_ref(node).unwrap();
element as &VirtualMethods:
}
ElementNodeTypeId(_) => {
let element: &mut JSRef<HTMLElement> = HTMLElementCast::to_mut_ref(node).unwrap();
element as &mut VirtualMethods:
let element: &JSRef<HTMLElement> = HTMLElementCast::to_ref(node).unwrap();
element as &VirtualMethods:
}
_ => {
node as &mut VirtualMethods:
node as &VirtualMethods:
}
}
}