Run Mutation Observer and Custom Element callbacks consistently at microtask checkpoint

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 11 matching lines @@
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
-
 #include "core/dom/CustomElementRegistry.h"
 
 #include "HTMLNames.h"
 #include "SVGNames.h"
 #include "bindings/v8/CustomElementConstructorBuilder.h"
-#include "bindings/v8/CustomElementHelpers.h"
+#include "core/dom/CustomElementCallbackDispatcher.h"
 #include "core/dom/CustomElementDefinition.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/html/HTMLElement.h"
 #include "core/svg/SVGElement.h"
 
 namespace WebCore {
 
-CustomElementInvocation::CustomElementInvocation(PassRefPtr<CustomElementCallback> callback, PassRefPtr<Element> element)
-    : m_callback(callback)
-    , m_element(element)
-{
-}
-
-CustomElementInvocation::~CustomElementInvocation()
-{
-}
-
 void setTypeExtension(Element* element, const AtomicString& typeExtension)
 {
     ASSERT(element);
     if (!typeExtension.isEmpty())
         element->setAttribute(HTMLNames::isAttr, typeExtension);
 }
 
 CustomElementRegistry::CustomElementRegistry(Document* document)
     : ContextLifecycleObserver(document)
 {
 }
 
-CustomElementRegistry::~CustomElementRegistry()
-{
-    deactivate();
-}
-
 static inline bool nameIncludesHyphen(const AtomicString& name)
 {
     size_t hyphenPosition = name.find('-');
     return (hyphenPosition != notFound);
 }
 
 bool CustomElementRegistry::isValidName(const AtomicString& name)
 {
     if (!nameIncludesHyphen(name))
         return false;
@@ skipping 63 matching lines @@
 
     m_definitions.add(definition->type(), definition);
 
     // Upgrade elements that were waiting for this definition.
     CustomElementUpgradeCandidateMap::ElementSet upgradeCandidates = m_candidates.takeUpgradeCandidatesFor(definition.get());
     constructorBuilder->didRegisterDefinition(definition.get(), upgradeCandidates);
 
     for (CustomElementUpgradeCandidateMap::ElementSet::iterator it = upgradeCandidates.begin(); it != upgradeCandidates.end(); ++it) {
         (*it)->setNeedsStyleRecalc(); // :unresolved has changed
 
-        enqueueReadyCallback(lifecycleCallbacks.get(), *it);
+        CustomElementCallbackDispatcher::instance().enqueueReadyCallback(lifecycleCallbacks.get(), *it);
     }
 }
 
 bool CustomElementRegistry::isUnresolved(Element* element) const
 {
     return m_candidates.contains(element);
 }
 
 PassRefPtr<CustomElementDefinition> CustomElementRegistry::findFor(Element* element) const
 {
@@ skipping 64 matching lines @@
 {
     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(CustomElementDefinition::TypeExtension, type, element);
     } else {
-        enqueueReadyCallback(definition->callback(), element);
+        CustomElementCallbackDispatcher::instance().enqueueReadyCallback(definition->callback(), element);
     }
 }
 
 void CustomElementRegistry::didCreateCustomTagElement(CustomElementDefinition* definition, Element* element)
 {
-    enqueueReadyCallback(definition->callback(), element);
+    CustomElementCallbackDispatcher::instance().enqueueReadyCallback(definition->callback(), element);
 }
 
 void CustomElementRegistry::didCreateUnresolvedElement(CustomElementDefinition::CustomElementKind kind, const AtomicString& type, Element* element)
 {
     m_candidates.add(kind, type, element);
 }
 
 void CustomElementRegistry::customElementWasDestroyed(Element* element)
 {
     ASSERT(element->isCustomElement());
     m_candidates.remove(element);
 }
 
-void CustomElementRegistry::enqueueReadyCallback(CustomElementCallback* callback, Element* element)
-{
-    if (!callback->hasReady())
-        return;
-
-    bool wasInactive = m_invocations.isEmpty();
-    m_invocations.append(CustomElementInvocation(callback, element));
-    if (wasInactive)
-        activeCustomElementRegistries().add(this);
-}
-
-void CustomElementRegistry::deactivate()
-{
-    ASSERT(m_invocations.isEmpty());
-    if (activeCustomElementRegistries().contains(this))
-        activeCustomElementRegistries().remove(this);
-}
-
 inline Document* CustomElementRegistry::document() const
 {
     return toDocument(m_scriptExecutionContext);
 }
 
-void CustomElementRegistry::deliverLifecycleCallbacks()
-{
-    ASSERT(!m_invocations.isEmpty());
-
-    if (!m_invocations.isEmpty()) {
-        Vector<CustomElementInvocation> invocations;
-        m_invocations.swap(invocations);
-
-        for (Vector<CustomElementInvocation>::iterator it = invocations.begin(); it != invocations.end(); ++it)
-            it->callback()->ready(it->element());
-    }
-
-    ASSERT(m_invocations.isEmpty());
-    deactivate();
 }
-
-void CustomElementRegistry::deliverAllLifecycleCallbacks()
-{
-    while (!activeCustomElementRegistries().isEmpty()) {
-        Vector<RefPtr<CustomElementRegistry> > registries;
-        copyToVector(activeCustomElementRegistries(), registries);
-        activeCustomElementRegistries().clear();
-        for (size_t i = 0; i < registries.size(); ++i)
-            registries[i]->deliverLifecycleCallbacks();
-    }
-}
-
-}