4 files changed, 140 insertions, 10 deletions

diff --git a/components/script/dom/create.rs b/components/script/dom/create.rs
index b96406b60ed..52410a487b8 100644
--- a/components/script/dom/create.rs
+++ b/components/script/dom/create.rs
@@ -2,10 +2,13 @@
  * 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::error::{report_pending_exception, throw_dom_exception};
 use dom::bindings::js::Root;
+use dom::bindings::reflector::DomObject;
 use dom::document::Document;
 use dom::element::Element;
 use dom::element::ElementCreator;
+use dom::globalscope::GlobalScope;
 use dom::htmlanchorelement::HTMLAnchorElement;
 use dom::htmlappletelement::HTMLAppletElement;
 use dom::htmlareaelement::HTMLAreaElement;
@@ -77,6 +80,7 @@ use dom::htmlunknownelement::HTMLUnknownElement;
 use dom::htmlvideoelement::HTMLVideoElement;
 use dom::svgsvgelement::SVGSVGElement;
 use html5ever::{QualName, Prefix};
+use js::jsapi::JSAutoCompartment;
 use servo_config::prefs::PREFS;
 
 fn create_svg_element(name: QualName,
@@ -106,11 +110,42 @@ fn create_svg_element(name: QualName,
     }
 }
 
+// https://dom.spec.whatwg.org/#concept-create-element
+#[allow(unsafe_code)]
 fn create_html_element(name: QualName,
                        prefix: Option<Prefix>,
                        document: &Document,
                        creator: ElementCreator)
                        -> Root<Element> {
+    assert!(name.ns == ns!(html));
+
+    // Step 4
+    let definition = document.lookup_custom_element_definition(name.local.clone(), None);
+
+    if let Some(definition) = definition {
+        // TODO: Handle customized built-in elements. Relies on CE upgrades.
+        if definition.is_autonomous() {
+            let local_name = name.local.clone();
+            return match definition.create_element(document) {
+                Ok(element) => element,
+                Err(error) => {
+                    // Step 6. Recovering from exception.
+                    let global = GlobalScope::current().unwrap_or_else(|| document.global());
+
+                    // Step 6.1.1
+                    unsafe {
+                        let _ac = JSAutoCompartment::new(global.get_cx(), global.reflector().get_jsobject().get());
+                        throw_dom_exception(global.get_cx(), &global, error);
+                        report_pending_exception(global.get_cx(), true);
+                    }
+
+                    // Step 6.1.2
+                    Root::upcast(HTMLUnknownElement::new(local_name, prefix, document))
+                },
+            };
+        }
+    }
+
     create_native_html_element(name, prefix, document, creator)
 }
 
diff --git a/components/script/dom/customelementregistry.rs b/components/script/dom/customelementregistry.rs
index ee584a8bae1..3b151a8f764 100644
--- a/components/script/dom/customelementregistry.rs
+++ b/components/script/dom/customelementregistry.rs
@@ -7,23 +7,31 @@ use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::CustomElementRegistryBinding;
 use dom::bindings::codegen::Bindings::CustomElementRegistryBinding::CustomElementRegistryMethods;
 use dom::bindings::codegen::Bindings::CustomElementRegistryBinding::ElementDefinitionOptions;
+use dom::bindings::codegen::Bindings::ElementBinding::ElementMethods;
 use dom::bindings::codegen::Bindings::FunctionBinding::Function;
-use dom::bindings::error::{Error, ErrorResult};
+use dom::bindings::conversions::{ConversionResult, FromJSValConvertible};
+use dom::bindings::error::{Error, ErrorResult, Fallible};
 use dom::bindings::inheritance::Castable;
 use dom::bindings::js::{JS, Root};
 use dom::bindings::reflector::{DomObject, Reflector, reflect_dom_object};
 use dom::bindings::str::DOMString;
+use dom::document::Document;
 use dom::domexception::{DOMErrorName, DOMException};
+use dom::element::Element;
 use dom::globalscope::GlobalScope;
+use dom::htmlelement::HTMLElement;
+use dom::node::Node;
 use dom::promise::Promise;
 use dom::window::Window;
 use dom_struct::dom_struct;
 use html5ever::LocalName;
 use js::conversions::ToJSValConvertible;
