Replace many uses of Attr::Value() by Attr::value()

The later only borrows the attribute, without copying its value as a string.

components/script/dom/element.rs

@@ -1581,11 +1581,11 @@ impl VirtualMethods for Element {
         if !tree_in_doc { return; }
 
         if let Some(ref attr) = self.get_attribute(&ns!(""), &atom!("id")) {
-            let doc = document_from_node(self);
-            let value = attr.r().Value();
+            let value = attr.value();
             if !value.is_empty() {
+                let doc = document_from_node(self);
                 let value = Atom::from_slice(&value);
-                doc.r().register_named_element(self, value);
+                doc.register_named_element(self, value.to_owned());
             }
         }
     }
@@ -1598,11 +1598,11 @@ impl VirtualMethods for Element {
         if !tree_in_doc { return; }
 
         if let Some(ref attr) = self.get_attribute(&ns!(""), &atom!("id")) {
-            let doc = document_from_node(self);
-            let value = attr.r().Value();
+            let value = attr.value();
             if !value.is_empty() {
+                let doc = document_from_node(self);
                 let value = Atom::from_slice(&value);
-                doc.r().unregister_named_element(self, value);
+                doc.unregister_named_element(self, value.to_owned());
             }
         }
     }

components/script/dom/htmlformelement.rs

@@ -314,7 +314,7 @@ impl HTMLFormElement {
                         _ => Some(FormDatum {
                             ty: ty,
                             name: name,
-                            value: input.Value()
+                            value: value
                         })
                     }
                 }

components/script/dom/htmlobjectelement.rs

@@ -4,7 +4,6 @@
 
 use dom::attr::Attr;
 use dom::bindings::cell::DOMRefCell;
-use dom::bindings::codegen::Bindings::AttrBinding::AttrMethods;
 use dom::bindings::codegen::Bindings::HTMLObjectElementBinding;
 use dom::bindings::codegen::Bindings::HTMLObjectElementBinding::HTMLObjectElementMethods;
 use dom::bindings::codegen::InheritTypes::HTMLObjectElementDerived;
@@ -67,8 +66,8 @@ impl<'a> ProcessDataURL for &'a HTMLObjectElement {
         let elem = ElementCast::from_ref(*self);
 
         // TODO: support other values
-        match (elem.get_attribute(&ns!(""), &atom!("type")).map(|x| x.r().Value()),
-               elem.get_attribute(&ns!(""), &atom!("data")).map(|x| x.r().Value())) {
+        match (elem.get_attribute(&ns!(""), &atom!("type")),
+               elem.get_attribute(&ns!(""), &atom!("data"))) {
             (None, Some(_uri)) => {
                 // TODO(gw): Prefetch the image here.
             }

components/script/dom/htmlscriptelement.rs

@@ -236,14 +236,13 @@ impl HTMLScriptElement {
         let event_attribute = element.get_attribute(&ns!(""), &Atom::from_slice("event"));
         match (for_attribute.r(), event_attribute.r()) {
             (Some(for_attribute), Some(event_attribute)) => {
-                let for_value = for_attribute.Value()
-                                             .to_ascii_lowercase();
+                let for_value = for_attribute.value().to_ascii_lowercase();
                 let for_value = for_value.trim_matches(HTML_SPACE_CHARACTERS);
                 if for_value != "window" {
                     return NextParserState::Continue;
                 }
 
-                let event_value = event_attribute.Value().to_ascii_lowercase();
+                let event_value = event_attribute.value().to_ascii_lowercase();
                 let event_value = event_value.trim_matches(HTML_SPACE_CHARACTERS);
                 if event_value != "onload" && event_value != "onload()" {
                     return NextParserState::Continue;
@@ -268,7 +267,7 @@ impl HTMLScriptElement {
             // Step 14.
             Some(ref src) => {
                 // Step 14.1
-                let src = src.r().Value();
+                let src = src.value();
 
                 // Step 14.2
                 if src.is_empty() {
@@ -277,10 +276,10 @@ impl HTMLScriptElement {
                 }
 
                 // Step 14.3
-                match UrlParser::new().base_url(&base_url).parse(&*src) {
+                match UrlParser::new().base_url(&base_url).parse(&src) {
                     Err(_) => {
                         // Step 14.4
-                        error!("error parsing URL for script {}", src);
+                        error!("error parsing URL for script {}", &**src);
                         self.queue_error_event();
                         return NextParserState::Continue;
                     }
@@ -469,37 +468,42 @@ impl HTMLScriptElement {
 
     pub fn is_javascript(&self) -> bool {
         let element = ElementCast::from_ref(self);
-        match element.get_attribute(&ns!(""), &atom!("type")).map(|s| s.r().Value()) {
+        let type_attr = element.get_attribute(&ns!(""), &atom!("type"));
+        let is_js = match type_attr.as_ref().map(|s| s.value()) {
             Some(ref s) if s.is_empty() => {
                 // type attr exists, but empty means js
                 debug!("script type empty, inferring js");
                 true
             },
-            Some(ref s) => {
-                debug!("script type={}", *s);
+            Some(s) => {
+                debug!("script type={}", &**s);
                 SCRIPT_JS_MIMES.contains(&s.to_ascii_lowercase().trim_matches(HTML_SPACE_CHARACTERS))
             },
             None => {
                 debug!("no script type");
-                match element.get_attribute(&ns!(""), &atom!("language"))
-                             .map(|s| s.r().Value()) {
+                let language_attr = element.get_attribute(&ns!(""), &atom!("language"));
+                let is_js = match language_attr.as_ref().map(|s| s.value()) {
                     Some(ref s) if s.is_empty() => {
                         debug!("script language empty, inferring js");
                         true
                     },
-                    Some(ref s) => {
-                        debug!("script language={}", *s);
-                        let mut language = format!("text/{}", s);
+                    Some(s) => {
+                        debug!("script language={}", &**s);
+                        let mut language = format!("text/{}", &**s);
                         language.make_ascii_lowercase();
                         SCRIPT_JS_MIMES.contains(&&*language)
                     },
                     None => {
                         debug!("no script type or language, inferring js");
                         true
                     }
-                }
+                };
+                // https://github.com/rust-lang/rust/issues/21114
+                is_js
             }
-        }
+        };
+        // https://github.com/rust-lang/rust/issues/21114
+        is_js
     }
 
     pub fn mark_already_started(&self) {

components/script/script_task.rs

@@ -22,7 +22,6 @@
 use devtools;
 use document_loader::{LoadType, DocumentLoader, NotifierData};
 use dom::bindings::cell::DOMRefCell;
-use dom::bindings::codegen::Bindings::AttrBinding::AttrMethods;
 use dom::bindings::codegen::Bindings::DocumentBinding::{DocumentMethods, DocumentReadyState};
 use dom::bindings::codegen::InheritTypes::{ElementCast, EventTargetCast, NodeCast, EventCast};
 use dom::bindings::conversions::FromJSValConvertible;
@@ -1798,7 +1797,7 @@ impl ScriptTask {
                         let element = ElementCast::to_ref(target.r()).unwrap();
                         let status = element.get_attribute(&ns!(""), &atom!("href"))
                             .and_then(|href| {
-                                let value = href.r().Value();
+                                let value = href.value();
                                 let url = document.r().url();
                                 UrlParser::new().base_url(&url).parse(&value).map(|url| url.serialize()).ok()
                             });