Upgrade elements that are created before a custom element definition is registered

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 23 matching lines @@
 
 #include "HTMLNames.h"
 #include "RuntimeEnabledFeatures.h"
 #include "bindings/v8/CustomElementHelpers.h"
 #include "bindings/v8/Dictionary.h"
 #include "bindings/v8/ScriptValue.h"
 #include "core/dom/CustomElementDefinition.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/html/HTMLElement.h"
-#include <wtf/HashSet.h>
 
 #if ENABLE(SVG)
 #include "SVGNames.h"
 #include "core/svg/SVGElement.h"
 #endif
 
 namespace WebCore {
 
 CustomElementInvocation::CustomElementInvocation(PassRefPtr<Element> element)
     : m_element(element)
@@ skipping 105 matching lines @@
     RefPtr<CustomElementDefinition> definition = CustomElementDefinition::create(state, type, name, namespaceURI, prototypeValue);
 
     RefPtr<CustomElementConstructor> constructor = CustomElementConstructor::create(document(), definition->tagQName(), definition->isTypeExtension() ? definition->type() : nullAtom);
     if (!CustomElementHelpers::initializeConstructorWrapper(constructor.get(), prototypeValue, state)) {
         ec = INVALID_STATE_ERR;
         return 0;
     }
 
     m_definitions.add(definition->type(), definition);
 
+    // Upgrade elements that were waiting for this definition.
+    CustomElementUpgradeCandidateMap::ElementSet upgradeCandidates = m_candidates.takeUpgradeCandidatesFor(definition.get());
+    CustomElementHelpers::upgradeWrappers(document(), upgradeCandidates, definition->prototype());
+    for (CustomElementUpgradeCandidateMap::ElementSet::iterator it = upgradeCandidates.begin(); it != upgradeCandidates.end(); ++it) {
+        (*it)->setNeedsStyleRecalc(); // :unresolved has changed
+        activate(CustomElementInvocation(*it));
+    }
+
     return constructor.release();
 }
 
 bool CustomElementRegistry::isUnresolved(Element* element) const
 {
-    return m_unresolvedElements.contains(element);
+    return m_candidates.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
@@ skipping 41 matching lines @@
 #endif
     else
         return Element::create(tagName, document());
 
     element->setIsCustomElement();
 
     RefPtr<CustomElementDefinition> definition = findAndCheckNamespace(tagName.localName(), tagName.namespaceURI());
     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());
+        didCreateUnresolvedElement(CustomElementDefinition::CustomTag, tagName.localName(), element.get());
     } else {
         didCreateCustomTagElement(element.get());
     }
 
     return element.release();
 }
 
-void CustomElementRegistry::didGiveTypeExtension(Element* element)
+void CustomElementRegistry::didGiveTypeExtension(Element* element, const AtomicString& type)
 {
     if (!element->isHTMLElement() && !element->isSVGElement())
         return;
     element->setIsCustomElement();
     RefPtr<CustomElementDefinition> definition = findFor(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);
+        didCreateUnresolvedElement(CustomElementDefinition::TypeExtension, type, element);
     } else {
         activate(CustomElementInvocation(element));
     }
 }
 
 void CustomElementRegistry::didCreateCustomTagElement(Element* element)
 {
     activate(CustomElementInvocation(element));
 }
 
-void CustomElementRegistry::didCreateUnresolvedElement(Element* element)
+void CustomElementRegistry::didCreateUnresolvedElement(CustomElementDefinition::CustomElementKind kind, const AtomicString& type, Element* element)
 {
-    m_unresolvedElements.add(element);
+    m_candidates.add(kind, type, element);
 }
 
 void CustomElementRegistry::customElementWasDestroyed(Element* element)
 {
     ASSERT(element->isCustomElement());
-    m_unresolvedElements.remove(element);
+    m_candidates.remove(element);
 }
 
 void CustomElementRegistry::activate(const CustomElementInvocation& invocation)
 {
     bool wasInactive = m_invocations.isEmpty();
     m_invocations.append(invocation);
     if (wasInactive)
         activeCustomElementRegistries().add(this);
 }
 
@@ skipping 28 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();
     }
 }
 
 }