Replace Root::deref() calls by Root::r() calls where possible.

This changes those calls that were already sound.

1 files changed, 19 insertions, 19 deletions

diff --git a/components/script/parse/html.rs b/components/script/parse/html.rs
index ab30802d16e..eb97d0893a4 100644
--- a/components/script/parse/html.rs
+++ b/components/script/parse/html.rs
@@ -46,7 +46,7 @@ impl SinkHelpers for servohtmlparser::Sink {
             AppendNode(n) => Temporary::new(unsafe { JS::from_trusted_node_address(n) }),
             AppendText(t) => {
                 let doc = self.document.root();
-                let text = Text::new(t, *doc);
+                let text = Text::new(t, doc.r());
                 NodeCast::from_temporary(text)
             }
         }
@@ -56,7 +56,7 @@ impl SinkHelpers for servohtmlparser::Sink {
 impl<'a> TreeSink<TrustedNodeAddress> for servohtmlparser::Sink {
     fn get_document(&mut self) -> TrustedNodeAddress {
         let doc = self.document.root();
-        let node: JSRef<Node> = NodeCast::from_ref(*doc);
+        let node: JSRef<Node> = NodeCast::from_ref(doc.r());
         node.to_trusted_node_address()
     }
 
@@ -66,7 +66,7 @@ impl<'a> TreeSink<TrustedNodeAddress> for servohtmlparser::Sink {
 
     fn elem_name(&self, target: TrustedNodeAddress) -> QualName {
         let node: Root<Node> = unsafe { JS::from_trusted_node_address(target).root() };
-        let elem: JSRef<Element> = ElementCast::to_ref(*node)
+        let elem: JSRef<Element> = ElementCast::to_ref(node.r())
             .expect("tried to get name of non-Element in HTML parsing");
         QualName {
             ns: elem.namespace().clone(),
@@ -77,22 +77,22 @@ impl<'a> TreeSink<TrustedNodeAddress> for servohtmlparser::Sink {
     fn create_element(&mut self, name: QualName, attrs: Vec<Attribute>)
             -> TrustedNodeAddress {
         let doc = self.document.root();
-        let elem = Element::create(name, None, *doc,
+        let elem = Element::create(name, None, doc.r(),
                                    ElementCreator::ParserCreated).root();
 
         for attr in attrs.into_iter() {
-            elem.set_attribute_from_parser(attr.name, attr.value, None);
+            elem.r().set_attribute_from_parser(attr.name, attr.value, None);
         }
 
-        let node: JSRef<Node> = NodeCast::from_ref(*elem);
+        let node: JSRef<Node> = NodeCast::from_ref(elem.r());
         node.to_trusted_node_address()
     }
 
     fn create_comment(&mut self, text: String) -> TrustedNodeAddress {
         let doc = self.document.root();
-        let comment = Comment::new(text, *doc);
+        let comment = Comment::new(text, doc.r());
         let node: Root<Node> = NodeCast::from_temporary(comment).root();
-        node.to_trusted_node_address()
+        node.r().to_trusted_node_address()
     }
 
     fn append_before_sibling(&mut self,
@@ -100,13 +100,13 @@ impl<'a> TreeSink<TrustedNodeAddress> for servohtmlparser::Sink {
             new_node: NodeOrText<TrustedNodeAddress>) -> Result<(), NodeOrText<TrustedNodeAddress>> {
         // If there is no parent, return the node to the parser.
         let sibling: Root<Node> = unsafe { JS::from_trusted_node_address(sibling).root() };
-        let parent = match sibling.parent_node() {
+        let parent = match sibling.r().parent_node() {
             Some(p) => p.root(),
             None => return Err(new_node),
         };
 
         let child = self.get_or_create(new_node).root();
-        assert!(parent.InsertBefore(*child, Some(*sibling)).is_ok());
+        assert!(parent.r().InsertBefore(child.r(), Some(sibling.r())).is_ok());
         Ok(())
     }
 
@@ -116,7 +116,7 @@ impl<'a> TreeSink<TrustedNodeAddress> for servohtmlparser::Sink {
 
     fn set_quirks_mode(&mut self, mode: QuirksMode) {
         let doc = self.document.root();
-        doc.set_quirks_mode(mode);
+        doc.r().set_quirks_mode(mode);
     }
 
     fn append(&mut self, parent: TrustedNodeAddress, child: NodeOrText<TrustedNodeAddress>) {
@@ -124,21 +124,21 @@ impl<'a> TreeSink<TrustedNodeAddress> for servohtmlparser::Sink {
         let child = self.get_or_create(child).root();
 
         // FIXME(#3701): Use a simpler algorithm and merge adjacent text nodes
-        assert!(parent.AppendChild(*child).is_ok());
+        assert!(parent.r().AppendChild(child.r()).is_ok());
     }
 
     fn append_doctype_to_document(&mut self, name: String, public_id: String, system_id: String) {
         let doc = self.document.root();
-        let doc_node: JSRef<Node> = NodeCast::from_ref(*doc);
-        let doctype = DocumentType::new(name, Some(public_id), Some(system_id), *doc);
+        let doc_node: JSRef<Node> = NodeCast::from_ref(doc.r());
+        let doctype = DocumentType::new(name, Some(public_id), Some(system_id), doc.r());
         let node: Root<Node> = NodeCast::from_temporary(doctype).root();
 
-        assert!(doc_node.AppendChild(*node).is_ok());
+        assert!(doc_node.AppendChild(node.r()).is_ok());
     }
 
     fn add_attrs_if_missing(&mut self, target: TrustedNodeAddress, attrs: Vec<Attribute>) {
         let node: Root<Node> = unsafe { JS::from_trusted_node_address(target).root() };
-        let elem: JSRef<Element> = ElementCast::to_ref(*node)
+        let elem: JSRef<Element> = ElementCast::to_ref(node.r())
             .expect("tried to set attrs on non-Element in HTML parsing");
         for attr in attrs.into_iter() {
             elem.set_attribute_from_parser(attr.name, attr.value, None);
@@ -151,13 +151,13 @@ impl<'a> TreeSink<TrustedNodeAddress> for servohtmlparser::Sink {
 
     fn mark_script_already_started(&mut self, node: TrustedNodeAddress) {
         let node: Root<Node> = unsafe { JS::from_trusted_node_address(node).root() };
-        let script: Option<JSRef<HTMLScriptElement>> = HTMLScriptElementCast::to_ref(*node);
+        let script: Option<JSRef<HTMLScriptElement>> = HTMLScriptElementCast::to_ref(node.r());
         script.map(|script| script.mark_already_started());
     }
 
     fn complete_script(&mut self, node: TrustedNodeAddress) {
         let node: Root<Node> = unsafe { JS::from_trusted_node_address(node).root() };
-        let script: Option<JSRef<HTMLScriptElement>> = HTMLScriptElementCast::to_ref(*node);
+        let script: Option<JSRef<HTMLScriptElement>> = HTMLScriptElementCast::to_ref(node.r());
         script.map(|script| script.prepare());
     }
 }
@@ -166,7 +166,7 @@ pub fn parse_html(document: JSRef<Document>,
                   input: HTMLInput,
                   url: &Url) {
     let parser = ServoHTMLParser::new(Some(url.clone()), document).root();
-    let parser: JSRef<ServoHTMLParser> = *parser;
+    let parser: JSRef<ServoHTMLParser> = parser.r();
 
     let nested_parse = task_state::get().contains(task_state::IN_HTML_PARSER);
     if !nested_parse {