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

Use string-cache's Namespace type

Browse source
This commit is contained in:
Keegan McAllister 2014-09-29 18:30:01 -07:00
parent 6429750b33
commit d50114c41d
27 changed files with 126 additions and 183 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -15,13 +15,11 @@ use dom::window::Window;
use dom::virtualmethods::vtable_for;
use devtools_traits::AttrInfo;
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;
use string_cache::Atom;
use string_cache::{Atom, Namespace};
pub enum AttrSettingType {
FirstSetAttr,
@ -136,7 +134,8 @@ impl<'a> AttrMethods for JSRef<'a, Attr> {
}
fn GetNamespaceURI(self) -> Option<DOMString> {
match self.namespace.to_str() {
let Namespace(ref atom) = self.namespace;
match atom.as_slice() {
"" => None,
url => Some(url.to_string()),
}
@ -158,7 +157,7 @@ impl<'a> AttrHelpers<'a> for JSRef<'a, Attr> {
fn set_value(self, set_type: AttrSettingType, value: AttrValue) {
let owner = self.owner.root();
let node: JSRef<Node> = NodeCast::from_ref(*owner);
let namespace_is_null = self.namespace == namespace::Null;
let namespace_is_null = self.namespace == ns!("");
match set_type {
ReplacedAttr => {
@ -189,8 +188,9 @@ impl<'a> AttrHelpers<'a> for JSRef<'a, Attr> {
}
fn summarize(self) -> AttrInfo {
let Namespace(ref ns) = self.namespace;
AttrInfo {
namespace: self.namespace.to_str().to_string(),
namespace: ns.as_slice().to_string(),
name: self.Name(),
value: self.Value(),
}

3
components/script/dom/bindings/trace.rs
View file

@ -35,14 +35,13 @@ use std::rc::Rc;
use std::cell::{Cell, RefCell};
use url::Url;
use servo_util::namespace::Namespace;
use msg::constellation_msg::{PipelineId, SubpageId, WindowSizeData};
use net::image_cache_task::ImageCacheTask;
use script_traits::ScriptControlChan;
use std::collections::hashmap::HashMap;
use collections::hash::Hash;
use style::PropertyDeclarationBlock;
use string_cache::Atom;
use string_cache::{Atom, Namespace};
impl<T: Reflectable> JSTraceable for JS<T> {
fn trace(&self, trc: *mut JSTracer) {

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

@ -56,7 +56,6 @@ use html::hubbub_html_parser::build_element_from_tag;
use hubbub::hubbub::{QuirksMode, NoQuirks, LimitedQuirks, FullQuirks};
use layout_interface::{DocumentDamageLevel, ContentChangedDocumentDamage};
use servo_util::namespace;
use servo_util::namespace::{Namespace, Null};
use servo_util::str::{DOMString, split_html_space_chars};
use string_cache::Atom;
@ -466,14 +465,14 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
return Err(InvalidCharacter);
}
let local_name = local_name.as_slice().to_ascii_lower();
Ok(build_element_from_tag(local_name, namespace::HTML, self))
Ok(build_element_from_tag(local_name, ns!(HTML), self))
}
// http://dom.spec.whatwg.org/#dom-document-createelementns
fn CreateElementNS(self,
namespace: Option<DOMString>,
qualified_name: DOMString) -> Fallible<Temporary<Element>> {
let ns = Namespace::from_str(namespace);
let ns = namespace::from_domstring(namespace);
match xml_name_type(qualified_name.as_slice()) {
InvalidXMLName => {
debug!("Not a valid element name");
@ -490,26 +489,26 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
local_name_from_qname) = get_attribute_parts(qualified_name.as_slice());
match (&ns, prefix_from_qname.clone(), local_name_from_qname.as_slice()) {
// throw if prefix is not null and namespace is null
(&namespace::Null, Some(_), _) => {
(&ns!(""), Some(_), _) => {
debug!("Namespace can't be null with a non-null prefix");
return Err(NamespaceError);
},
// throw if prefix is "xml" and namespace is not the XML namespace
(_, Some(ref prefix), _) if "xml" == prefix.as_slice() && ns != namespace::XML => {
(_, Some(ref prefix), _) if "xml" == prefix.as_slice() && ns != ns!(XML) => {
debug!("Namespace must be the xml namespace if the prefix is 'xml'");
return Err(NamespaceError);
},
// throw if namespace is the XMLNS namespace and neither qualifiedName nor prefix is "xmlns"
(&namespace::XMLNS, Some(ref prefix), _) if "xmlns" == prefix.as_slice() => {},
(&namespace::XMLNS, _, "xmlns") => {},
(&namespace::XMLNS, _, _) => {
(&ns!(XMLNS), Some(ref prefix), _) if "xmlns" == prefix.as_slice() => {},
(&ns!(XMLNS), _, "xmlns") => {},
(&ns!(XMLNS), _, _) => {
debug!("The prefix or the qualified name must be 'xmlns' if namespace is the XMLNS namespace ");
return Err(NamespaceError);
},
_ => {}
}
if ns == namespace::HTML {
if ns == ns!(HTML) {
Ok(build_element_from_tag(local_name_from_qname.to_string(), ns, self))
} else {
Ok(Element::new(local_name_from_qname.to_string(), ns,
@ -755,7 +754,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
}
let element: JSRef<Element> = ElementCast::to_ref(node).unwrap();
element.get_attribute(Null, "name").root().map_or(false, |attr| {
element.get_attribute(ns!(""), "name").root().map_or(false, |attr| {
attr.value().as_slice() == name.as_slice()
})
})

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

@ -12,7 +12,6 @@ use dom::bindings::utils::{Reflector, Reflectable, reflect_dom_object};
use dom::element::{Element, AttributeHandlers};
use dom::node::window_from_node;
use servo_util::namespace::Null;
use servo_util::str::{DOMString, HTML_SPACE_CHARACTERS};
use string_cache::Atom;
@ -56,7 +55,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(ns!(""), self.local_name)
}
fn check_token_exceptions<'a>(self, token: &'a str) -> Fallible<&'a str> {

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

@ -35,13 +35,12 @@ use devtools_traits::AttrInfo;
use style::{matches, parse_selector_list_from_str};
use style;
use servo_util::namespace;
use servo_util::namespace::{Namespace, Null};
use servo_util::str::DOMString;
use std::ascii::StrAsciiExt;
use std::cell::{Cell, RefCell};
use std::mem;
use string_cache::Atom;
use string_cache::{Atom, Namespace};
#[jstraceable]
#[must_root]
@ -229,7 +228,7 @@ pub trait LayoutElementHelpers {
impl LayoutElementHelpers for JS<Element> {
#[allow(unrooted_must_root)]
unsafe fn html_element_in_html_document_for_layout(&self) -> bool {
if (*self.unsafe_get()).namespace != namespace::HTML {
if (*self.unsafe_get()).namespace != ns!(HTML) {
return false
}
let node: JS<Node> = self.transmute_copy();
@ -249,7 +248,7 @@ pub trait ElementHelpers {
impl<'a> ElementHelpers for JSRef<'a, Element> {
fn html_element_in_html_document(&self) -> bool {
let node: JSRef<Node> = NodeCast::from_ref(*self);
self.namespace == namespace::HTML && node.is_in_html_doc()
self.namespace == ns!(HTML) && node.is_in_html_doc()
}
fn get_local_name<'a>(&'a self) -> &'a Atom {
@ -273,7 +272,7 @@ impl<'a> ElementHelpers for JSRef<'a, Element> {
}
fn is_void(self) -> bool {
if self.namespace != namespace::HTML {
if self.namespace != ns!(HTML) {
return false
}
match self.local_name.as_slice() {
@ -351,7 +350,7 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
let name = Atom::from_slice(name);
self.do_set_attribute(name.clone(), value, name.clone(),
namespace::Null, None, |attr| *attr.local_name() == name);
ns!(""), None, |attr| *attr.local_name() == name);
}
fn do_set_attribute(self, local_name: Atom, value: AttrValue,
@ -376,7 +375,7 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
fn parse_attribute(self, namespace: &Namespace, local_name: &Atom,
value: DOMString) -> AttrValue {
if *namespace == namespace::Null {
if *namespace == ns!("") {
vtable_for(&NodeCast::from_ref(self))
.parse_plain_attribute(local_name.as_slice(), value)
} else {
@ -400,7 +399,7 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
node.wait_until_safe_to_modify_dom();
}
if namespace == namespace::Null {
if namespace == ns!("") {
let removed_raw_value = (*self.deref().attrs.borrow())[idx].root().Value();
vtable_for(&NodeCast::from_ref(self))
.before_remove_attr(&local_name,
@ -425,7 +424,7 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
}
fn has_class(&self, name: &str) -> bool {
self.get_attribute(Null, "class").root().map(|attr| {
self.get_attribute(ns!(""), "class").root().map(|attr| {
attr.deref().value().tokens().map(|mut tokens| {
tokens.any(|atom| atom.as_slice() == name)
}).unwrap_or(false)
@ -444,7 +443,7 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
false => Atom::from_slice(name)
};
self.deref().attrs.borrow().iter().map(|attr| attr.root()).any(|attr| {
*attr.local_name() == name && attr.namespace == Null
*attr.local_name() == name && attr.namespace == ns!("")
})
}
@ -453,7 +452,7 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
if value {
self.set_string_attribute(name, String::new());
} else {
self.remove_attribute(Null, name);
self.remove_attribute(ns!(""), name);
}
}
@ -468,7 +467,7 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
fn get_string_attribute(self, name: &str) -> DOMString {
assert!(name == name.to_ascii_lower().as_slice());
match self.get_attribute(Null, name) {
match self.get_attribute(ns!(""), name) {
Some(x) => {
let x = x.root();
x.deref().Value()
@ -488,7 +487,7 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
fn get_uint_attribute(self, name: &str) -> u32 {
assert!(name == name.to_ascii_lower().as_slice());
let attribute = self.get_attribute(Null, name).root();
let attribute = self.get_attribute(ns!(""), name).root();
match attribute {
Some(attribute) => {
match *attribute.deref().value() {
@ -509,8 +508,8 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
// http://dom.spec.whatwg.org/#dom-element-namespaceuri
fn GetNamespaceURI(self) -> Option<DOMString> {
match self.namespace {
Null => None,
ref ns => Some(ns.to_str().to_string())
ns!("") => None,
Namespace(ref ns) => Some(ns.as_slice().to_string())
}
}
@ -592,7 +591,7 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
} else {
name
};
self.get_attribute(Null, name.as_slice()).root()
self.get_attribute(ns!(""), name.as_slice()).root()
.map(|s| s.deref().Value())
}
@ -600,7 +599,7 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
fn GetAttributeNS(self,
namespace: Option<DOMString>,
local_name: DOMString) -> Option<DOMString> {
let namespace = Namespace::from_str(namespace);
let namespace = namespace::from_domstring(namespace);
self.get_attribute(namespace, local_name.as_slice()).root()
.map(|attr| attr.deref().Value())
}
@ -629,8 +628,8 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
// Step 3-5.
let name = Atom::from_slice(name.as_slice());
let value = self.parse_attribute(&namespace::Null, &name, value);
self.do_set_attribute(name.clone(), value, name.clone(), namespace::Null, None, |attr| {
let value = self.parse_attribute(&ns!(""), &name, value);
self.do_set_attribute(name.clone(), value, name.clone(), ns!(""), None, |attr| {
attr.deref().name.as_slice() == name.as_slice()
});
Ok(())
@ -647,7 +646,7 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
}
// Step 1.
let namespace = Namespace::from_str(namespace_url);
let namespace = namespace::from_domstring(namespace_url);
let name_type = xml_name_type(name.as_slice());
match name_type {
@ -663,17 +662,17 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
match prefix {
Some(ref prefix_str) => {
// Step 5.
if namespace == namespace::Null {
if namespace == ns!("") {
return Err(NamespaceError);
}
// Step 6.
if "xml" == prefix_str.as_slice() && namespace != namespace::XML {
if "xml" == prefix_str.as_slice() && namespace != ns!(XML) {
return Err(NamespaceError);
}
// Step 7b.
if "xmlns" == prefix_str.as_slice() && namespace != namespace::XMLNS {
if "xmlns" == prefix_str.as_slice() && namespace != ns!(XMLNS) {
return Err(NamespaceError);
}
},
@ -685,12 +684,12 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
let xmlns = Atom::from_slice("xmlns"); // TODO: Make this a static atom type
// Step 7a.
if xmlns == name && namespace != namespace::XMLNS {
if xmlns == name && namespace != ns!(XMLNS) {
return Err(NamespaceError);
}
// Step 8.
if namespace == namespace::XMLNS && xmlns != name && Some("xmlns") != prefix {
if namespace == ns!(XMLNS) && xmlns != name && Some("xmlns") != prefix {
return Err(NamespaceError);
}
@ -712,14 +711,14 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
} else {
name
};
self.remove_attribute(namespace::Null, name.as_slice())
self.remove_attribute(ns!(""), name.as_slice())
}
// http://dom.spec.whatwg.org/#dom-element-removeattributens
fn RemoveAttributeNS(self,
namespace: Option<DOMString>,
localname: DOMString) {
let namespace = Namespace::from_str(namespace);
let namespace = namespace::from_domstring(namespace);
self.remove_attribute(namespace, localname.as_slice())
}
@ -913,7 +912,7 @@ impl<'a> VirtualMethods for JSRef<'a, Element> {
if !tree_in_doc { return; }
match self.get_attribute(Null, "id").root() {
match self.get_attribute(ns!(""), "id").root() {
Some(attr) => {
let doc = document_from_node(*self).root();
let value = attr.deref().Value();
@ -934,7 +933,7 @@ impl<'a> VirtualMethods for JSRef<'a, Element> {
if !tree_in_doc { return; }
match self.get_attribute(Null, "id").root() {
match self.get_attribute(ns!(""), "id").root() {
Some(attr) => {
let doc = document_from_node(*self).root();
let value = attr.deref().Value();
@ -962,7 +961,7 @@ impl<'a> style::TElement<'a> for JSRef<'a, Element> {
// selector-link
ElementNodeTypeId(HTMLAnchorElementTypeId) |
ElementNodeTypeId(HTMLAreaElementTypeId) |
ElementNodeTypeId(HTMLLinkElementTypeId) => self.get_attr(&namespace::Null, "href"),
ElementNodeTypeId(HTMLLinkElementTypeId) => self.get_attr(&ns!(""), "href"),
_ => None,
}
}
@ -977,7 +976,7 @@ impl<'a> style::TElement<'a> for JSRef<'a, Element> {
node.get_hover_state()
}
fn get_id<'a>(&self) -> Option<Atom> {
self.get_attribute(namespace::Null, "id").map(|attr| {
self.get_attribute(ns!(""), "id").map(|attr| {
let attr = attr.root();
match *attr.value() {
AtomAttrValue(ref val) => val.clone(),

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

@ -19,7 +19,6 @@ use dom::htmlelement::HTMLElement;
use dom::node::{Node, NodeHelpers, ElementNodeTypeId};
use dom::virtualmethods::VirtualMethods;
use servo_util::namespace::Null;
use servo_util::str::DOMString;
#[jstraceable]
@ -56,7 +55,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, "href").root();
let attr = element.get_attribute(ns!(""), "href").root();
match attr {
Some(ref href) => {
let value = href.Value();

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

@ -12,11 +12,11 @@ use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::element::{Element, AttributeHandlers, ElementHelpers};
use dom::node::{Node, NodeHelpers};
use dom::window::Window;
use servo_util::namespace::Namespace;
use servo_util::namespace;
use servo_util::str::{DOMString, split_html_space_chars};
use std::ascii::StrAsciiExt;
use string_cache::Atom;
use string_cache::{Atom, Namespace};
pub trait CollectionFilter : JSTraceable {
fn filter(&self, elem: JSRef<Element>, root: JSRef<Node>) -> bool;
@ -105,7 +105,7 @@ impl HTMLCollection {
maybe_ns: Option<DOMString>) -> Temporary<HTMLCollection> {
let namespace_filter = match maybe_ns {
Some(ref namespace) if namespace.as_slice() == "*" => None,
ns => Some(Namespace::from_str(ns)),
ns => Some(namespace::from_domstring(ns)),
};
if tag.as_slice() == "*" {

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

@ -17,7 +17,6 @@ use dom::eventtarget::{EventTarget, EventTargetHelpers, NodeTargetTypeId};
use dom::node::{Node, ElementNodeTypeId, window_from_node};
use dom::virtualmethods::VirtualMethods;
use servo_util::namespace;
use servo_util::str::DOMString;
use string_cache::Atom;
@ -40,7 +39,7 @@ impl HTMLElementDerived for EventTarget {
impl HTMLElement {
pub fn new_inherited(type_id: ElementTypeId, tag_name: DOMString, document: JSRef<Document>) -> HTMLElement {
HTMLElement {
element: Element::new_inherited(type_id, tag_name, namespace::HTML, None, document)
element: Element::new_inherited(type_id, tag_name, ns!(HTML), None, document)
}
}

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

@ -23,7 +23,6 @@ use page::IterablePage;
use servo_msg::constellation_msg::{PipelineId, SubpageId};
use servo_msg::constellation_msg::{IFrameSandboxed, IFrameUnsandboxed};
use servo_msg::constellation_msg::{ConstellationChan, LoadIframeUrlMsg};
use servo_util::namespace::Null;
use servo_util::str::DOMString;
use string_cache::Atom;
@ -75,7 +74,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, "src").root().and_then(|src| {
element.get_attribute(ns!(""), "src").root().and_then(|src| {
let url = src.deref().value();
if url.as_slice().is_empty() {
None

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

@ -16,7 +16,6 @@ use dom::node::{Node, NodeHelpers, ElementNodeTypeId, window_from_node};
use dom::virtualmethods::VirtualMethods;
use layout_interface::{LayoutChan, LoadStylesheetMsg};
use servo_util::str::{DOMString, HTML_SPACE_CHARACTERS};
use servo_util::namespace::Null;
use std::ascii::StrAsciiExt;
use url::UrlParser;
@ -49,7 +48,7 @@ impl HTMLLinkElement {
}
fn get_attr(element: JSRef<Element>, name: &str) -> Option<String> {
let elem = element.get_attribute(Null, name).root();
let elem = element.get_attribute(ns!(""), name).root();
elem.map(|e| e.deref().value().as_slice().to_string())
}

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

@ -20,7 +20,6 @@ use dom::virtualmethods::VirtualMethods;
use servo_net::image_cache_task;
use servo_net::image_cache_task::ImageCacheTask;
use servo_util::namespace::Null;
use servo_util::str::DOMString;
use string_cache::Atom;
@ -63,8 +62,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, "type").map(|x| x.root().Value()),
elem.get_attribute(Null, "data").map(|x| x.root().Value())) {
match (elem.get_attribute(ns!(""), "type").map(|x| x.root().Value()),
elem.get_attribute(ns!(""), "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();

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

@ -19,7 +19,6 @@ use dom::htmlelement::HTMLElement;
use dom::node::{DisabledStateHelpers, Node, NodeHelpers, ElementNodeTypeId};
use dom::virtualmethods::VirtualMethods;
use servo_util::namespace;
use servo_util::str::{DOMString, split_html_space_chars};
use string_cache::Atom;
@ -51,7 +50,7 @@ impl HTMLOptionElement {
fn collect_text(node: &JSRef<Node>, value: &mut DOMString) {
let elem: JSRef<Element> = ElementCast::to_ref(*node).unwrap();
let svg_script = elem.namespace == namespace::SVG && elem.local_name.as_slice() == "script";
let svg_script = elem.namespace == ns!(SVG) && elem.local_name.as_slice() == "script";
let html_script = node.is_htmlscriptelement();
if svg_script || html_script {
return;

5
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::namespace::Null;
use servo_util::str::{DOMString, HTML_SPACE_CHARACTERS, StaticStringVec};
#[jstraceable]
@ -75,7 +74,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, "type").root().map(|s| s.Value()) {
match element.get_attribute(ns!(""), "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");
@ -87,7 +86,7 @@ impl<'a> HTMLScriptElementHelpers for JSRef<'a, HTMLScriptElement> {
},
None => {
debug!("no script type");
match element.get_attribute(Null, "language").root().map(|s| s.Value()) {
match element.get_attribute(ns!(""), "language").root().map(|s| s.Value()) {
Some(ref s) if s.is_empty() => {
debug!("script language empty, inferring js");
true

13
components/script/dom/htmlserializer.rs
View file

@ -18,7 +18,6 @@ use dom::node::{TextNodeTypeId, NodeHelpers};
use dom::processinginstruction::ProcessingInstruction;
use dom::text::Text;
use servo_util::namespace;
use string_cache::Atom;
#[allow(unrooted_must_root)]
@ -82,7 +81,7 @@ fn serialize_text(text: JSRef<Text>, html: &mut String) {
match elem.deref().local_name.as_slice() {
"style" | "script" | "xmp" | "iframe" |
"noembed" | "noframes" | "plaintext" |
"noscript" if elem.deref().namespace == namespace::HTML
"noscript" if elem.deref().namespace == ns!(HTML)
=> html.push_str(text.deref().characterdata.data.deref().borrow().as_slice()),
_ => escape(text.deref().characterdata.data.deref().borrow().as_slice(), false, html)
}
@ -116,7 +115,7 @@ fn serialize_elem(elem: JSRef<Element>, open_elements: &mut Vec<String>, html: &
html.push_char('>');
match elem.deref().local_name.as_slice() {
"pre" | "listing" | "textarea" if elem.deref().namespace == namespace::HTML => {
"pre" | "listing" | "textarea" if elem.deref().namespace == ns!(HTML) => {
let node: JSRef<Node> = NodeCast::from_ref(elem);
match node.first_child().map(|child| child.root()) {
Some(ref child) if child.is_text() => {
@ -138,16 +137,16 @@ fn serialize_elem(elem: JSRef<Element>, open_elements: &mut Vec<String>, html: &
fn serialize_attr(attr: JSRef<Attr>, html: &mut String) {
html.push_char(' ');
if attr.deref().namespace == namespace::XML {
if attr.deref().namespace == ns!(XML) {
html.push_str("xml:");
html.push_str(attr.local_name().as_slice());
} else if attr.deref().namespace == namespace::XMLNS &&
} else if attr.deref().namespace == ns!(XMLNS) &&
*attr.local_name() == Atom::from_slice("xmlns") {
html.push_str("xmlns");
} else if attr.deref().namespace == namespace::XMLNS {
} else if attr.deref().namespace == ns!(XMLNS) {
html.push_str("xmlns:");
html.push_str(attr.local_name().as_slice());
} else if attr.deref().namespace == namespace::XLink {
} else if attr.deref().namespace == ns!(XLink) {
html.push_str("xlink:");
html.push_str(attr.local_name().as_slice());
} else {

22
components/script/html/hubbub_html_parser.rs
View file

@ -25,8 +25,6 @@ use encoding::types::{Encoding, DecodeReplace};
use hubbub::hubbub;
use hubbub::hubbub::{NullNs, HtmlNs, MathMlNs, SvgNs, XLinkNs, XmlNs, XmlNsNs};
use servo_net::resource_task::{Load, LoadData, Payload, Done, ResourceTask, load_whole_resource};
use servo_util::namespace;
use servo_util::namespace::{Namespace, Null};
use servo_util::str::DOMString;
use servo_util::task::spawn_named;
use std::ascii::StrAsciiExt;
@ -36,7 +34,7 @@ use std::comm::{channel, Sender, Receiver};
use url::{Url, UrlParser};
use http::headers::HeaderEnum;
use time;
use string_cache::Atom;
use string_cache::{Atom, Namespace};
macro_rules! handle_element(
($document: expr,
@ -153,7 +151,7 @@ fn parse_last_modified(timestamp: &str) -> String {
// via atomization (issue #85).
pub fn build_element_from_tag(tag: DOMString, ns: Namespace, document: JSRef<Document>) -> Temporary<Element> {
if ns != namespace::HTML {
if ns != ns!(HTML) {
return Element::new(tag, ns, None, document);
}
@ -373,9 +371,9 @@ pub fn parse_html(page: &Page,
let tmp_borrow = doc_cell.borrow();
let tmp = &*tmp_borrow;
let namespace = match tag.ns {
HtmlNs => namespace::HTML,
MathMlNs => namespace::MathML,
SvgNs => namespace::SVG,
HtmlNs => ns!(HTML),
MathMlNs => ns!(MathML),
SvgNs => ns!(SVG),
ns => fail!("Not expecting namespace {:?}", ns),
};
let element: Root<Element> = build_element_from_tag(tag.name.clone(), namespace, *tmp).root();
@ -383,10 +381,10 @@ pub fn parse_html(page: &Page,
debug!("-- attach attrs");
for attr in tag.attributes.iter() {
let (namespace, prefix) = match attr.ns {
NullNs => (namespace::Null, None),
XLinkNs => (namespace::XLink, Some("xlink")),
XmlNs => (namespace::XML, Some("xml")),
XmlNsNs => (namespace::XMLNS, Some("xmlns")),
NullNs => (ns!(""), None),
XLinkNs => (ns!(XLink), Some("xlink")),
XmlNs => (ns!(XML), Some("xml")),
XmlNsNs => (ns!(XMLNS), Some("xmlns")),
ns => fail!("Not expecting namespace {:?}", ns),
};
element.set_attribute_from_parser(Atom::from_slice(attr.name.as_slice()),
@ -472,7 +470,7 @@ pub fn parse_html(page: &Page,
};
let script_element: JSRef<Element> = ElementCast::from_ref(script);
match script_element.get_attribute(Null, "src").root() {
match script_element.get_attribute(ns!(""), "src").root() {
Some(src) => {
debug!("found script: {:s}", src.deref().Value());
let mut url_parser = UrlParser::new();

3
components/script/page.rs
View file

@ -27,7 +27,6 @@ use servo_msg::compositor_msg::ScriptListener;
use servo_msg::constellation_msg::{ConstellationChan, WindowSizeData};
use servo_msg::constellation_msg::{PipelineId, SubpageId};
use servo_net::resource_task::ResourceTask;
use servo_util::namespace::Null;
use servo_util::str::DOMString;
use std::cell::{Cell, RefCell, Ref, RefMut};
use std::comm::{channel, Receiver, Empty, Disconnected};
@ -400,7 +399,7 @@ impl Page {
.filter(|node| node.is_anchor_element());
anchors.find(|node| {
let elem: JSRef<Element> = ElementCast::to_ref(*node).unwrap();
elem.get_attribute(Null, "name").root().map_or(false, |attr| {
elem.get_attribute(ns!(""), "name").root().map_or(false, |attr| {
attr.deref().value().as_slice() == fragid.as_slice()
})
}).map(|node| Temporary::from_rooted(ElementCast::to_ref(node).unwrap()))