merge upstream

src/components/script/dom/bindings/codegen/Bindings.conf

@@ -154,7 +154,6 @@ DOMInterfaces = {
         'createComment',
         'createDocumentFragment',
         'createElement',
-        'createElementNS',
         'createTextNode',
         'title',
     ],
@@ -310,7 +309,6 @@ DOMInterfaces = {
         'appendChild',
         'nodeName',
         'nodeValue',
-        'namespaceURI',
         'removeChild',
         'textContent',
         'childNodes'

src/components/script/dom/bindings/codegen/Document.webidl

@@ -42,8 +42,8 @@ interface Document : Node {
 
   [Creator, Throws]
   Element createElement(DOMString localName);
-  [Creator, Throws]
-  Element createElementNS(DOMString? namespace, DOMString qualifiedName);
+  // [Creator, Throws]
+  // Element createElementNS(DOMString? namespace, DOMString qualifiedName);
   [Creator]
   DocumentFragment createDocumentFragment();
   [Creator]

src/components/script/dom/document.rs

@@ -3,21 +3,18 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::comment::Comment;
-use dom::bindings::codegen::ElementBinding;
 use dom::bindings::codegen::DocumentBinding;
 use dom::bindings::utils::{Reflectable, Reflector, Traceable, reflect_dom_object};
-use dom::bindings::utils::{ErrorResult, Fallible, NotSupported, InvalidCharacter, NamespaceError};
+use dom::bindings::utils::{ErrorResult, Fallible, NotSupported, InvalidCharacter};
 use dom::bindings::utils::DOMString;
-use dom::bindings::utils::{xml_name_type, InvalidXMLName, Name, QName};
+use dom::bindings::utils::{xml_name_type, InvalidXMLName};
 use dom::documentfragment::DocumentFragment;
 use dom::element::{Element};
-use dom::element::{HTMLHeadElementTypeId, HTMLTitleElementTypeId, nonHTMLTypeId};
+use dom::element::{HTMLHeadElementTypeId, HTMLTitleElementTypeId};
 use dom::event::{AbstractEvent, Event};
 use dom::htmlcollection::HTMLCollection;
 use dom::htmldocument::HTMLDocument;
 use dom::mouseevent::MouseEvent;
-use dom::namespace;
-use dom::namespace::Namespace;
 use dom::node::{AbstractNode, ScriptView, Node, ElementNodeTypeId, DocumentNodeTypeId};
 use dom::text::Text;
 use dom::uievent::UIEvent;
@@ -204,56 +201,6 @@ impl Document {
         Ok(build_element_from_tag(local_name, abstract_self))
     }
 
-    pub fn CreateElementNS(&self, abstract_self: AbstractDocument, namespace: Option<DOMString>, qualified_name: DOMString) -> Fallible<AbstractNode<ScriptView>> {
-        let ns: Namespace = Namespace::from_str(namespace);
-        let mut local_name;
-        match xml_name_type(qualified_name) {
-            InvalidXMLName => {
-                debug!("Not a valid element name");
-                return Err(InvalidCharacter);
-            },
-            Name => {
-                debug!("Not a valid qualified element name");
-                return Err(NamespaceError);
-            },
-            QName => {
-                let (prefix_from_qname, local_name_from_qname) = if qualified_name.contains(":")  {
-                    let parts: ~[&str] = qualified_name.splitn_iter(':', 1).collect();
-                    (Some(parts[0].to_owned()), parts[1].to_owned())
-                } else {
-                    (None, qualified_name.clone())
-                };
-                match (ns.clone(), prefix_from_qname, local_name_from_qname.clone()) {
-                    (namespace::Null, None, _) => {},
-                    (namespace::Null, _, _) => {
-                        debug!("Namespace can't be null with a non-null prefix");
-                        return Err(NamespaceError);
-                    },
-                    (namespace::XML, Some(~"xml"), _) => {},
-                    (namespace::XML, _, _) => {
-                        debug!("Namespace must be the xml namespace if the prefix is 'xml'");
-                        return Err(NamespaceError);
-                    },
-                    (namespace::XMLNS, Some(~"xmlns"), _) | (namespace::XMLNS, _, ~"xmlns") => {},
-                    (_, Some(~"xmlns"), _) | (_, _, ~"xmlns") => {
-                        debug!("Namespace must be the xmlns namespace if the prefix or the qualified name is 'xmlns'");
-                        return Err(NamespaceError);
-                    },
-                    _ => {}
-                }
-                local_name = local_name_from_qname;
-            }
-        }
-
-        if ns == namespace::HTML {
-            local_name = local_name.to_ascii_lower();
-            Ok(build_element_from_tag(local_name, abstract_self))
-        } else {
-            let element = Element::new(nonHTMLTypeId, local_name, ns, abstract_self);
-            Ok(Node::reflect_node(@mut element, abstract_self, ElementBinding::Wrap))
-        }
-    }
-
     pub fn CreateDocumentFragment(&self, abstract_self: AbstractDocument) -> AbstractNode<ScriptView> {
         DocumentFragment::new(abstract_self)
     }

src/components/script/dom/element.rs

@@ -117,8 +117,6 @@ pub enum ElementTypeId {
     HTMLUListElementTypeId,
     HTMLVideoElementTypeId,
     HTMLUnknownElementTypeId,
-
-    nonHTMLTypeId,
 }
 
 //

src/components/script/dom/node.rs

@@ -21,7 +21,7 @@ use dom::text::Text;
 
 use js::jsapi::{JSObject, JSContext};
 use servo_util::slot::{MutSlotRef, Slot, SlotRef};
-use servo_util::tree::{TreeNode, TreeNodeRef, TreeNodeRefAsElement, ElementLike};
+use servo_util::tree::{TreeNode, TreeNodeRef, TreeNodeRefAsElement};
 use std::cast::transmute;
 use std::cast;
 use std::unstable::raw::Box;
@@ -1177,19 +1177,8 @@ impl Node<ScriptView> {
         false
     }
 
-    pub fn GetNamespaceURI(&self, abstract_self: AbstractNode<ScriptView>) -> Option<DOMString> {
-        match self.type_id {
-            ElementNodeTypeId(*) => {
-                do abstract_self.with_imm_element_like |element| {
-                    Some(element.get_namespace())
-                }
-            }
-            CommentNodeTypeId |
-            TextNodeTypeId |
-            DocumentFragmentNodeTypeId |
-            DoctypeNodeTypeId |
-            DocumentNodeTypeId(_) => None
-        }
+    pub fn GetNamespaceURI(&self) -> Option<DOMString> {
+        None
     }
 
     pub fn GetPrefix(&self) -> Option<DOMString> {

src/test/ref/basic.list

@@ -13,4 +13,3 @@
 == last_of_type_pseudo_a.html last_of_type_pseudo_b.html
 == only_of_type_pseudo_a.html only_of_type_pseudo_b.html
 == visibility_hidden.html visibility_hidden_ref.html
-== dom_createelementns_a.html dom_createelementns_b.html