Use string-cache's Namespace type

14 files changed, 65 insertions, 77 deletions

diff --git a/components/script/dom/attr.rs b/components/script/dom/attr.rs
index bd2d90e2ec6..6dff298c95f 100644
--- a/components/script/dom/attr.rs
+++ b/components/script/dom/attr.rs
@@ -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(),
         }
diff --git a/components/script/dom/bindings/trace.rs b/components/script/dom/bindings/trace.rs
index af3083d456d..eb03b360471 100644
--- a/components/script/dom/bindings/trace.rs
+++ b/components/script/dom/bindings/trace.rs
@@ -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) {
diff --git a/components/script/dom/document.rs b/components/script/dom/document.rs
index a66ec400e34..b3261f6df39 100644
--- a/components/script/dom/document.rs
+++ b/components/script/dom/document.rs
@@ -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()
             })
         })
diff --git a/components/script/dom/domtokenlist.rs b/components/script/dom/domtokenlist.rs
index d66fc059582..7909053c4af 100644
--- a/components/script/dom/domtokenlist.rs
+++ b/components/script/dom/domtokenlist.rs
@@ -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> {
diff --git a/components/script/dom/element.rs b/components/script/dom/element.rs
index a789ecb41a7..bf5f9014fd2 100644
--- a/components/script/dom/element.rs
+++ b/components/script/dom/element.rs
@@ -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(),
diff --git a/components/script/dom/htmlanchorelement.rs b/components/script/dom/htmlanchorelement.rs
index 72a473aa468..e182e8170b3 100644
--- a/components/script/dom/htmlanchorelement.rs
+++ b/components/script/dom/htmlanchorelement.rs
@@ -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();
diff --git a/components/script/dom/htmlcollection.rs b/components/script/dom/htmlcollection.rs
index 049cb5de60e..34c4a41e6f7 100644
--- a/components/script/dom/htmlcollection.rs
+++ b/components/script/dom/htmlcollection.rs
@@ -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() == "*" {
diff --git a/components/script/dom/htmlelement.rs b/components/script/dom/htmlelement.rs
index 44ed7910320..96c3af3a8fd 100644
--- a/components/script/dom/htmlelement.rs
+++ b/components/script/dom/htmlelement.rs
@@ -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)
         }
     }
 
diff --git a/components/script/dom/htmliframeelement.rs b/components/script/dom/htmliframeelement.rs
index 49323fea7a9..24a90163065 100644
--- a/components/script/dom/htmliframeelement.rs
+++ b/components/script/dom/htmliframeelement.rs
@@ -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
diff --git a/components/script/dom/htmllinkelement.rs b/components/script/dom/htmllinkelement.rs
index fe78cfe47c4..2e1c9cfcdfc 100644
--- a/components/script/dom/htmllinkelement.rs
+++ b/components/script/dom/htmllinkelement.rs
@@ -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())
 }
 
diff --git a/components/script/dom/htmlobjectelement.rs b/components/script/dom/htmlobjectelement.rs
index 759f3c37c59..268c4699456 100644
--- a/components/script/dom/htmlobjectelement.rs
+++ b/components/script/dom/htmlobjectelement.rs
@@ -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();
diff --git a/components/script/dom/htmloptionelement.rs b/components/script/dom/htmloptionelement.rs
index b87621f8e3b..568d991a5ce 100644
--- a/components/script/dom/htmloptionelement.rs
+++ b/components/script/dom/htmloptionelement.rs
@@ -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;
diff --git a/components/script/dom/htmlscriptelement.rs b/components/script/dom/htmlscriptelement.rs
index 08511ba87d3..73a39aab521 100644
--- a/components/script/dom/htmlscriptelement.rs
+++ b/components/script/dom/htmlscriptelement.rs
@@ -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
diff --git a/components/script/dom/htmlserializer.rs b/components/script/dom/htmlserializer.rs
index 32606f94896..c9f6753b815 100644
--- a/components/script/dom/htmlserializer.rs
+++ b/components/script/dom/htmlserializer.rs
@@ -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 {