auto merge of #1690 : Ms2ger/servo/DOMStrings, r=jdm

76 files changed, 161 insertions, 146 deletions

diff --git a/src/components/script/dom/characterdata.rs b/src/components/script/dom/characterdata.rs
index bf3c81fd0c5..778e2fa7c6c 100644
--- a/src/components/script/dom/characterdata.rs
+++ b/src/components/script/dom/characterdata.rs
@@ -11,11 +11,11 @@ use dom::node::{Node, NodeTypeId};
 
 pub struct CharacterData {
     node: Node,
-    data: ~str
+    data: DOMString,
 }
 
 impl CharacterData {
-    pub fn new_inherited(id: NodeTypeId, data: ~str, document: AbstractDocument) -> CharacterData {
+    pub fn new_inherited(id: NodeTypeId, data: DOMString, document: AbstractDocument) -> CharacterData {
         CharacterData {
             node: Node::new_inherited(id, document),
             data: data
diff --git a/src/components/script/dom/comment.rs b/src/components/script/dom/comment.rs
index 1d42d28b97f..b8d85e1c110 100644
--- a/src/components/script/dom/comment.rs
+++ b/src/components/script/dom/comment.rs
@@ -15,13 +15,13 @@ pub struct Comment {
 }
 
 impl Comment {
-    pub fn new_inherited(text: ~str, document: AbstractDocument) -> Comment {
+    pub fn new_inherited(text: DOMString, document: AbstractDocument) -> Comment {
         Comment {
             element: CharacterData::new_inherited(CommentNodeTypeId, text, document)
         }
     }
 
-    pub fn new(text: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(text: DOMString, document: AbstractDocument) -> AbstractNode {
         let node = Comment::new_inherited(text, document);
         Node::reflect_node(@mut node, document, CommentBinding::Wrap)
     }
diff --git a/src/components/script/dom/event.rs b/src/components/script/dom/event.rs
index d6edf098195..0b436fe3254 100644
--- a/src/components/script/dom/event.rs
+++ b/src/components/script/dom/event.rs
@@ -132,7 +132,7 @@ pub struct Event {
     reflector_: Reflector,
     current_target: Option<AbstractEventTarget>,
     target: Option<AbstractEventTarget>,
-    type_: ~str,
+    type_: DOMString,
     phase: EventPhase,
     default_prevented: bool,
     stop_propagation: bool,
diff --git a/src/components/script/dom/eventtarget.rs b/src/components/script/dom/eventtarget.rs
index 9ee4c123870..9d04d716f74 100644
--- a/src/components/script/dom/eventtarget.rs
+++ b/src/components/script/dom/eventtarget.rs
@@ -36,7 +36,7 @@ struct EventListenerEntry {
 pub struct EventTarget {
     type_id: EventTargetTypeId,
     reflector_: Reflector,
-    handlers: HashMap<~str, ~[EventListenerEntry]>,
+    handlers: HashMap<DOMString, ~[EventListenerEntry]>,
 }
 
 pub struct AbstractEventTarget {
diff --git a/src/components/script/dom/formdata.rs b/src/components/script/dom/formdata.rs
index 3722fb3e9ca..3e24f9e4dbb 100644
--- a/src/components/script/dom/formdata.rs
+++ b/src/components/script/dom/formdata.rs
@@ -17,7 +17,7 @@ enum FormDatum {
 }
 
 pub struct FormData {
-    data: HashMap<~str, FormDatum>,
+    data: HashMap<DOMString, FormDatum>,
     reflector_: Reflector,
     window: @mut Window,
     form: Option<AbstractNode>
diff --git a/src/components/script/dom/htmlanchorelement.rs b/src/components/script/dom/htmlanchorelement.rs
index db1d68472d2..c2146a142c3 100644
--- a/src/components/script/dom/htmlanchorelement.rs
+++ b/src/components/script/dom/htmlanchorelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLAnchorElement {
 }
 
 impl HTMLAnchorElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLAnchorElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLAnchorElement {
         HTMLAnchorElement {
             htmlelement: HTMLElement::new_inherited(HTMLAnchorElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLAnchorElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLAnchorElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlappletelement.rs b/src/components/script/dom/htmlappletelement.rs
index 5d5a9f5df5d..b290af51d08 100644
--- a/src/components/script/dom/htmlappletelement.rs
+++ b/src/components/script/dom/htmlappletelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLAppletElement {
 }
 
 impl HTMLAppletElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLAppletElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLAppletElement {
         HTMLAppletElement {
             htmlelement: HTMLElement::new_inherited(HTMLAppletElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLAppletElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLAppletElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlareaelement.rs b/src/components/script/dom/htmlareaelement.rs
index cb088d52542..bc916e7c9e0 100644
--- a/src/components/script/dom/htmlareaelement.rs
+++ b/src/components/script/dom/htmlareaelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLAreaElement {
 }
 
 impl HTMLAreaElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLAreaElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLAreaElement {
         HTMLAreaElement {
             htmlelement: HTMLElement::new_inherited(HTMLAreaElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLAreaElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLAreaElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlaudioelement.rs b/src/components/script/dom/htmlaudioelement.rs
index 45f2e9af340..b1013a2342e 100644
--- a/src/components/script/dom/htmlaudioelement.rs
+++ b/src/components/script/dom/htmlaudioelement.rs
@@ -3,6 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::HTMLAudioElementBinding;
+use dom::bindings::utils::DOMString;
 use dom::document::AbstractDocument;
 use dom::element::HTMLAudioElementTypeId;
 use dom::htmlmediaelement::HTMLMediaElement;
@@ -13,13 +14,13 @@ pub struct HTMLAudioElement {
 }
 
 impl HTMLAudioElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLAudioElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLAudioElement {
         HTMLAudioElement {
             htmlmediaelement: HTMLMediaElement::new_inherited(HTMLAudioElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLAudioElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLAudioElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlbaseelement.rs b/src/components/script/dom/htmlbaseelement.rs
index 10d07f226c5..8812a1d733a 100644
--- a/src/components/script/dom/htmlbaseelement.rs
+++ b/src/components/script/dom/htmlbaseelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLBaseElement {
 }
 
 impl HTMLBaseElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLBaseElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLBaseElement {
         HTMLBaseElement {
             htmlelement: HTMLElement::new_inherited(HTMLBaseElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLBaseElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLBaseElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlbodyelement.rs b/src/components/script/dom/htmlbodyelement.rs
index 944d09ce3b2..6d8565cd3e7 100644
--- a/src/components/script/dom/htmlbodyelement.rs
+++ b/src/components/script/dom/htmlbodyelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLBodyElement {
 }
 
 impl HTMLBodyElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLBodyElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLBodyElement {
         HTMLBodyElement {
             htmlelement: HTMLElement::new_inherited(HTMLBodyElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLBodyElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLBodyElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlbrelement.rs b/src/components/script/dom/htmlbrelement.rs
index 51e04f07d58..2ecfbe1036e 100644
--- a/src/components/script/dom/htmlbrelement.rs
+++ b/src/components/script/dom/htmlbrelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLBRElement {
 }
 
 impl HTMLBRElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLBRElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLBRElement {
         HTMLBRElement {
             htmlelement: HTMLElement::new_inherited(HTMLBRElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLBRElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLBRElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlbuttonelement.rs b/src/components/script/dom/htmlbuttonelement.rs
index 95b162acaa6..943f2432d99 100644
--- a/src/components/script/dom/htmlbuttonelement.rs
+++ b/src/components/script/dom/htmlbuttonelement.rs
@@ -15,13 +15,13 @@ pub struct HTMLButtonElement {
 }
 
 impl HTMLButtonElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLButtonElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLButtonElement {
         HTMLButtonElement {
             htmlelement: HTMLElement::new_inherited(HTMLButtonElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLButtonElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLButtonElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlcanvaselement.rs b/src/components/script/dom/htmlcanvaselement.rs
index 086c859447a..bda496c1dbb 100644
--- a/src/components/script/dom/htmlcanvaselement.rs
+++ b/src/components/script/dom/htmlcanvaselement.rs
@@ -3,6 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::HTMLCanvasElementBinding;
+use dom::bindings::utils::DOMString;
 use dom::bindings::utils::{ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLCanvasElementTypeId;
@@ -14,13 +15,13 @@ pub struct HTMLCanvasElement {
 }
 
 impl HTMLCanvasElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLCanvasElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLCanvasElement {
         HTMLCanvasElement {
             htmlelement: HTMLElement::new_inherited(HTMLCanvasElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLCanvasElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLCanvasElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmldataelement.rs b/src/components/script/dom/htmldataelement.rs
index 7a4f7795a9f..bc802107450 100644
--- a/src/components/script/dom/htmldataelement.rs
+++ b/src/components/script/dom/htmldataelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLDataElement {
 }
 
 impl HTMLDataElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLDataElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLDataElement {
         HTMLDataElement {
             htmlelement: HTMLElement::new_inherited(HTMLDataElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLDataElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLDataElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmldatalistelement.rs b/src/components/script/dom/htmldatalistelement.rs
index 2cc31b6b428..2d6ab1f1a95 100644
--- a/src/components/script/dom/htmldatalistelement.rs
+++ b/src/components/script/dom/htmldatalistelement.rs
@@ -3,6 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::HTMLDataListElementBinding;
+use dom::bindings::utils::DOMString;
 use dom::document::AbstractDocument;
 use dom::element::HTMLDataListElementTypeId;
 use dom::htmlcollection::HTMLCollection;
@@ -14,13 +15,13 @@ pub struct HTMLDataListElement {
 }
 
 impl HTMLDataListElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLDataListElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLDataListElement {
         HTMLDataListElement {
             htmlelement: HTMLElement::new_inherited(HTMLDataListElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLDataListElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLDataListElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmldirectoryelement.rs b/src/components/script/dom/htmldirectoryelement.rs
index 026e8883055..878191682a4 100644
--- a/src/components/script/dom/htmldirectoryelement.rs
+++ b/src/components/script/dom/htmldirectoryelement.rs
@@ -3,6 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::HTMLDirectoryElementBinding;
+use dom::bindings::utils::DOMString;
 use dom::bindings::utils::ErrorResult;
 use dom::document::AbstractDocument;
 use dom::element::HTMLDirectoryElementTypeId;
@@ -14,13 +15,13 @@ pub struct HTMLDirectoryElement {
 }
 
 impl HTMLDirectoryElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLDirectoryElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLDirectoryElement {
         HTMLDirectoryElement {
             htmlelement: HTMLElement::new_inherited(HTMLDirectoryElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLDirectoryElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLDirectoryElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmldivelement.rs b/src/components/script/dom/htmldivelement.rs
index 0d32034dcf6..a1effa5351b 100644
--- a/src/components/script/dom/htmldivelement.rs
+++ b/src/components/script/dom/htmldivelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLDivElement {
 }
 
 impl HTMLDivElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLDivElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLDivElement {
         HTMLDivElement {
             htmlelement: HTMLElement::new_inherited(HTMLDivElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLDivElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLDivElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmldlistelement.rs b/src/components/script/dom/htmldlistelement.rs
index 3bfff50575a..64e813f6cbc 100644
--- a/src/components/script/dom/htmldlistelement.rs
+++ b/src/components/script/dom/htmldlistelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLDListElement {
 }
 
 impl HTMLDListElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLDListElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLDListElement {
         HTMLDListElement {
             htmlelement: HTMLElement::new_inherited(HTMLDListElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLDListElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLDListElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlelement.rs b/src/components/script/dom/htmlelement.rs
index 19aecc6d947..495acc89459 100644
--- a/src/components/script/dom/htmlelement.rs
+++ b/src/components/script/dom/htmlelement.rs
@@ -16,13 +16,13 @@ pub struct HTMLElement {
 }
 
 impl HTMLElement {
-    pub fn new_inherited(type_id: ElementTypeId, tag_name: ~str, document: AbstractDocument) -> HTMLElement {
+    pub fn new_inherited(type_id: ElementTypeId, tag_name: DOMString, document: AbstractDocument) -> HTMLElement {
         HTMLElement {
             element: Element::new_inherited(type_id, tag_name, namespace::HTML, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLElement::new_inherited(HTMLElementTypeId, localName, document);
         Node::reflect_node(@mut element, document, HTMLElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlembedelement.rs b/src/components/script/dom/htmlembedelement.rs
index b387aa51800..870466d60ee 100644
--- a/src/components/script/dom/htmlembedelement.rs
+++ b/src/components/script/dom/htmlembedelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLEmbedElement {
 }
 
 impl HTMLEmbedElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLEmbedElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLEmbedElement {
         HTMLEmbedElement {
             htmlelement: HTMLElement::new_inherited(HTMLEmbedElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLEmbedElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLEmbedElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlfieldsetelement.rs b/src/components/script/dom/htmlfieldsetelement.rs
index f63a56fe723..194dae232da 100644
--- a/src/components/script/dom/htmlfieldsetelement.rs
+++ b/src/components/script/dom/htmlfieldsetelement.rs
@@ -16,13 +16,13 @@ pub struct HTMLFieldSetElement {
 }
 
 impl HTMLFieldSetElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLFieldSetElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLFieldSetElement {
         HTMLFieldSetElement {
             htmlelement: HTMLElement::new_inherited(HTMLFieldSetElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLFieldSetElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLFieldSetElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlfontelement.rs b/src/components/script/dom/htmlfontelement.rs
index dc9924b102b..0f23d6f464c 100644
--- a/src/components/script/dom/htmlfontelement.rs
+++ b/src/components/script/dom/htmlfontelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLFontElement {
 }
 
 impl HTMLFontElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLFontElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLFontElement {
         HTMLFontElement {
             htmlelement: HTMLElement::new_inherited(HTMLFontElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLFontElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLFontElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlformelement.rs b/src/components/script/dom/htmlformelement.rs
index 4382c863169..e8236ea7e5b 100644
--- a/src/components/script/dom/htmlformelement.rs
+++ b/src/components/script/dom/htmlformelement.rs
@@ -15,13 +15,13 @@ pub struct HTMLFormElement {
 }
 
 impl HTMLFormElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLFormElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLFormElement {
         HTMLFormElement {
             htmlelement: HTMLElement::new_inherited(HTMLFormElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLFormElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLFormElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlframeelement.rs b/src/components/script/dom/htmlframeelement.rs
index c8daf679ccc..dd04a15d342 100644
--- a/src/components/script/dom/htmlframeelement.rs
+++ b/src/components/script/dom/htmlframeelement.rs
@@ -15,13 +15,13 @@ pub struct HTMLFrameElement {
 }
 
 impl HTMLFrameElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLFrameElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLFrameElement {
         HTMLFrameElement {
             htmlelement: HTMLElement::new_inherited(HTMLFrameElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLFrameElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLFrameElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlframesetelement.rs b/src/components/script/dom/htmlframesetelement.rs
index 60aa03d4e94..4f41cf9e7fa 100644
--- a/src/components/script/dom/htmlframesetelement.rs
+++ b/src/components/script/dom/htmlframesetelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLFrameSetElement {
 }
 
 impl HTMLFrameSetElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLFrameSetElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLFrameSetElement {
         HTMLFrameSetElement {
             htmlelement: HTMLElement::new_inherited(HTMLFrameSetElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLFrameSetElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLFrameSetElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlheadelement.rs b/src/components/script/dom/htmlheadelement.rs
index d480504aeab..0bd735c125c 100644
--- a/src/components/script/dom/htmlheadelement.rs
+++ b/src/components/script/dom/htmlheadelement.rs
@@ -3,6 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::HTMLHeadElementBinding;
+use dom::bindings::utils::DOMString;
 use dom::document::AbstractDocument;
 use dom::element::HTMLHeadElementTypeId;
 use dom::htmlelement::HTMLElement;
@@ -13,13 +14,13 @@ pub struct HTMLHeadElement {
 }
 
 impl HTMLHeadElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLHeadElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLHeadElement {
         HTMLHeadElement {
             htmlelement: HTMLElement::new_inherited(HTMLHeadElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLHeadElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLHeadElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlheadingelement.rs b/src/components/script/dom/htmlheadingelement.rs
index 284982c6852..4b46223894b 100644
--- a/src/components/script/dom/htmlheadingelement.rs
+++ b/src/components/script/dom/htmlheadingelement.rs
@@ -24,14 +24,14 @@ pub struct HTMLHeadingElement {
 }
 
 impl HTMLHeadingElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument, level: HeadingLevel) -> HTMLHeadingElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument, level: HeadingLevel) -> HTMLHeadingElement {
         HTMLHeadingElement {
             htmlelement: HTMLElement::new_inherited(HTMLHeadingElementTypeId, localName, document),
             level: level,
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument, level: HeadingLevel) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument, level: HeadingLevel) -> AbstractNode {
         let element = HTMLHeadingElement::new_inherited(localName, document, level);
         Node::reflect_node(@mut element, document, HTMLHeadingElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlhrelement.rs b/src/components/script/dom/htmlhrelement.rs
index 274e82be2ff..07e58f0f15b 100644
--- a/src/components/script/dom/htmlhrelement.rs
+++ b/src/components/script/dom/htmlhrelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLHRElement {
 }
 
 impl HTMLHRElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLHRElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLHRElement {
         HTMLHRElement {
             htmlelement: HTMLElement::new_inherited(HTMLHRElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLHRElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLHRElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlhtmlelement.rs b/src/components/script/dom/htmlhtmlelement.rs
index 685f01b6bbd..82b568d74ef 100644
--- a/src/components/script/dom/htmlhtmlelement.rs
+++ b/src/components/script/dom/htmlhtmlelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLHtmlElement {
 }
 
 impl HTMLHtmlElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLHtmlElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLHtmlElement {
         HTMLHtmlElement {
             htmlelement: HTMLElement::new_inherited(HTMLHtmlElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLHtmlElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLHtmlElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmliframeelement.rs b/src/components/script/dom/htmliframeelement.rs
index 7743901015f..3e8ff7d76ce 100644
--- a/src/components/script/dom/htmliframeelement.rs
+++ b/src/components/script/dom/htmliframeelement.rs
@@ -43,7 +43,7 @@ impl HTMLIFrameElement {
 }
 
 impl HTMLIFrameElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLIFrameElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLIFrameElement {
         HTMLIFrameElement {
             htmlelement: HTMLElement::new_inherited(HTMLIframeElementTypeId, localName, document),
             frame: None,
@@ -52,7 +52,7 @@ impl HTMLIFrameElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLIFrameElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLIFrameElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlimageelement.rs b/src/components/script/dom/htmlimageelement.rs
index c7272e49431..157d9ab3fb9 100644
--- a/src/components/script/dom/htmlimageelement.rs
+++ b/src/components/script/dom/htmlimageelement.rs
@@ -22,14 +22,14 @@ pub struct HTMLImageElement {
 }
 
 impl HTMLImageElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLImageElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLImageElement {
         HTMLImageElement {
             htmlelement: HTMLElement::new_inherited(HTMLImageElementTypeId, localName, document),
             image: None,
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLImageElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLImageElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlinputelement.rs b/src/components/script/dom/htmlinputelement.rs
index 6505fdc62b5..ee9b994a5fd 100644
--- a/src/components/script/dom/htmlinputelement.rs
+++ b/src/components/script/dom/htmlinputelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLInputElement {
 }
 
 impl HTMLInputElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLInputElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLInputElement {
         HTMLInputElement {
             htmlelement: HTMLElement::new_inherited(HTMLInputElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLInputElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLInputElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmllabelelement.rs b/src/components/script/dom/htmllabelelement.rs
index cfba2f43256..1a1d88df9f3 100644
--- a/src/components/script/dom/htmllabelelement.rs
+++ b/src/components/script/dom/htmllabelelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLLabelElement {
 }
 
 impl HTMLLabelElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLLabelElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLLabelElement {
         HTMLLabelElement {
             htmlelement: HTMLElement::new_inherited(HTMLLabelElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLLabelElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLLabelElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmllegendelement.rs b/src/components/script/dom/htmllegendelement.rs
index 11e0409c022..875d02ab553 100644
--- a/src/components/script/dom/htmllegendelement.rs
+++ b/src/components/script/dom/htmllegendelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLLegendElement {
 }
 
 impl HTMLLegendElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLLegendElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLLegendElement {
         HTMLLegendElement {
             htmlelement: HTMLElement::new_inherited(HTMLLegendElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLLegendElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLLegendElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmllielement.rs b/src/components/script/dom/htmllielement.rs
index 28ce96b2392..4d7b0c9f027 100644
--- a/src/components/script/dom/htmllielement.rs
+++ b/src/components/script/dom/htmllielement.rs
@@ -14,13 +14,13 @@ pub struct HTMLLIElement {
 }
 
 impl HTMLLIElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLLIElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLLIElement {
         HTMLLIElement {
             htmlelement: HTMLElement::new_inherited(HTMLLIElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLLIElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLLIElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmllinkelement.rs b/src/components/script/dom/htmllinkelement.rs
index 905ca7109d4..df2e4d3bf20 100644
--- a/src/components/script/dom/htmllinkelement.rs
+++ b/src/components/script/dom/htmllinkelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLLinkElement {
 }
 
 impl HTMLLinkElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLLinkElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLLinkElement {
         HTMLLinkElement {
             htmlelement: HTMLElement::new_inherited(HTMLLinkElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLLinkElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLLinkElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlmainelement.rs b/src/components/script/dom/htmlmainelement.rs
index a310f139660..6f7ccb6621b 100644
--- a/src/components/script/dom/htmlmainelement.rs
+++ b/src/components/script/dom/htmlmainelement.rs
@@ -3,6 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::HTMLMainElementBinding;
+use dom::bindings::utils::DOMString;
 use dom::document::AbstractDocument;
 use dom::element::HTMLMainElementTypeId;
 use dom::htmlelement::HTMLElement;
@@ -13,13 +14,13 @@ pub struct HTMLMainElement {
 }
 
 impl HTMLMainElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLMainElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLMainElement {
         HTMLMainElement {
             htmlelement: HTMLElement::new_inherited(HTMLMainElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLMainElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLMainElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlmapelement.rs b/src/components/script/dom/htmlmapelement.rs
index fc6bbc444c5..43124ae26cc 100644
--- a/src/components/script/dom/htmlmapelement.rs
+++ b/src/components/script/dom/htmlmapelement.rs
@@ -15,13 +15,13 @@ pub struct HTMLMapElement {
 }
 
 impl HTMLMapElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLMapElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLMapElement {
         HTMLMapElement {
             htmlelement: HTMLElement::new_inherited(HTMLMapElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLMapElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLMapElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlmediaelement.rs b/src/components/script/dom/htmlmediaelement.rs
index 192da18ee3e..67ce9078e21 100644
--- a/src/components/script/dom/htmlmediaelement.rs
+++ b/src/components/script/dom/htmlmediaelement.rs
@@ -12,7 +12,7 @@ pub struct HTMLMediaElement {
 }
 
 impl HTMLMediaElement {
-    pub fn new_inherited(type_id: ElementTypeId, tag_name: ~str, document: AbstractDocument) -> HTMLMediaElement {
+    pub fn new_inherited(type_id: ElementTypeId, tag_name: DOMString, document: AbstractDocument) -> HTMLMediaElement {
         HTMLMediaElement {
             htmlelement: HTMLElement::new_inherited(type_id, tag_name, document)
         }
diff --git a/src/components/script/dom/htmlmetaelement.rs b/src/components/script/dom/htmlmetaelement.rs
index e57d3d6b595..ae2d6eab2ae 100644
--- a/src/components/script/dom/htmlmetaelement.rs
+++ b/src/components/script/dom/htmlmetaelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLMetaElement {
 }
 
 impl HTMLMetaElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLMetaElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLMetaElement {
         HTMLMetaElement {
             htmlelement: HTMLElement::new_inherited(HTMLMetaElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLMetaElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLMetaElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlmeterelement.rs b/src/components/script/dom/htmlmeterelement.rs
index 30067b1d0e9..8b8a89dca75 100644
--- a/src/components/script/dom/htmlmeterelement.rs
+++ b/src/components/script/dom/htmlmeterelement.rs
@@ -3,6 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::HTMLMeterElementBinding;
+use dom::bindings::utils::DOMString;
 use dom::bindings::utils::ErrorResult;
 use dom::document::AbstractDocument;
 use dom::element::HTMLMeterElementTypeId;
@@ -14,13 +15,13 @@ pub struct HTMLMeterElement {
 }
 
 impl HTMLMeterElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLMeterElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLMeterElement {
         HTMLMeterElement {
             htmlelement: HTMLElement::new_inherited(HTMLMeterElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLMeterElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLMeterElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlmodelement.rs b/src/components/script/dom/htmlmodelement.rs
index b1357875f17..fb8fc1114e5 100644
--- a/src/components/script/dom/htmlmodelement.rs
+++ b/src/components/script/dom/htmlmodelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLModElement {
 }
 
 impl HTMLModElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLModElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLModElement {
         HTMLModElement {
             htmlelement: HTMLElement::new_inherited(HTMLModElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLModElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLModElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlobjectelement.rs b/src/components/script/dom/htmlobjectelement.rs
index eb4375be216..6bfceea009e 100644
--- a/src/components/script/dom/htmlobjectelement.rs
+++ b/src/components/script/dom/htmlobjectelement.rs
@@ -16,13 +16,13 @@ pub struct HTMLObjectElement {
 }
 
 impl HTMLObjectElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLObjectElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLObjectElement {
         HTMLObjectElement {
             htmlelement: HTMLElement::new_inherited(HTMLObjectElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLObjectElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLObjectElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlolistelement.rs b/src/components/script/dom/htmlolistelement.rs
index 9946f51ba3d..2b8229ef059 100644
--- a/src/components/script/dom/htmlolistelement.rs
+++ b/src/components/script/dom/htmlolistelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLOListElement {
 }
 
 impl HTMLOListElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLOListElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLOListElement {
         HTMLOListElement {
             htmlelement: HTMLElement::new_inherited(HTMLOListElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLOListElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLOListElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmloptgroupelement.rs b/src/components/script/dom/htmloptgroupelement.rs
index 8c1d4c3922c..76661bd5a61 100644
--- a/src/components/script/dom/htmloptgroupelement.rs
+++ b/src/components/script/dom/htmloptgroupelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLOptGroupElement {
 }
 
 impl HTMLOptGroupElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLOptGroupElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLOptGroupElement {
         HTMLOptGroupElement {
             htmlelement: HTMLElement::new_inherited(HTMLOptGroupElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLOptGroupElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLOptGroupElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmloptionelement.rs b/src/components/script/dom/htmloptionelement.rs
index 6beb2ba3c18..35af2ad0aff 100644
--- a/src/components/script/dom/htmloptionelement.rs
+++ b/src/components/script/dom/htmloptionelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLOptionElement {
 }
 
 impl HTMLOptionElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLOptionElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLOptionElement {
         HTMLOptionElement {
             htmlelement: HTMLElement::new_inherited(HTMLOptionElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLOptionElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLOptionElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmloutputelement.rs b/src/components/script/dom/htmloutputelement.rs
index 26b399af8b3..b83c007fbb8 100644
--- a/src/components/script/dom/htmloutputelement.rs
+++ b/src/components/script/dom/htmloutputelement.rs
@@ -15,13 +15,13 @@ pub struct HTMLOutputElement {
 }
 
 impl HTMLOutputElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLOutputElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLOutputElement {
         HTMLOutputElement {
             htmlelement: HTMLElement::new_inherited(HTMLOutputElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLOutputElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLOutputElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlparagraphelement.rs b/src/components/script/dom/htmlparagraphelement.rs
index 3fdc422cced..e48d69cba52 100644
--- a/src/components/script/dom/htmlparagraphelement.rs
+++ b/src/components/script/dom/htmlparagraphelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLParagraphElement {
 }
 
 impl HTMLParagraphElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLParagraphElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLParagraphElement {
         HTMLParagraphElement {
             htmlelement: HTMLElement::new_inherited(HTMLParagraphElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLParagraphElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLParagraphElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlparamelement.rs b/src/components/script/dom/htmlparamelement.rs
index 80e1696fa4e..de3bc7873a1 100644
--- a/src/components/script/dom/htmlparamelement.rs
+++ b/src/components/script/dom/htmlparamelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLParamElement {
 }
 
 impl HTMLParamElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLParamElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLParamElement {
         HTMLParamElement {
             htmlelement: HTMLElement::new_inherited(HTMLParamElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLParamElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLParamElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlpreelement.rs b/src/components/script/dom/htmlpreelement.rs
index 2fb9752d096..271bd2a42c0 100644
--- a/src/components/script/dom/htmlpreelement.rs
+++ b/src/components/script/dom/htmlpreelement.rs
@@ -3,6 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::HTMLPreElementBinding;
+use dom::bindings::utils::DOMString;
 use dom::bindings::utils::{ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLPreElementTypeId;
@@ -14,13 +15,13 @@ pub struct HTMLPreElement {
 }
 
 impl HTMLPreElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLPreElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLPreElement {
         HTMLPreElement {
             htmlelement: HTMLElement::new_inherited(HTMLPreElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLPreElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLPreElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlprogresselement.rs b/src/components/script/dom/htmlprogresselement.rs
index b3f8f49a152..ed4fc3650e3 100644
--- a/src/components/script/dom/htmlprogresselement.rs
+++ b/src/components/script/dom/htmlprogresselement.rs
@@ -3,6 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::HTMLProgressElementBinding;
+use dom::bindings::utils::DOMString;
 use dom::bindings::utils::{ErrorResult, Fallible};
 use dom::document::AbstractDocument;
 use dom::element::HTMLProgressElementTypeId;
@@ -14,13 +15,13 @@ pub struct HTMLProgressElement {
 }
 
 impl HTMLProgressElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLProgressElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLProgressElement {
         HTMLProgressElement {
             htmlelement: HTMLElement::new_inherited(HTMLProgressElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLProgressElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLProgressElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlquoteelement.rs b/src/components/script/dom/htmlquoteelement.rs
index 82992c73006..02ce3881200 100644
--- a/src/components/script/dom/htmlquoteelement.rs
+++ b/src/components/script/dom/htmlquoteelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLQuoteElement {
 }
 
 impl HTMLQuoteElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLQuoteElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLQuoteElement {
         HTMLQuoteElement {
             htmlelement: HTMLElement::new_inherited(HTMLQuoteElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLQuoteElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLQuoteElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlscriptelement.rs b/src/components/script/dom/htmlscriptelement.rs
index 604fe714322..c5e74d90c66 100644
--- a/src/components/script/dom/htmlscriptelement.rs
+++ b/src/components/script/dom/htmlscriptelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLScriptElement {
 }
 
 impl HTMLScriptElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLScriptElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLScriptElement {
         HTMLScriptElement {
             htmlelement: HTMLElement::new_inherited(HTMLScriptElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLScriptElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLScriptElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlselectelement.rs b/src/components/script/dom/htmlselectelement.rs
index ffdee692bee..8e35109fb03 100644
--- a/src/components/script/dom/htmlselectelement.rs
+++ b/src/components/script/dom/htmlselectelement.rs
@@ -15,13 +15,13 @@ pub struct HTMLSelectElement {
 }
 
 impl HTMLSelectElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLSelectElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLSelectElement {
         HTMLSelectElement {
             htmlelement: HTMLElement::new_inherited(HTMLSelectElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLSelectElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLSelectElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlsourceelement.rs b/src/components/script/dom/htmlsourceelement.rs
index ba5701e7cc1..25ba0239ad9 100644
--- a/src/components/script/dom/htmlsourceelement.rs
+++ b/src/components/script/dom/htmlsourceelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLSourceElement {
 }
 
 impl HTMLSourceElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLSourceElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLSourceElement {
         HTMLSourceElement {
             htmlelement: HTMLElement::new_inherited(HTMLSourceElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLSourceElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLSourceElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlspanelement.rs b/src/components/script/dom/htmlspanelement.rs
index b63e5fc9626..d76faa79057 100644
--- a/src/components/script/dom/htmlspanelement.rs
+++ b/src/components/script/dom/htmlspanelement.rs
@@ -3,6 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::HTMLSpanElementBinding;
+use dom::bindings::utils::DOMString;
 use dom::document::AbstractDocument;
 use dom::element::HTMLSpanElementTypeId;
 use dom::htmlelement::HTMLElement;
@@ -13,13 +14,13 @@ pub struct HTMLSpanElement {
 }
 
 impl HTMLSpanElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLSpanElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLSpanElement {
         HTMLSpanElement {
             htmlelement: HTMLElement::new_inherited(HTMLSpanElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLSpanElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLSpanElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlstyleelement.rs b/src/components/script/dom/htmlstyleelement.rs
index b43d75d0321..0588d372168 100644
--- a/src/components/script/dom/htmlstyleelement.rs
+++ b/src/components/script/dom/htmlstyleelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLStyleElement {
 }
 
 impl HTMLStyleElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLStyleElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLStyleElement {
         HTMLStyleElement {
             htmlelement: HTMLElement::new_inherited(HTMLStyleElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLStyleElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLStyleElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmltablecaptionelement.rs b/src/components/script/dom/htmltablecaptionelement.rs
index 5f3c6edc2f7..47deb6cf5be 100644
--- a/src/components/script/dom/htmltablecaptionelement.rs
+++ b/src/components/script/dom/htmltablecaptionelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLTableCaptionElement {
 }
 
 impl HTMLTableCaptionElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLTableCaptionElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLTableCaptionElement {
         HTMLTableCaptionElement {
             htmlelement: HTMLElement::new_inherited(HTMLTableCaptionElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLTableCaptionElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLTableCaptionElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmltablecellelement.rs b/src/components/script/dom/htmltablecellelement.rs
index 2e448c7e8ec..206f0ed4cef 100644
--- a/src/components/script/dom/htmltablecellelement.rs
+++ b/src/components/script/dom/htmltablecellelement.rs
@@ -12,7 +12,7 @@ pub struct HTMLTableCellElement {
 }
 
 impl HTMLTableCellElement {
-    pub fn new_inherited(type_id: ElementTypeId, tag_name: ~str, document: AbstractDocument) -> HTMLTableCellElement {
+    pub fn new_inherited(type_id: ElementTypeId, tag_name: DOMString, document: AbstractDocument) -> HTMLTableCellElement {
         HTMLTableCellElement {
             htmlelement: HTMLElement::new_inherited(type_id, tag_name, document)
         }
diff --git a/src/components/script/dom/htmltablecolelement.rs b/src/components/script/dom/htmltablecolelement.rs
index c640c852140..80462070d28 100644
--- a/src/components/script/dom/htmltablecolelement.rs
+++ b/src/components/script/dom/htmltablecolelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLTableColElement {
 }
 
 impl HTMLTableColElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLTableColElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLTableColElement {
         HTMLTableColElement {
             htmlelement: HTMLElement::new_inherited(HTMLTableColElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLTableColElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLTableColElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmltabledatacellelement.rs b/src/components/script/dom/htmltabledatacellelement.rs
index 52ee1d24d64..d14b2279ce6 100644
--- a/src/components/script/dom/htmltabledatacellelement.rs
+++ b/src/components/script/dom/htmltabledatacellelement.rs
@@ -3,6 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::HTMLTableDataCellElementBinding;
+use dom::bindings::utils::DOMString;
 use dom::document::AbstractDocument;
 use dom::element::HTMLTableDataCellElementTypeId;
 use dom::htmltablecellelement::HTMLTableCellElement;
@@ -13,13 +14,13 @@ pub struct HTMLTableDataCellElement {
 }
 
 impl HTMLTableDataCellElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLTableDataCellElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLTableDataCellElement {
         HTMLTableDataCellElement {
             htmltablecellelement: HTMLTableCellElement::new_inherited(HTMLTableDataCellElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLTableDataCellElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLTableDataCellElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmltableelement.rs b/src/components/script/dom/htmltableelement.rs
index 9c5b639cf7b..26b6f89819a 100644
--- a/src/components/script/dom/htmltableelement.rs
+++ b/src/components/script/dom/htmltableelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLTableElement {
 }
 
 impl HTMLTableElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLTableElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLTableElement {
         HTMLTableElement {
             htmlelement: HTMLElement::new_inherited(HTMLTableElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLTableElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLTableElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmltableheadercellelement.rs b/src/components/script/dom/htmltableheadercellelement.rs
index 20cddcc9dc1..49f75d33ff4 100644
--- a/src/components/script/dom/htmltableheadercellelement.rs
+++ b/src/components/script/dom/htmltableheadercellelement.rs
@@ -3,6 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::HTMLTableHeaderCellElementBinding;
+use dom::bindings::utils::DOMString;
 use dom::document::AbstractDocument;
 use dom::element::HTMLTableHeaderCellElementTypeId;
 use dom::htmltablecellelement::HTMLTableCellElement;
@@ -13,13 +14,13 @@ pub struct HTMLTableHeaderCellElement {
 }
 
 impl HTMLTableHeaderCellElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLTableHeaderCellElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLTableHeaderCellElement {
         HTMLTableHeaderCellElement {
             htmltablecellelement: HTMLTableCellElement::new_inherited(HTMLTableHeaderCellElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLTableHeaderCellElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLTableHeaderCellElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmltablerowelement.rs b/src/components/script/dom/htmltablerowelement.rs
index 67ecfe7fd5c..8454cea09c4 100644
--- a/src/components/script/dom/htmltablerowelement.rs
+++ b/src/components/script/dom/htmltablerowelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLTableRowElement {
 }
 
 impl HTMLTableRowElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLTableRowElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLTableRowElement {
         HTMLTableRowElement {
             htmlelement: HTMLElement::new_inherited(HTMLTableRowElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLTableRowElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLTableRowElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmltablesectionelement.rs b/src/components/script/dom/htmltablesectionelement.rs
index 4d22c72a2e1..6f80dc04e9a 100644
--- a/src/components/script/dom/htmltablesectionelement.rs
+++ b/src/components/script/dom/htmltablesectionelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLTableSectionElement {
 }
 
 impl HTMLTableSectionElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLTableSectionElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLTableSectionElement {
         HTMLTableSectionElement {
             htmlelement: HTMLElement::new_inherited(HTMLTableSectionElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLTableSectionElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLTableSectionElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmltemplateelement.rs b/src/components/script/dom/htmltemplateelement.rs
index 389e1313631..6dd6434455a 100644
--- a/src/components/script/dom/htmltemplateelement.rs
+++ b/src/components/script/dom/htmltemplateelement.rs
@@ -3,6 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::HTMLTemplateElementBinding;
+use dom::bindings::utils::DOMString;
 use dom::document::AbstractDocument;
 use dom::element::HTMLTemplateElementTypeId;
 use dom::htmlelement::HTMLElement;
@@ -13,13 +14,13 @@ pub struct HTMLTemplateElement {
 }
 
 impl HTMLTemplateElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLTemplateElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLTemplateElement {
         HTMLTemplateElement {
             htmlelement: HTMLElement::new_inherited(HTMLTemplateElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLTemplateElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLTemplateElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmltextareaelement.rs b/src/components/script/dom/htmltextareaelement.rs
index 3fb59cce249..52e31d94029 100644
--- a/src/components/script/dom/htmltextareaelement.rs
+++ b/src/components/script/dom/htmltextareaelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLTextAreaElement {
 }
 
 impl HTMLTextAreaElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLTextAreaElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLTextAreaElement {
         HTMLTextAreaElement {
             htmlelement: HTMLElement::new_inherited(HTMLTextAreaElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLTextAreaElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLTextAreaElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmltimeelement.rs b/src/components/script/dom/htmltimeelement.rs
index 0aff5d026e4..3924ccde4ed 100644
--- a/src/components/script/dom/htmltimeelement.rs
+++ b/src/components/script/dom/htmltimeelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLTimeElement {
 }
 
 impl HTMLTimeElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLTimeElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLTimeElement {
         HTMLTimeElement {
             htmlelement: HTMLElement::new_inherited(HTMLTimeElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLTimeElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLTimeElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmltitleelement.rs b/src/components/script/dom/htmltitleelement.rs
index aa654e6086d..583d28db9cd 100644
--- a/src/components/script/dom/htmltitleelement.rs
+++ b/src/components/script/dom/htmltitleelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLTitleElement {
 }
 
 impl HTMLTitleElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLTitleElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLTitleElement {
         HTMLTitleElement {
             htmlelement: HTMLElement::new_inherited(HTMLTitleElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLTitleElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLTitleElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmltrackelement.rs b/src/components/script/dom/htmltrackelement.rs
index db42315564e..9d435930e50 100644
--- a/src/components/script/dom/htmltrackelement.rs
+++ b/src/components/script/dom/htmltrackelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLTrackElement {
 }
 
 impl HTMLTrackElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLTrackElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLTrackElement {
         HTMLTrackElement {
             htmlelement: HTMLElement::new_inherited(HTMLTrackElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLTrackElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLTrackElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlulistelement.rs b/src/components/script/dom/htmlulistelement.rs
index 16c4a44b6e2..d45d56a6d5c 100644
--- a/src/components/script/dom/htmlulistelement.rs
+++ b/src/components/script/dom/htmlulistelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLUListElement {
 }
 
 impl HTMLUListElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLUListElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLUListElement {
         HTMLUListElement {
             htmlelement: HTMLElement::new_inherited(HTMLUListElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLUListElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLUListElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlunknownelement.rs b/src/components/script/dom/htmlunknownelement.rs
index 1ff729cc39f..5988c14bf78 100644
--- a/src/components/script/dom/htmlunknownelement.rs
+++ b/src/components/script/dom/htmlunknownelement.rs
@@ -3,6 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::HTMLUnknownElementBinding;
+use dom::bindings::utils::DOMString;
 use dom::document::AbstractDocument;
 use dom::element::HTMLUnknownElementTypeId;
 use dom::htmlelement::HTMLElement;
@@ -13,13 +14,13 @@ pub struct HTMLUnknownElement {
 }
 
 impl HTMLUnknownElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLUnknownElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLUnknownElement {
         HTMLUnknownElement {
             htmlelement: HTMLElement::new_inherited(HTMLUnknownElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLUnknownElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLUnknownElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/htmlvideoelement.rs b/src/components/script/dom/htmlvideoelement.rs
index 38bb636d9d4..abb991ec3dd 100644
--- a/src/components/script/dom/htmlvideoelement.rs
+++ b/src/components/script/dom/htmlvideoelement.rs
@@ -14,13 +14,13 @@ pub struct HTMLVideoElement {
 }
 
 impl HTMLVideoElement {
-    pub fn new_inherited(localName: ~str, document: AbstractDocument) -> HTMLVideoElement {
+    pub fn new_inherited(localName: DOMString, document: AbstractDocument) -> HTMLVideoElement {
         HTMLVideoElement {
             htmlmediaelement: HTMLMediaElement::new_inherited(HTMLVideoElementTypeId, localName, document)
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(localName: DOMString, document: AbstractDocument) -> AbstractNode {
         let element = HTMLVideoElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLVideoElementBinding::Wrap)
     }
diff --git a/src/components/script/dom/text.rs b/src/components/script/dom/text.rs
index 2875d115245..7ea96245124 100644
--- a/src/components/script/dom/text.rs
+++ b/src/components/script/dom/text.rs
@@ -15,13 +15,13 @@ pub struct Text {
 }
 
 impl Text {
-    pub fn new_inherited(text: ~str, document: AbstractDocument) -> Text {
+    pub fn new_inherited(text: DOMString, document: AbstractDocument) -> Text {
         Text {
             element: CharacterData::new_inherited(TextNodeTypeId, text, document)
         }
     }
 
-    pub fn new(text: ~str, document: AbstractDocument) -> AbstractNode {
+    pub fn new(text: DOMString, document: AbstractDocument) -> AbstractNode {
         let node = Text::new_inherited(text, document);
         Node::reflect_node(@mut node, document, TextBinding::Wrap)
     }
diff --git a/src/components/script/html/hubbub_html_parser.rs b/src/components/script/html/hubbub_html_parser.rs
index db528ead019..9c1453b43f7 100644
--- a/src/components/script/html/hubbub_html_parser.rs
+++ b/src/components/script/html/hubbub_html_parser.rs
@@ -2,6 +2,7 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+use dom::bindings::utils::DOMString;
 use dom::document::AbstractDocument;
 use dom::element::{HTMLLinkElementTypeId, HTMLIframeElementTypeId, HTMLImageElementTypeId};
 use dom::htmlelement::HTMLElement;
@@ -159,7 +160,7 @@ fn js_script_listener(to_parent: SharedChan<HtmlDiscoveryMessage>,
 // Silly macros to handle constructing      DOM nodes. This produces bad code and should be optimized
 // via atomization (issue #85).
 
-pub fn build_element_from_tag(tag: ~str, document: AbstractDocument) -> AbstractNode {
+pub fn build_element_from_tag(tag: DOMString, document: AbstractDocument) -> AbstractNode {
     // TODO (Issue #85): use atoms
     handle_element!(document, tag, "a",         HTMLAnchorElement);
     handle_element!(document, tag, "applet",    HTMLAppletElement);