Let unresolved custom element go through CustomElementCallbackQueue.

Source/core/dom/custom/CustomElementRegistrationContext.cpp

 /*

[dominicc (has gone to gerrit), 2013/12/13 05:11:16]

I think this isn't quite right. resolvePoppedElement/define will push creation
callbacks. But they might be in the wrong order now.

The naming could be better too... popped isn't quite right; it's a queue.

And didFailResolution happens a LOT later then being marked as "unresolved." But
it would be an easy mistake to think the unresolved state is only downstream of
didFailResolution.

Why do we even need two attempts at resolution? We could just always enqueue a
resolve step I think. That might be simpler.

so createCustomTagElement, didGiveTypeExtension just tell the scheduler to
enqueue a resolve step. Their job is to build the CustomElementDescriptor and
pass it with the element to the resolve step.

The resolve step looks for the definition. If one is available, it does upgrade
immediately. If not, it enters the element in the upgrade candidates map.

We can probably shift resolve, didResolveElement, didCreateUnresolvedElement
into the resolution step class. And rename didCreateUnresolvedElement to
didSomethingUpgradeCandidate.

The code for actual upgrade steps needs to be shared between the resolve step,
and the post-hoc upgrade candidate upgrade step.

[Hajime Morrita, 2013/12/13 07:02:29]

OK, I cut the first resolution and let it done after scheduling.
I also folded some functions inline.
Looks much simpler now.

  * Copyright (C) 2013 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
  *    notice, this list of conditions and the following disclaimer
@@ skipping 55 matching lines @@
     if (HTMLNames::xhtmlNamespaceURI == tagName.namespaceURI()) {
         element = HTMLElement::create(tagName, document);
     } else if (SVGNames::svgNamespaceURI == tagName.namespaceURI()) {
         element = SVGUnknownElement::create(tagName, document);
     } else {
         // XML elements are not custom elements, so return early.
         return Element::create(tagName, &document);
     }
 
     element->setCustomElementState(Element::WaitingForUpgrade);
-    resolve(element.get(), nullAtom);
+    resolveNewElement(element.get(), nullAtom);
     return element.release();
 }
 
 void CustomElementRegistrationContext::didGiveTypeExtension(Element* element, const AtomicString& type)
 {
-    resolve(element, type);
+    resolveNewElement(element, type);
 }
 
-void CustomElementRegistrationContext::resolve(Element* element, const AtomicString& typeExtension)
+void CustomElementRegistrationContext::resolveNewElement(Element* element, const AtomicString& typeExtension)
 {
     // If an element has a custom tag name it takes precedence over
     // the "is" attribute (if any).
     const AtomicString& type = CustomElement::isValidName(element->localName())
         ? element->localName()
         : typeExtension;
     ASSERT(!type.isNull());
 
     CustomElementDescriptor descriptor(type, element->namespaceURI(), element->localName());
     CustomElementDefinition* definition = m_registry.find(descriptor);
     if (definition)
         didResolveElement(definition, element);
     else
         didCreateUnresolvedElement(descriptor, element);
 }
 
+void CustomElementRegistrationContext::resolvePoppedElement(Element* element, const CustomElementDescriptor& descriptor)
+{
+    CustomElementDefinition* definition = m_registry.find(descriptor);
+    if (definition)
+        didResolveElement(definition, element);
+    else
+        didFailResolution(descriptor, element);
+}
+
 void CustomElementRegistrationContext::didResolveElement(CustomElementDefinition* definition, Element* element)
 {
     CustomElement::define(element, definition);
 }
 
 void CustomElementRegistrationContext::didCreateUnresolvedElement(const CustomElementDescriptor& descriptor, Element* element)
 {
     ASSERT(element->customElementState() == Element::WaitingForUpgrade);
+    CustomElementCallbackScheduler::scheduleResolutionCallback(descriptor, element);
+}
+
+void CustomElementRegistrationContext::didFailResolution(const CustomElementDescriptor& descriptor, Element* element)
+{
+    ASSERT(element->customElementState() == Element::WaitingForUpgrade);
     m_candidates.add(descriptor, element);
 }
 
 PassRefPtr<CustomElementRegistrationContext> CustomElementRegistrationContext::create()
 {
     return adoptRef(new CustomElementRegistrationContext());
 }
 
 void CustomElementRegistrationContext::setIsAttributeAndTypeExtension(Element* element, const AtomicString& type)
 {
@@ skipping 20 matching lines @@
     // Custom tags take precedence over type extensions
     ASSERT(!CustomElement::isValidName(element->localName()));
 
     element->setCustomElementState(Element::WaitingForUpgrade);
 
     if (CustomElementRegistrationContext* context = element->document().registrationContext())
         context->didGiveTypeExtension(element, type);
 }
 
 } // namespace WebCore