Implement the Custom Elements :unresolved pseudoclass

Source/core/dom/CustomElementRegistry.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 152 matching lines @@
     if (!CustomElementHelpers::initializeConstructorWrapper(constructor.get(), prototypeValue, state)) {
         ec = INVALID_STATE_ERR;
         return 0;
     }
 
     m_definitions.add(definition->type(), definition);
 
     return constructor.release();
 }
 
+bool CustomElementRegistry::isUnresolved(Element* element) const
+{
+    return m_unresolvedElements.contains(element);
+}
+
 PassRefPtr<CustomElementDefinition> CustomElementRegistry::findFor(Element* element) const
 {
     ASSERT(element->document()->registry() == this);
 
     if (!element->isCustomElement())
         return 0;
 
     // When a custom tag and a type extension are provided as element
     // names at the same time, the custom tag takes precedence.
     if (isCustomTagName(element->localName())) {
@@ skipping 36 matching lines @@
 #if ENABLE(SVG)
     else if (SVGNames::svgNamespaceURI == tagName.namespaceURI())
         element = SVGElement::create(tagName, document());
 #endif
     else
         element = Element::create(tagName, document());
 
     element->setIsCustomElement();
 
     RefPtr<CustomElementDefinition> definition = findAndCheckNamespace(tagName.localName(), tagName.namespaceURI());
-    if (definition && !definition->isTypeExtension())
+    if (!definition || definition->isTypeExtension()) {
+        // If a definition for a type extension was available, this
+        // custom tag element will be unresolved in perpetuity.
+        didCreateUnresolvedElement(element.get());
+    } else {
         didCreateCustomTagElement(element.get());
+    }
 
     return element.release();
 }
 
 void CustomElementRegistry::didGiveTypeExtension(Element* element)
 {
     element->setIsCustomElement();
     RefPtr<CustomElementDefinition> definition = findFor(element);
-    if (!definition || !definition->isTypeExtension())
-        return;
-    activate(CustomElementInvocation(element));
+    if (!definition || !definition->isTypeExtension()) {
+        // If a definition for a custom tag was available, this type
+        // extension element will be unresolved in perpetuity.
+        didCreateUnresolvedElement(element);
+    } else {
+        activate(CustomElementInvocation(element));
+    }
 }
 
 void CustomElementRegistry::didCreateCustomTagElement(Element* element)
 {
     activate(CustomElementInvocation(element));
 }
 
+void CustomElementRegistry::didCreateUnresolvedElement(Element* element)
+{
+    m_unresolvedElements.add(element);
+}
+
+void CustomElementRegistry::customElementWasDestroyed(Element* element)
+{
+    ASSERT(element->isCustomElement());
+    m_unresolvedElements.remove(element);
+}
+
 void CustomElementRegistry::activate(const CustomElementInvocation& invocation)
 {
     bool wasInactive = m_invocations.isEmpty();
     m_invocations.append(invocation);
     if (wasInactive)
         activeCustomElementRegistries().add(this);
 }
 
 void CustomElementRegistry::deactivate()
 {
@@ skipping 26 matching lines @@
     while (!activeCustomElementRegistries().isEmpty()) {
         Vector<RefPtr<CustomElementRegistry> > registries;
         copyToVector(activeCustomElementRegistries(), registries);
         activeCustomElementRegistries().clear();
         for (size_t i = 0; i < registries.size(); ++i)
             registries[i]->deliverLifecycleCallbacks();
     }
 }
 
 }