-use js::jsapi::{IsConstructor, HandleObject, JS_GetProperty, JSAutoCompartment, JSContext};
-use js::jsval::{JSVal, UndefinedValue};
+use js::jsapi::{Construct1, IsConstructor, HandleValueArray, HandleObject};
+use js::jsapi::{JS_GetProperty, JSAutoCompartment, JSContext};
+use js::jsval::{JSVal, ObjectValue, UndefinedValue};
 use std::cell::Cell;
 use std::collections::HashMap;
+use std::ptr;
 use std::rc::Rc;
 
 /// https://html.spec.whatwg.org/multipage/#customelementregistry
@@ -34,12 +42,12 @@ pub struct CustomElementRegistry {
     window: JS<Window>,
 
     #[ignore_heap_size_of = "Rc"]
-    when_defined: DOMRefCell<HashMap<DOMString, Rc<Promise>>>,
+    when_defined: DOMRefCell<HashMap<LocalName, Rc<Promise>>>,
 
     element_definition_is_running: Cell<bool>,
 
     #[ignore_heap_size_of = "Rc"]
-    definitions: DOMRefCell<HashMap<DOMString, Rc<CustomElementDefinition>>>,
+    definitions: DOMRefCell<HashMap<LocalName, Rc<CustomElementDefinition>>>,
 }
 
 impl CustomElementRegistry {
@@ -65,6 +73,18 @@ impl CustomElementRegistry {
         self.when_defined.borrow_mut().clear()
     }
 
+    /// https://html.spec.whatwg.org/multipage/#look-up-a-custom-element-definition
+    pub fn lookup_definition(&self,
+                             local_name: LocalName,
+                             is: Option<LocalName>)
+                             -> Option<Rc<CustomElementDefinition>> {
+        self.definitions.borrow().values().find(|definition| {
+            // Step 4-5
+            definition.local_name == local_name &&
+                (definition.name == local_name || Some(&definition.name) == is.as_ref())
+        }).cloned()
+    }
+
     pub fn lookup_definition_by_constructor(&self, constructor: HandleObject) -> Option<Rc<CustomElementDefinition>> {
         self.definitions.borrow().values().find(|definition| {
             definition.constructor.callback() == constructor.get()
@@ -101,6 +121,7 @@ impl CustomElementRegistryMethods for CustomElementRegistry {
     fn Define(&self, name: DOMString, constructor_: Rc<Function>, options: &ElementDefinitionOptions) -> ErrorResult {
         let global_scope = self.window.upcast::<GlobalScope>();
         rooted!(in(global_scope.get_cx()) let constructor = constructor_.callback());
+        let name = LocalName::from(&*name);
 
         // Step 1
         if unsafe { !IsConstructor(constructor.get()) } {
@@ -137,10 +158,10 @@ impl CustomElementRegistryMethods for CustomElementRegistry {
                 return Err(Error::NotSupported)
             }
 
-            extended_name
+            LocalName::from(&**extended_name)
         } else {
             // Step 7.3
-            &name
+            name.clone()
         };
 
         // Step 8
@@ -165,8 +186,8 @@ impl CustomElementRegistryMethods for CustomElementRegistry {
         result?;
 
         // Step 11
-        let definition = CustomElementDefinition::new(LocalName::from(&*name),
-                                                      LocalName::from(&**local_name),
+        let definition = CustomElementDefinition::new(name.clone(),
+                                                      local_name,
                                                       constructor_);
 
         // Step 12
@@ -188,7 +209,7 @@ impl CustomElementRegistryMethods for CustomElementRegistry {
     /// https://html.spec.whatwg.org/multipage/#dom-customelementregistry-get
     #[allow(unsafe_code)]
     unsafe fn Get(&self, cx: *mut JSContext, name: DOMString) -> JSVal {
-        match self.definitions.borrow().get(&name) {
+        match self.definitions.borrow().get(&LocalName::from(&*name)) {
             Some(definition) => {
                 rooted!(in(cx) let mut constructor = UndefinedValue());
                 definition.constructor.to_jsval(cx, constructor.handle_mut());
@@ -202,6 +223,7 @@ impl CustomElementRegistryMethods for CustomElementRegistry {
     #[allow(unrooted_must_root)]
     fn WhenDefined(&self, name: DOMString) -> Rc<Promise> {
         let global_scope = self.window.upcast::<GlobalScope>();
+        let name = LocalName::from(&*name);
 
         // Step 1
         if !is_valid_custom_element_name(&name) {
@@ -256,6 +278,53 @@ impl CustomElementDefinition {
     pub fn is_autonomous(&self) -> bool {
         self.name == self.local_name
     }
+
+    /// https://dom.spec.whatwg.org/#concept-create-element Step 6.1
+    #[allow(unsafe_code)]
+    pub fn create_element(&self, document: &Document) -> Fallible<Root<Element>> {
+        let window = document.window();
+        let cx = window.get_cx();
+        // Step 2
+        rooted!(in(cx) let constructor = ObjectValue(self.constructor.callback()));
+        rooted!(in(cx) let mut element = ptr::null_mut());
+        {
+            // Go into the constructor's compartment
+            let _ac = JSAutoCompartment::new(cx, self.constructor.callback());
+            let args = HandleValueArray::new();
+            if unsafe { !Construct1(cx, constructor.handle(), &args, element.handle_mut()) } {
+                return Err(Error::JSFailed);
+            }
+        }
+
+        rooted!(in(cx) let element_val = ObjectValue(element.get()));
+        let element: Root<Element> = match unsafe { Root::from_jsval(cx, element_val.handle(), ()) } {
+            Ok(ConversionResult::Success(element)) => element,
+            Ok(ConversionResult::Failure(..)) =>
+                return Err(Error::Type("Constructor did not return a DOM node".to_owned())),
+            _ => return Err(Error::JSFailed),
+        };
+
+        // Step 3
+        if !element.is::<HTMLElement>() {
+            return Err(Error::Type("Constructor did not return a DOM node".to_owned()));
+        }
+
+        // Steps 4-9
+        if element.HasAttributes() ||
+            element.upcast::<Node>().children_count() > 0 ||
+            element.upcast::<Node>().has_parent() ||
+            &*element.upcast::<Node>().owner_doc() != document ||
+            *element.namespace() != ns!(html) ||
+            *element.local_name() != self.local_name
+        {
+            return Err(Error::NotSupported);
+        }
+
+        // Step 11
+        // Element's `is` is None by default
+
+        Ok(element)
+    }
 }
 
 /// https://html.spec.whatwg.org/multipage/#valid-custom-element-name
diff --git a/components/script/dom/document.rs b/components/script/dom/document.rs
index c97d352872c..a61421e7866 100644
--- a/components/script/dom/document.rs
+++ b/components/script/dom/document.rs
@@ -36,6 +36,7 @@ use dom::bindings::xmlname::{namespace_from_domstring, validate_and_extract, xml
 use dom::bindings::xmlname::XMLName::InvalidXMLName;
 use dom::closeevent::CloseEvent;
 use dom::comment::Comment;
+use dom::customelementregistry::CustomElementDefinition;
 use dom::customevent::CustomEvent;
 use dom::documentfragment::DocumentFragment;
 use dom::documenttype::DocumentType;
@@ -1996,6 +1997,26 @@ impl Document {
 
         self.window.layout().nodes_from_point_response()
     }
+
+    /// https://html.spec.whatwg.org/multipage/#look-up-a-custom-element-definition
+    pub fn lookup_custom_element_definition(&self,
+                                            local_name: LocalName,
+                                            is: Option<LocalName>)
+                                            -> Option<Rc<CustomElementDefinition>> {
+        if !PREFS.get("dom.customelements.enabled").as_boolean().unwrap_or(false) {
+            return None;
+        }
+
+        // Step 2
+        if !self.has_browsing_context {
+            return None;
+        }
+
+        // Step 3
+        let registry = self.window.CustomElements();
+
+        registry.lookup_definition(local_name, is)
+    }
 }
 
 #[derive(PartialEq, HeapSizeOf)]
diff --git a/components/script/dom/node.rs b/components/script/dom/node.rs
index cace0497433..f09001625d0 100644
--- a/components/script/dom/node.rs
+++ b/components/script/dom/node.rs
@@ -428,6 +428,11 @@ impl Node {
         self.preceding_siblings().count() as u32
     }
 
+    /// Returns true if this node has a parent.
+    pub fn has_parent(&self) -> bool {
+        self.parent_node.get().is_some()
+    }
+
     pub fn children_count(&self) -> u32 {
         self.children_count.get()
     }