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

Revert "script: Use atom comparison in more places, especially for attributes." for persistent test failures.

Browse source 
This reverts commit 874db26104.
This commit is contained in:
Josh Matthews 2014-09-18 09:20:19 -04:00
parent 7158cac2dc
commit 9607b468bc
32 changed files with 147 additions and 300 deletions
Download patch file Download diff file Expand all files Collapse all files

16
components/script/dom/attr.rs
View file

@ -13,13 +13,13 @@ use dom::element::{Element, AttributeHandlers};
use dom::node::Node;
use dom::window::Window;
use dom::virtualmethods::vtable_for;
use servo_util::atom::Atom;
use servo_util::namespace;
use servo_util::namespace::Namespace;
use servo_util::str::{DOMString, split_html_space_chars};
use std::cell::{Ref, RefCell};
use std::mem;
use std::slice::Items;
pub enum AttrSettingType {
FirstSetAttr,
@ -51,9 +51,9 @@ impl AttrValue {
AtomAttrValue(value)
}
pub fn tokens<'a>(&'a self) -> Option<&'a [Atom]> {
pub fn tokens<'a>(&'a self) -> Option<Items<'a, Atom>> {
match *self {
TokenListAttrValue(_, ref tokens) => Some(tokens.as_slice()),
TokenListAttrValue(_, ref tokens) => Some(tokens.iter()),
_ => None
}
}
@ -189,19 +189,17 @@ impl<'a> AttrHelpers for JSRef<'a, Attr> {
pub trait AttrHelpersForLayout {
unsafe fn value_ref_forever(&self) -> &'static str;
unsafe fn value_atom_forever(&self) -> Option<Atom>;
unsafe fn value_tokens_forever(&self) -> Option<&'static [Atom]>;
unsafe fn value_tokens_forever(&self) -> Option<Items<Atom>>;
unsafe fn local_name_atom_forever(&self) -> Atom;
}
impl AttrHelpersForLayout for Attr {
#[inline]
unsafe fn value_ref_forever(&self) -> &'static str {
// cast to point to T in RefCell<T> directly
let value = mem::transmute::<&RefCell<AttrValue>, &AttrValue>(self.value.deref());
value.as_slice()
}
#[inline]
unsafe fn value_atom_forever(&self) -> Option<Atom> {
// cast to point to T in RefCell<T> directly
let value = mem::transmute::<&RefCell<AttrValue>, &AttrValue>(self.value.deref());
@ -211,17 +209,15 @@ impl AttrHelpersForLayout for Attr {
}
}
#[inline]
unsafe fn value_tokens_forever(&self) -> Option<&'static [Atom]> {
unsafe fn value_tokens_forever(&self) -> Option<Items<Atom>> {
// cast to point to T in RefCell<T> directly
let value = mem::transmute::<&RefCell<AttrValue>, &AttrValue>(self.value.deref());
match *value {
TokenListAttrValue(_, ref tokens) => Some(tokens.as_slice()),
TokenListAttrValue(_, ref tokens) => Some(tokens.iter()),
_ => None,
}
}
#[inline]
unsafe fn local_name_atom_forever(&self) -> Atom {
self.local_name.clone()
}

1
components/script/dom/bindings/codegen/CodegenRust.py
View file

@ -5458,7 +5458,6 @@ class GlobalGenRoots():
for protoName in descriptor.prototypeChain[1:-1]:
protoDescriptor = config.getDescriptor(protoName)
delegate = string.Template('''impl ${selfName} for ${baseName} {
#[inline]
fn ${fname}(&self) -> bool {
self.${parentName}.${fname}()
}

3
components/script/dom/document.rs
View file

@ -52,7 +52,6 @@ use dom::window::{Window, WindowHelpers};
use html::hubbub_html_parser::build_element_from_tag;
use hubbub::hubbub::{QuirksMode, NoQuirks, LimitedQuirks, FullQuirks};
use layout_interface::{DocumentDamageLevel, ContentChangedDocumentDamage};
use servo_util::atom::Atom;
use servo_util::namespace;
use servo_util::namespace::{Namespace, Null};
use servo_util::str::{DOMString, null_str_as_empty_ref, split_html_space_chars};
@ -731,7 +730,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
}
let element: &JSRef<Element> = ElementCast::to_ref(node).unwrap();
element.get_attribute(Null, &satom!("name")).root().map_or(false, |attr| {
element.get_attribute(Null, "name").root().map_or(false, |attr| {
attr.value().as_slice() == name.as_slice()
})
})

21
components/script/dom/domtokenlist.rs
View file

@ -21,23 +21,24 @@ use servo_util::str::{DOMString, HTML_SPACE_CHARACTERS};
pub struct DOMTokenList {
reflector_: Reflector,
element: JS<Element>,
local_name: Atom,
local_name: &'static str,
}
impl DOMTokenList {
pub fn new_inherited(element: &JSRef<Element>, local_name: &Atom) -> DOMTokenList {
pub fn new_inherited(element: &JSRef<Element>,
local_name: &'static str) -> DOMTokenList {
DOMTokenList {
reflector_: Reflector::new(),
element: JS::from_rooted(element),
local_name: local_name.clone(),
local_name: local_name,
}
}
pub fn new(element: &JSRef<Element>, local_name: &Atom) -> Temporary<DOMTokenList> {
pub fn new(element: &JSRef<Element>,
local_name: &'static str) -> Temporary<DOMTokenList> {
let window = window_from_node(element).root();
reflect_dom_object(box DOMTokenList::new_inherited(element, local_name),
&Window(*window),
DOMTokenListBinding::Wrap)
&Window(*window), DOMTokenListBinding::Wrap)
}
}
@ -55,7 +56,7 @@ trait PrivateDOMTokenListHelpers {
impl<'a> PrivateDOMTokenListHelpers for JSRef<'a, DOMTokenList> {
fn attribute(&self) -> Option<Temporary<Attr>> {
let element = self.element.root();
element.deref().get_attribute(Null, &self.local_name)
element.deref().get_attribute(Null, self.local_name)
}
fn check_token_exceptions<'a>(&self, token: &'a str) -> Fallible<&'a str> {
@ -79,9 +80,7 @@ impl<'a> DOMTokenListMethods for JSRef<'a, DOMTokenList> {
// http://dom.spec.whatwg.org/#dom-domtokenlist-item
fn Item(&self, index: u32) -> Option<DOMString> {
self.attribute().root().and_then(|attr| attr.value().tokens().and_then(|mut tokens| {
tokens.iter()
.idx(index as uint)
.map(|token| token.as_slice().to_string())
tokens.idx(index as uint).map(|token| token.as_slice().to_string())
}))
}
@ -96,7 +95,7 @@ impl<'a> DOMTokenListMethods for JSRef<'a, DOMTokenList> {
self.check_token_exceptions(token.as_slice()).map(|slice| {
self.attribute().root().and_then(|attr| attr.value().tokens().map(|mut tokens| {
let atom = Atom::from_slice(slice);
tokens.iter().any(|token| *token == atom)
tokens.any(|token| *token == atom)
})).unwrap_or(false)
})
}

136
components/script/dom/element.rs
View file

@ -55,7 +55,6 @@ pub struct Element {
}
impl ElementDerived for EventTarget {
#[inline]
fn is_element(&self) -> bool {
match self.type_id {
NodeTargetTypeId(ElementNodeTypeId(_)) => true,
@ -168,22 +167,21 @@ impl Element {
}
pub trait RawLayoutElementHelpers {
unsafe fn get_attr_val_for_layout(&self, namespace: &Namespace, name: &Atom) -> Option<&'static str>;
unsafe fn get_attr_atom_for_layout(&self, namespace: &Namespace, name: &Atom) -> Option<Atom>;
unsafe fn has_class_for_layout(&self, name: &Atom) -> bool;
unsafe fn get_classes_for_layout(&self) -> Option<&'static [Atom]>;
unsafe fn get_attr_val_for_layout(&self, namespace: &Namespace, name: &str) -> Option<&'static str>;
unsafe fn get_attr_atom_for_layout(&self, namespace: &Namespace, name: &str) -> Option<Atom>;
unsafe fn has_class_for_layout(&self, name: &str) -> bool;
}
impl RawLayoutElementHelpers for Element {
#[inline]
#[allow(unrooted_must_root)]
unsafe fn get_attr_val_for_layout(&self, namespace: &Namespace, name: &Atom)
unsafe fn get_attr_val_for_layout(&self, namespace: &Namespace, name: &str)
-> Option<&'static str> {
// cast to point to T in RefCell<T> directly
let attrs: *const Vec<JS<Attr>> = mem::transmute(&self.attrs);
(*attrs).iter().find(|attr: & &JS<Attr>| {
let attr = attr.unsafe_get();
*name == (*attr).local_name_atom_forever() &&
name == (*attr).local_name_atom_forever().as_slice() &&
(*attr).namespace == *namespace
}).map(|attr| {
let attr = attr.unsafe_get();
@ -193,13 +191,13 @@ impl RawLayoutElementHelpers for Element {
#[inline]
#[allow(unrooted_must_root)]
unsafe fn get_attr_atom_for_layout(&self, namespace: &Namespace, name: &Atom)
unsafe fn get_attr_atom_for_layout(&self, namespace: &Namespace, name: &str)
-> Option<Atom> {
// cast to point to T in RefCell<T> directly
let attrs: *const Vec<JS<Attr>> = mem::transmute(&self.attrs);
(*attrs).iter().find(|attr: & &JS<Attr>| {
let attr = attr.unsafe_get();
*name == (*attr).local_name_atom_forever() &&
name == (*attr).local_name_atom_forever().as_slice() &&
(*attr).namespace == *namespace
}).and_then(|attr| {
let attr = attr.unsafe_get();
@ -209,31 +207,16 @@ impl RawLayoutElementHelpers for Element {
#[inline]
#[allow(unrooted_must_root)]
unsafe fn has_class_for_layout(&self, name: &Atom) -> bool {
unsafe fn has_class_for_layout(&self, name: &str) -> bool {
let attrs: *const Vec<JS<Attr>> = mem::transmute(&self.attrs);
(*attrs).iter().find(|attr: & &JS<Attr>| {
let attr = attr.unsafe_get();
(*attr).local_name_atom_forever() == satom!("class")
(*attr).local_name_atom_forever().as_slice() == "class"
}).map_or(false, |attr| {
let attr = attr.unsafe_get();
(*attr).value_tokens_forever().map(|mut tokens| {
tokens.iter().any(|atom| atom == name)
})
(*attr).value_tokens_forever().map(|mut tokens| { tokens.any(|atom| atom.as_slice() == name) })
}.take().unwrap())
}
#[inline]
#[allow(unrooted_must_root)]
unsafe fn get_classes_for_layout(&self) -> Option<&'static [Atom]> {
let attrs: *const Vec<JS<Attr>> = mem::transmute(&self.attrs);
(*attrs).iter().find(|attr: & &JS<Attr>| {
let attr = attr.unsafe_get();
(*attr).local_name_atom_forever() == satom!("class")
}).and_then(|attr| {
let attr = attr.unsafe_get();
(*attr).value_tokens_forever()
})
}
}
pub trait LayoutElementHelpers {
@ -242,7 +225,6 @@ pub trait LayoutElementHelpers {
impl LayoutElementHelpers for JS<Element> {
#[allow(unrooted_must_root)]
#[inline]
unsafe fn html_element_in_html_document_for_layout(&self) -> bool {
if (*self.unsafe_get()).namespace != namespace::HTML {
return false
@ -275,11 +257,10 @@ impl<'a> ElementHelpers for JSRef<'a, Element> {
}
pub trait AttributeHandlers {
/// Returns the attribute with given namespace and case-insensitive local name, if any.
fn get_attribute(&self, namespace: Namespace, local_name: &Atom) -> Option<Temporary<Attr>>;
/// Returns the attribute with given namespace and case-sensitive local name, if any.
fn get_case_sensitive_attribute(&self, namespace: Namespace, name: &Atom)
-> Option<Temporary<Attr>>;
/// Returns the attribute with given namespace and case-sensitive local
/// name, if any.
fn get_attribute(&self, namespace: Namespace, local_name: &str)
-> Option<Temporary<Attr>>;
fn set_attribute_from_parser(&self, local_name: Atom,
value: DOMString, namespace: Namespace,
prefix: Option<DOMString>);
@ -292,38 +273,27 @@ pub trait AttributeHandlers {
fn remove_attribute(&self, namespace: Namespace, name: &str);
fn notify_attribute_changed(&self, local_name: &Atom);
fn has_class(&self, name: &Atom) -> bool;
fn has_class(&self, name: &str) -> bool;
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: &Atom) -> DOMString;
fn get_url_attribute(&self, name: &str) -> DOMString;
fn set_url_attribute(&self, name: &str, value: DOMString);
fn get_string_attribute(&self, name: &Atom) -> 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: &Atom) -> u32;
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, name: &Atom) -> Option<Temporary<Attr>> {
match self.html_element_in_html_document() {
true => {
let local_name = Atom::from_slice(name.as_slice().to_ascii_lower().as_slice());
self.get_case_sensitive_attribute(namespace, &local_name)
}
false => self.get_case_sensitive_attribute(namespace, name),
}
}
fn get_case_sensitive_attribute(&self, namespace: Namespace, local_name: &Atom)
-> Option<Temporary<Attr>> {
let element: &Element = self.deref();
element.attrs.borrow().iter().map(|attr| attr.root()).find(|attr| {
attr.local_name() == local_name && attr.namespace == namespace
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))
}
@ -423,12 +393,11 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
}
}
fn has_class(&self, name: &Atom) -> bool {
self.get_attribute(Null, &satom!("class")).root().map(|attr| {
match attr.deref().value().tokens() {
None => false,
Some(ref atoms) => atoms.iter().any(|atom| atom == name),
}
fn has_class(&self, name: &str) -> bool {
self.get_attribute(Null, "class").root().map(|attr| {
attr.deref().value().tokens().map(|mut tokens| {
tokens.any(|atom| atom.as_slice() == name)
}).unwrap_or(false)
}).unwrap_or(false)
}
@ -457,7 +426,8 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
}
}
fn get_url_attribute(&self, name: &Atom) -> 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)
}
@ -465,7 +435,8 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
self.set_string_attribute(name, value);
}
fn get_string_attribute(&self, name: &Atom) -> 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) => {
let x = x.root();
@ -484,8 +455,8 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
self.set_attribute(name, AttrValue::from_tokenlist(value));
}
fn get_uint_attribute(&self, name: &Atom) -> u32 {
assert!(name.as_slice() == name.as_slice().to_ascii_lower().as_slice());
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 {
Some(attribute) => {
@ -552,7 +523,7 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
// http://dom.spec.whatwg.org/#dom-element-id
fn Id(&self) -> DOMString {
self.get_string_attribute(&satom!("id"))
self.get_string_attribute("id")
}
// http://dom.spec.whatwg.org/#dom-element-id
@ -562,7 +533,7 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
// http://dom.spec.whatwg.org/#dom-element-classname
fn ClassName(&self) -> DOMString {
self.get_string_attribute(&satom!("class"))
self.get_string_attribute("class")
}
// http://dom.spec.whatwg.org/#dom-element-classname
@ -575,7 +546,7 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
match self.class_list.get() {
Some(class_list) => Temporary::new(class_list),
None => {
let class_list = DOMTokenList::new(self, &satom!("class")).root();
let class_list = DOMTokenList::new(self, "class").root();
self.class_list.assign(Some(class_list.deref().clone()));
Temporary::from_rooted(&*class_list)
}
@ -606,7 +577,7 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
} else {
name
};
self.get_attribute(Null, &Atom::from_slice(name.as_slice())).root()
self.get_attribute(Null, name.as_slice()).root()
.map(|s| s.deref().Value())
}
@ -615,7 +586,7 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
namespace: Option<DOMString>,
local_name: DOMString) -> Option<DOMString> {
let namespace = Namespace::from_str(null_str_as_empty_ref(&namespace));
self.get_attribute(namespace, &Atom::from_slice(local_name.as_slice())).root()
self.get_attribute(namespace, local_name.as_slice()).root()
.map(|attr| attr.deref().Value())
}
@ -925,7 +896,7 @@ impl<'a> VirtualMethods for JSRef<'a, Element> {
if !tree_in_doc { return; }
match self.get_attribute(Null, &satom!("id")).root() {
match self.get_attribute(Null, "id").root() {
Some(attr) => {
let doc = document_from_node(self).root();
let value = attr.deref().Value();
@ -945,7 +916,7 @@ impl<'a> VirtualMethods for JSRef<'a, Element> {
if !tree_in_doc { return; }
match self.get_attribute(Null, &satom!("id")).root() {
match self.get_attribute(Null, "id").root() {
Some(attr) => {
let doc = document_from_node(self).root();
let value = attr.deref().Value();
@ -959,8 +930,8 @@ impl<'a> VirtualMethods for JSRef<'a, Element> {
}
impl<'a> style::TElement for JSRef<'a, Element> {
fn get_attr(&self, namespace: &Namespace, attr: &Atom) -> Option<&'static str> {
self.get_case_sensitive_attribute(namespace.clone(), attr).root().map(|attr| {
fn get_attr(&self, namespace: &Namespace, attr: &str) -> Option<&'static str> {
self.get_attribute(namespace.clone(), attr).root().map(|attr| {
unsafe { mem::transmute(attr.deref().value().as_slice()) }
})
}
@ -972,9 +943,7 @@ impl<'a> style::TElement for JSRef<'a, Element> {
// selector-link
ElementNodeTypeId(HTMLAnchorElementTypeId) |
ElementNodeTypeId(HTMLAreaElementTypeId) |
ElementNodeTypeId(HTMLLinkElementTypeId) => {
self.get_attr(&namespace::Null, &satom!("href"))
}
ElementNodeTypeId(HTMLLinkElementTypeId) => self.get_attr(&namespace::Null, "href"),
_ => None,
}
}
@ -989,7 +958,7 @@ impl<'a> style::TElement for JSRef<'a, Element> {
node.get_hover_state()
}
fn get_id<'a>(&self) -> Option<Atom> {
self.get_attribute(namespace::Null, &satom!("id")).map(|attr| {
self.get_attribute(namespace::Null, "id").map(|attr| {
let attr = attr.root();
match *attr.value() {
AtomAttrValue(ref val) => val.clone(),
@ -1005,22 +974,7 @@ impl<'a> style::TElement for JSRef<'a, Element> {
let node: &JSRef<Node> = NodeCast::from_ref(self);
node.get_enabled_state()
}
fn has_class(&self, name: &Atom) -> bool {
fn has_class(&self, name: &str) -> bool {
(self as &AttributeHandlers).has_class(name)
}
fn each_class(&self, callback: |&Atom|) {
match self.get_attribute(Null, &satom!("class")) {
None => {}
Some(ref attr) => {
match attr.root().value().tokens() {
None => {}
Some(ref atoms) => {
for atom in atoms.iter() {
callback(atom);
}
}
}
}
}
}
}

2
components/script/dom/htmlanchorelement.rs
View file

@ -57,7 +57,7 @@ impl<'a> PrivateHTMLAnchorElementHelpers for JSRef<'a, HTMLAnchorElement> {
fn handle_event_impl(&self, event: &JSRef<Event>) {
if "click" == event.Type().as_slice() && !event.DefaultPrevented() {
let element: &JSRef<Element> = ElementCast::from_ref(self);
let attr = element.get_attribute(Null, &satom!("href")).root();
let attr = element.get_attribute(Null, "href").root();
match attr {
Some(ref href) => {
let value = href.Value();

16
components/script/dom/htmlcollection.rs
View file

@ -146,17 +146,15 @@ impl HTMLCollection {
pub fn by_class_name(window: &JSRef<Window>, root: &JSRef<Node>, classes: DOMString)
-> Temporary<HTMLCollection> {
struct ClassNameFilter {
classes: Vec<Atom>
classes: Vec<DOMString>
}
impl CollectionFilter for ClassNameFilter {
fn filter(&self, elem: &JSRef<Element>, _root: &JSRef<Node>) -> bool {
self.classes.iter().all(|class| elem.has_class(class))
self.classes.iter().all(|class| elem.has_class(class.as_slice()))
}
}
let filter = ClassNameFilter {
classes: split_html_space_chars(classes.as_slice()).map(|class| {
Atom::from_slice(class)
}).collect()
classes: split_html_space_chars(classes.as_slice()).map(|class| class.to_string()).collect()
};
HTMLCollection::create(window, root, box filter)
}
@ -222,8 +220,8 @@ impl<'a> HTMLCollectionMethods for JSRef<'a, HTMLCollection> {
Static(ref elems) => elems.iter()
.map(|elem| elem.root())
.find(|elem| {
elem.get_string_attribute(&satom!("name")) == key ||
elem.get_string_attribute(&satom!("id")) == key })
elem.get_string_attribute("name") == key ||
elem.get_string_attribute("id") == key })
.map(|maybe_elem| Temporary::from_rooted(&*maybe_elem)),
Live(ref root, ref filter) => {
let root = root.root();
@ -234,8 +232,8 @@ impl<'a> HTMLCollectionMethods for JSRef<'a, HTMLCollection> {
.map(|elem| elem.clone())
})
.find(|elem| {
elem.get_string_attribute(&satom!("name")) == key ||
elem.get_string_attribute(&satom!("id")) == key })
elem.get_string_attribute("name") == key ||
elem.get_string_attribute("id") == key })
.map(|maybe_elem| Temporary::from_rooted(&maybe_elem))
}
}

6
components/script/dom/htmliframeelement.rs
View file

@ -75,7 +75,7 @@ impl<'a> HTMLIFrameElementHelpers for JSRef<'a, HTMLIFrameElement> {
fn get_url(&self) -> Option<Url> {
let element: &JSRef<Element> = ElementCast::from_ref(self);
element.get_attribute(Null, &satom!("src")).root().and_then(|src| {
element.get_attribute(Null, "src").root().and_then(|src| {
let url = src.deref().value();
if url.as_slice().is_empty() {
None
@ -133,7 +133,7 @@ impl HTMLIFrameElement {
impl<'a> HTMLIFrameElementMethods for JSRef<'a, HTMLIFrameElement> {
fn Src(&self) -> DOMString {
let element: &JSRef<Element> = ElementCast::from_ref(self);
element.get_string_attribute(&satom!("src"))
element.get_string_attribute("src")
}
fn SetSrc(&self, src: DOMString) {
@ -143,7 +143,7 @@ impl<'a> HTMLIFrameElementMethods for JSRef<'a, HTMLIFrameElement> {
fn Sandbox(&self) -> DOMString {
let element: &JSRef<Element> = ElementCast::from_ref(self);
element.get_string_attribute(&satom!("sandbox"))
element.get_string_attribute("sandbox")
}
fn SetSandbox(&self, sandbox: DOMString) {

4
components/script/dom/htmllinkelement.rs
View file

@ -92,11 +92,11 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLLinkElement> {
// FIXME: workaround for https://github.com/mozilla/rust/issues/13246;
// we get unrooting order failures if these are inside the match.
let rel = {
let rel = element.get_attribute(Null, &satom!("rel")).root();
let rel = element.get_attribute(Null, "rel").root();
rel.map(|rel| rel.deref().value().as_slice().to_string())
};
let href = {
let href = element.get_attribute(Null, &satom!("href")).root();
let href = element.get_attribute(Null, "href").root();
href.map(|href| href.deref().value().as_slice().to_string())
};

4
components/script/dom/htmlobjectelement.rs
View file

@ -63,8 +63,8 @@ impl<'a> ProcessDataURL for JSRef<'a, HTMLObjectElement> {
let elem: &JSRef<Element> = ElementCast::from_ref(self);
// TODO: support other values
match (elem.get_attribute(Null, &satom!("type")).map(|x| x.root().Value()),
elem.get_attribute(Null, &satom!("data")).map(|x| x.root().Value())) {
match (elem.get_attribute(Null, "type").map(|x| x.root().Value()),
elem.get_attribute(Null, "data").map(|x| x.root().Value())) {
(None, Some(uri)) => {
if is_image_data(uri.as_slice()) {
let data_url = Url::parse(uri.as_slice()).unwrap();

9
components/script/dom/htmlscriptelement.rs
View file

@ -16,7 +16,6 @@ use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, NodeHelpers, ElementNodeTypeId};
use servo_util::atom::Atom;
use servo_util::namespace::Null;
use servo_util::str::{DOMString, HTML_SPACE_CHARACTERS, StaticStringVec};
@ -76,7 +75,7 @@ static SCRIPT_JS_MIMES: StaticStringVec = &[
impl<'a> HTMLScriptElementHelpers for JSRef<'a, HTMLScriptElement> {
fn is_javascript(&self) -> bool {
let element: &JSRef<Element> = ElementCast::from_ref(self);
match element.get_attribute(Null, &satom!("type")).root().map(|s| s.Value()) {
match element.get_attribute(Null, "type").root().map(|s| s.Value()) {
Some(ref s) if s.is_empty() => {
// type attr exists, but empty means js
debug!("script type empty, inferring js");
@ -88,9 +87,7 @@ impl<'a> HTMLScriptElementHelpers for JSRef<'a, HTMLScriptElement> {
},
None => {
debug!("no script type");
match element.get_attribute(Null, &satom!("language"))
.root()
.map(|s| s.Value()) {
match element.get_attribute(Null, "language").root().map(|s| s.Value()) {
Some(ref s) if s.is_empty() => {
debug!("script language empty, inferring js");
true
@ -112,7 +109,7 @@ impl<'a> HTMLScriptElementHelpers for JSRef<'a, HTMLScriptElement> {
impl<'a> HTMLScriptElementMethods for JSRef<'a, HTMLScriptElement> {
fn Src(&self) -> DOMString {
let element: &JSRef<Element> = ElementCast::from_ref(self);
element.get_url_attribute(&satom!("src"))
element.get_url_attribute("src")
}
// http://www.whatwg.org/html/#dom-script-text

6
components/script/dom/macros.rs
View file

@ -12,8 +12,7 @@ macro_rules! make_getter(
use dom::bindings::codegen::InheritTypes::ElementCast;
use std::ascii::StrAsciiExt;
let element: &JSRef<Element> = ElementCast::from_ref(self);
element.get_string_attribute(&Atom::from_slice(stringify!($attr).to_ascii_lower()
.as_slice()))
element.get_string_attribute(stringify!($attr).to_ascii_lower().as_slice())
}
);
)
@ -39,8 +38,7 @@ macro_rules! make_uint_getter(
use dom::bindings::codegen::InheritTypes::ElementCast;
use std::ascii::StrAsciiExt;
let element: &JSRef<Element> = ElementCast::from_ref(self);
element.get_uint_attribute(&Atom::from_slice(stringify!($attr).to_ascii_lower()
.as_slice()))
element.get_uint_attribute(stringify!($attr).to_ascii_lower().as_slice())
}
);
)

12
components/script/dom/node.rs
View file

@ -769,19 +769,16 @@ pub trait RawLayoutNodeHelpers {
}
impl RawLayoutNodeHelpers for Node {
#[inline]
unsafe fn get_hover_state_for_layout(&self) -> bool {
(*self.unsafe_get_flags()).contains(InHoverState)
}
#[inline]
unsafe fn get_disabled_state_for_layout(&self) -> bool {
(*self.unsafe_get_flags()).contains(InDisabledState)
}
#[inline]
unsafe fn get_enabled_state_for_layout(&self) -> bool {
(*self.unsafe_get_flags()).contains(InEnabledState)
}
#[inline]
fn type_id_for_layout(&self) -> NodeTypeId {
self.type_id
}
@ -1416,7 +1413,6 @@ impl Node {
}
}
#[inline]
pub unsafe fn unsafe_get_flags(&self) -> *const NodeFlags {
mem::transmute(&self.flags)
}
@ -1991,7 +1987,7 @@ impl<'a> VirtualMethods for JSRef<'a, Node> {
}
}
impl<'a> style::TNode<JSRef<'a,Element>> for JSRef<'a,Node> {
impl<'a> style::TNode<JSRef<'a, Element>> for JSRef<'a, Node> {
fn parent_node(&self) -> Option<JSRef<'a, Node>> {
(self as &NodeHelpers).parent_node().map(|node| *node.root())
}
@ -2025,9 +2021,9 @@ impl<'a> style::TNode<JSRef<'a,Element>> for JSRef<'a,Node> {
fn match_attr(&self, attr: &style::AttrSelector, test: |&str| -> bool) -> bool {
let name = {
if self.is_html_element_in_html_document() {
&attr.lower_name
attr.lower_name.as_slice()
} else {
&attr.name
attr.name.as_slice()
}
};
match attr.namespace {