Title: [207810] trunk
Revision
207810
Author
[email protected]
Date
2016-10-24 23:18:13 -0700 (Mon, 24 Oct 2016)

Log Message

Custom elements reactions should have a queue per element
https://bugs.webkit.org/show_bug.cgi?id=163878

Reviewed by Antti Koivisto.

Source/WebCore:

This patch splits the custom elements reaction queue into per element to match the latest HTML specifications:
https://html.spec.whatwg.org/multipage/scripting.html#custom-element-reaction-queue
and introduces the backup element queue:
https://html.spec.whatwg.org/multipage/scripting.html#backup-element-queue

In terms of code changes, CustomElementReactionStack now holds onto ElementQueue, an ordered list of elements,
and make each ElementRareData keep its own CustomElementReactionQueue. CustomElementReactionQueue is created
for each custom element when it is synchronously constructed or enqueued to upgrade.

Because each reaction queue is now specific to each element, CustomElementReactionQueue instead of
CustomElementReactionQueueItem stores JSCustomElementInterface.

The backup element queue is created as a singleton returned by CustomElementReactionStack's backupElementQueue,
and ensureBackupQueue() schedules a new mirotask to process the backup queue when there isn't already one.

ensureCurrentQueue() now returns a reference to CustomElementReactionQueue instead of a pointer since it can
fallback to the backup queue when the stack is empty as specified:
https://html.spec.whatwg.org/multipage/scripting.html#enqueue-an-element-on-the-appropriate-element-queue

Note that ensureCurrentQueue() may insert the same element multiple times into the element queue for now since
avoiding this duplication would require either doing O(n) iteration on m_elements or adding a HashSet.
We can revisit this in the future if the reaction queue is found to grow beyond a few entries since elements in
the element queue will have duplicates only when each reaction queue has more than one item.

Tests: fast/custom-elements/backup-element-queue.html
       fast/custom-elements/custom-element-reaction-queue.html

* bindings/js/JSCustomElementInterface.cpp:
(WebCore::JSCustomElementInterface::upgradeElement):
* dom/CustomElementReactionQueue.cpp:
(WebCore::CustomElementReactionQueueItem::CustomElementReactionQueueItem):
(WebCore::CustomElementReactionQueueItem::invoke): Removed the check for isFailedCustomElement since the queue
is explicitly cleared in Element::setIsFailedCustomElement.
(WebCore::CustomElementReactionQueue::CustomElementReactionQueue): Now takes JSCustomElementInterface since
each item in the queue no longer stores Element or JSCustomElementInterface.
(WebCore::CustomElementReactionQueue::clear):
(WebCore::CustomElementReactionQueue::enqueueElementUpgrade):
(WebCore::CustomElementReactionQueue::enqueueElementUpgradeIfDefined):
(WebCore::CustomElementReactionQueue::enqueueConnectedCallbackIfNeeded):
(WebCore::CustomElementReactionQueue::enqueueDisconnectedCallbackIfNeeded):
(WebCore::CustomElementReactionQueue::enqueueAdoptedCallbackIfNeeded):
(WebCore::CustomElementReactionQueue::enqueueAttributeChangedCallbackIfNeeded):
(WebCore::CustomElementReactionQueue::enqueuePostUpgradeReactions):
(WebCore::CustomElementReactionQueue::invokeAll):
(WebCore::CustomElementReactionStack::ElementQueue::add): Added.
(WebCore::CustomElementReactionStack::ElementQueue::invokeAll): Added.
(WebCore::CustomElementReactionStack::ensureCurrentQueue):
(WebCore::BackupElementQueueMicrotask): Added.
(WebCore::CustomElementReactionStack::ensureBackupQueue): Added.
(WebCore::CustomElementReactionStack::processBackupQueue): Added.
(WebCore::CustomElementReactionStack::backupElementQueue): Added.
* dom/CustomElementReactionQueue.h:
* dom/CustomElementRegistry.cpp:
(WebCore::enqueueUpgradeInShadowIncludingTreeOrder):
* dom/Document.cpp:
(WebCore::createFallbackHTMLElement):
* dom/Element.cpp:
(WebCore::Element::setIsDefinedCustomElement): Create a new reaction queue if there isn't already one; when
this element had been upgraded, the reaction queue have already been created in Element::enqueueToUpgrade.
(WebCore::Element::setIsFailedCustomElement): Clear the reaction queue when the upgrading had failed.
(WebCore::Element::enqueueToUpgrade): Added.
(WebCore::Element::reactionQueue): Added.
* dom/Element.h:
* dom/ElementRareData.h:
(WebCore::ElementRareData::customElementReactionQueue): Replaced customElementInterface.
(WebCore::ElementRareData::setCustomElementReactionQueue): Replaced setCustomElementReactionQueue.

LayoutTests:

Added a W3C style testharness.js test for making sure the custom element reaction queue exists per element,
and added a WebKit style test for making sure that the backup element queue exists.

* fast/custom-elements/backup-element-queue-expected.txt: Added.
* fast/custom-elements/backup-element-queue.html: Added.
* fast/custom-elements/custom-element-reaction-queue-expected.txt: Added.
* fast/custom-elements/custom-element-reaction-queue.html: Added.

Modified Paths

Added Paths

Diff

Modified: trunk/LayoutTests/ChangeLog (207809 => 207810)


--- trunk/LayoutTests/ChangeLog	2016-10-25 06:07:04 UTC (rev 207809)
+++ trunk/LayoutTests/ChangeLog	2016-10-25 06:18:13 UTC (rev 207810)
@@ -1,3 +1,18 @@
+2016-10-24  Ryosuke Niwa  <[email protected]>
+
+        Custom elements reactions should have a queue per element
+        https://bugs.webkit.org/show_bug.cgi?id=163878
+
+        Reviewed by Antti Koivisto.
+
+        Added a W3C style testharness.js test for making sure the custom element reaction queue exists per element,
+        and added a WebKit style test for making sure that the backup element queue exists.
+
+        * fast/custom-elements/backup-element-queue-expected.txt: Added.
+        * fast/custom-elements/backup-element-queue.html: Added.
+        * fast/custom-elements/custom-element-reaction-queue-expected.txt: Added.
+        * fast/custom-elements/custom-element-reaction-queue.html: Added.
+
 2016-10-24  Jiewen Tan  <[email protected]>
 
         Update SubtleCrypto::generateKey to match the latest spec

Added: trunk/LayoutTests/fast/custom-elements/backup-element-queue-expected.txt (0 => 207810)


--- trunk/LayoutTests/fast/custom-elements/backup-element-queue-expected.txt	                        (rev 0)
+++ trunk/LayoutTests/fast/custom-elements/backup-element-queue-expected.txt	2016-10-25 06:18:13 UTC (rev 207810)
@@ -0,0 +1,15 @@
+This tests the existence of the backup element queue. To manually test, press the delete key once the page is loaded.
+
+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
+
+
+PASS constructed is false
+PASS editor.innerHTML = "a<test-element>b</test-element>c"; constructed is true
+PASS editor.focus(); getSelection().selectAllChildren(editor); disconnected is false
+PASS "Before the end of the micro task"; disconnected is false
+PASS "At the end of the micro task"; disconnected is true
+PASS successfullyParsed is true
+
+TEST COMPLETE
+
+

Added: trunk/LayoutTests/fast/custom-elements/backup-element-queue.html (0 => 207810)


--- trunk/LayoutTests/fast/custom-elements/backup-element-queue.html	                        (rev 0)
+++ trunk/LayoutTests/fast/custom-elements/backup-element-queue.html	2016-10-25 06:18:13 UTC (rev 207810)
@@ -0,0 +1,51 @@
+<!DOCTYPE html>
+<html>
+<body>
+<script src=""
+<div id="editor" contenteditable></div>
+<script>
+
+description('This tests the existence of the backup element queue. To manually test, press the delete key once the page is loaded.');
+
+var jsTestIsAsync = true;
+
+var constructed = false;
+var disconnected = false;
+class TestElement extends HTMLElement {
+    constructor() {
+        super();
+        constructed = true;
+    }
+    disconnectedCallback() {
+        disconnected = true;
+    }
+}
+customElements.define('test-element', TestElement);
+
+var editor = document.getElementById('editor');
+shouldBe('constructed', 'false');
+shouldBe('editor.innerHTML = "a<test-element>b</test-element>c"; constructed', 'true');
+shouldBe('editor.focus(); getSelection().selectAllChildren(editor); disconnected', 'false');
+
+function checkDisconnectedAtEndOfMictotask()
+{
+    shouldBe('"Before the end of the micro task"; disconnected', 'false');
+    Promise.resolve().then(function () {
+        shouldBe('"At the end of the micro task"; disconnected', 'true');
+        finishJSTest();
+    });
+}
+
+if (window.testRunner) {
+    testRunner.execCommand('delete', false, null);
+    checkDisconnectedAtEndOfMictotask();
+} else {
+    editor._oninput_ = function () {
+        checkDisconnectedAtEndOfMictotask();
+    }
+}
+
+
+</script>
+</body>
+</html>

Added: trunk/LayoutTests/fast/custom-elements/custom-element-reaction-queue-expected.txt (0 => 207810)


--- trunk/LayoutTests/fast/custom-elements/custom-element-reaction-queue-expected.txt	                        (rev 0)
+++ trunk/LayoutTests/fast/custom-elements/custom-element-reaction-queue-expected.txt	2016-10-25 06:18:13 UTC (rev 207810)
@@ -0,0 +1,5 @@
+
+PASS Upgrading a custom element must invoke attributeChangedCallback and connectedCallback before start upgrading another element 
+PASS Mutating a undefined custom element while upgrading a custom element must not enqueue or invoke reactions on the mutated element 
+PASS Mutating another custom element inside adopted callback must invoke all pending callbacks on the mutated element 
+

Added: trunk/LayoutTests/fast/custom-elements/custom-element-reaction-queue.html (0 => 207810)


--- trunk/LayoutTests/fast/custom-elements/custom-element-reaction-queue.html	                        (rev 0)
+++ trunk/LayoutTests/fast/custom-elements/custom-element-reaction-queue.html	2016-10-25 06:18:13 UTC (rev 207810)
@@ -0,0 +1,181 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>Custom Elements: Each element must have its own custom element reaction queue</title>
+<meta name="author" title="Ryosuke Niwa" href=""
+<meta name="assert" content="Each element must have its own custom element reaction queue">
+<meta name="help" content="https://html.spec.whatwg.org/multipage/scripting.html#custom-element-reaction-queue">
+<script src=""
+<script src=""
+<script src=""
+</head>
+<body>
+<div id="log"></div>
+<script>
+
+function create_constructor_log(element) {
+    return {type: 'constructed', element: element};
+}
+
+function assert_constructor_log_entry(log, element) {
+    assert_equals(log.type, 'constructed');
+    assert_equals(log.element, element);
+}
+
+function assert_adopted_log_entry(log, element) {
+    assert_equals(log.type, 'adopted');
+    assert_equals(log.element, element);
+}
+
+function create_adopted_callback_log(element) {
+    return {type: 'adopted', element: element};
+}
+
+function create_connected_callback_log(element) {
+    return {type: 'connected', element: element};
+}
+
+function assert_connected_log_entry(log, element) {
+    assert_equals(log.type, 'connected');
+    assert_equals(log.element, element);
+}
+
+test_with_window(function (contentWindow) {
+    const contentDocument = contentWindow.document;
+    contentDocument.write('<test-element id="first-element">');
+    contentDocument.write('<test-element id="second-element">');
+
+    const element1 = contentDocument.getElementById('first-element');
+    const element2 = contentDocument.getElementById('second-element');
+    assert_equals(Object.getPrototypeOf(element1), contentWindow.HTMLElement.prototype);
+    assert_equals(Object.getPrototypeOf(element2), contentWindow.HTMLElement.prototype);
+
+    let log = [];
+    class TestElement extends contentWindow.HTMLElement {
+        constructor() {
+            super();
+            log.push(create_constructor_log(this));
+        }
+        connectedCallback(...args) {
+            log.push(create_connected_callback_log(this, ...args));
+        }
+        attributeChangedCallback(...args) {
+            log.push(create_attribute_changed_callback_log(this, ...args));
+        }
+        static get observedAttributes() { return ['id']; }
+    }
+    contentWindow.customElements.define('test-element', TestElement);
+    assert_equals(Object.getPrototypeOf(element1), TestElement.prototype);
+    assert_equals(Object.getPrototypeOf(element2), TestElement.prototype);
+
+    assert_equals(log.length, 6);
+    assert_constructor_log_entry(log[0], element1);
+    assert_attribute_log_entry(log[1], {name: 'id', oldValue: null, newValue: 'first-element', namespace: null});
+    assert_connected_log_entry(log[2], element1);
+    assert_constructor_log_entry(log[3], element2);
+    assert_attribute_log_entry(log[4], {name: 'id', oldValue: null, newValue: 'second-element', namespace: null});
+    assert_connected_log_entry(log[5], element2);
+}, 'Upgrading a custom element must invoke attributeChangedCallback and connectedCallback before start upgrading another element');
+
+test_with_window(function (contentWindow) {
+    const contentDocument = contentWindow.document;
+    contentDocument.write('<test-element id="first-element">');
+    contentDocument.write('<test-element id="second-element">');
+
+    const element1 = contentDocument.getElementById('first-element');
+    const element2 = contentDocument.getElementById('second-element');
+    assert_equals(Object.getPrototypeOf(element1), contentWindow.HTMLElement.prototype);
+    assert_equals(Object.getPrototypeOf(element2), contentWindow.HTMLElement.prototype);
+
+    let log = [];
+    class TestElement extends contentWindow.HTMLElement {
+        constructor() {
+            super();
+            log.push(create_constructor_log(this));
+            if (this == element1)
+                element2.setAttribute('class', 'foo');
+        }
+        connectedCallback(...args) {
+            log.push(create_connected_callback_log(this, ...args));
+        }
+        attributeChangedCallback(...args) {
+            log.push(create_attribute_changed_callback_log(this, ...args));
+        }
+        static get observedAttributes() { return ['id', 'class']; }
+    }
+    contentWindow.customElements.define('test-element', TestElement);
+    assert_equals(Object.getPrototypeOf(element1), TestElement.prototype);
+    assert_equals(Object.getPrototypeOf(element2), TestElement.prototype);
+
+    assert_equals(log.length, 7);
+    assert_constructor_log_entry(log[0], element1);
+    assert_attribute_log_entry(log[1], {name: 'id', oldValue: null, newValue: 'first-element', namespace: null});
+    assert_connected_log_entry(log[2], element1);
+    assert_constructor_log_entry(log[3], element2);
+    assert_attribute_log_entry(log[4], {name: 'id', oldValue: null, newValue: 'second-element', namespace: null});
+    assert_attribute_log_entry(log[5], {name: 'class', oldValue: null, newValue: 'foo', namespace: null});
+    assert_connected_log_entry(log[6], element2);
+}, 'Mutating a undefined custom element while upgrading a custom element must not enqueue or invoke reactions on the mutated element');
+
+test_with_window(function (contentWindow) {
+    let log = [];
+    let element1;
+    let element2;
+    class TestElement extends contentWindow.HTMLElement {
+        constructor() {
+            super();
+            log.push(create_constructor_log(this));
+        }
+        adoptedCallback(...args) {
+            log.push(create_adopted_callback_log(this, ...args));
+            if (this == element1)
+                element3.setAttribute('id', 'foo');
+        }
+        connectedCallback(...args) {
+            log.push(create_connected_callback_log(this, ...args));
+        }
+        attributeChangedCallback(...args) {
+            log.push(create_attribute_changed_callback_log(this, ...args));
+        }
+        static get observedAttributes() { return ['id', 'class']; }
+    }
+
+    contentWindow.customElements.define('test-element', TestElement);
+
+    let contentDocument = contentWindow.document;
+    element1 = contentDocument.createElement('test-element');
+    element2 = contentDocument.createElement('test-element');
+    element3 = contentDocument.createElement('test-element');
+    assert_equals(Object.getPrototypeOf(element1), TestElement.prototype);
+    assert_equals(Object.getPrototypeOf(element2), TestElement.prototype);
+    assert_equals(Object.getPrototypeOf(element3), TestElement.prototype);
+
+    assert_equals(log.length, 3);
+    assert_constructor_log_entry(log[0], element1);
+    assert_constructor_log_entry(log[1], element2);
+    assert_constructor_log_entry(log[2], element3);
+    log = [];
+
+    const container = contentDocument.createElement('div');
+    container.appendChild(element1);
+    container.appendChild(element2);
+    container.appendChild(element3);
+
+    const anotherDocument = document.implementation.createHTMLDocument();
+    anotherDocument.documentElement.appendChild(container);
+
+    assert_equals(log.length, 7);
+    assert_adopted_log_entry(log[0], element1);
+    assert_adopted_log_entry(log[1], element3);
+    assert_connected_log_entry(log[2], element3);
+    assert_attribute_log_entry(log[3], {name: 'id', oldValue: null, newValue: 'foo', namespace: null});
+    assert_connected_log_entry(log[4], element1);
+    assert_adopted_log_entry(log[5], element2);
+    assert_connected_log_entry(log[6], element2);
+
+}, 'Mutating another custom element inside adopted callback must invoke all pending callbacks on the mutated element');
+
+
+</script>
+</body>
+</html>

Modified: trunk/Source/WebCore/ChangeLog (207809 => 207810)


--- trunk/Source/WebCore/ChangeLog	2016-10-25 06:07:04 UTC (rev 207809)
+++ trunk/Source/WebCore/ChangeLog	2016-10-25 06:18:13 UTC (rev 207810)
@@ -1,3 +1,77 @@
+2016-10-24  Ryosuke Niwa  <[email protected]>
+
+        Custom elements reactions should have a queue per element
+        https://bugs.webkit.org/show_bug.cgi?id=163878
+
+        Reviewed by Antti Koivisto.
+
+        This patch splits the custom elements reaction queue into per element to match the latest HTML specifications:
+        https://html.spec.whatwg.org/multipage/scripting.html#custom-element-reaction-queue
+        and introduces the backup element queue:
+        https://html.spec.whatwg.org/multipage/scripting.html#backup-element-queue
+
+        In terms of code changes, CustomElementReactionStack now holds onto ElementQueue, an ordered list of elements,
+        and make each ElementRareData keep its own CustomElementReactionQueue. CustomElementReactionQueue is created
+        for each custom element when it is synchronously constructed or enqueued to upgrade.
+
+        Because each reaction queue is now specific to each element, CustomElementReactionQueue instead of
+        CustomElementReactionQueueItem stores JSCustomElementInterface.
+
+        The backup element queue is created as a singleton returned by CustomElementReactionStack's backupElementQueue,
+        and ensureBackupQueue() schedules a new mirotask to process the backup queue when there isn't already one.
+
+        ensureCurrentQueue() now returns a reference to CustomElementReactionQueue instead of a pointer since it can
+        fallback to the backup queue when the stack is empty as specified:
+        https://html.spec.whatwg.org/multipage/scripting.html#enqueue-an-element-on-the-appropriate-element-queue
+
+        Note that ensureCurrentQueue() may insert the same element multiple times into the element queue for now since
+        avoiding this duplication would require either doing O(n) iteration on m_elements or adding a HashSet.
+        We can revisit this in the future if the reaction queue is found to grow beyond a few entries since elements in
+        the element queue will have duplicates only when each reaction queue has more than one item.
+
+        Tests: fast/custom-elements/backup-element-queue.html
+               fast/custom-elements/custom-element-reaction-queue.html
+
+        * bindings/js/JSCustomElementInterface.cpp:
+        (WebCore::JSCustomElementInterface::upgradeElement):
+        * dom/CustomElementReactionQueue.cpp:
+        (WebCore::CustomElementReactionQueueItem::CustomElementReactionQueueItem):
+        (WebCore::CustomElementReactionQueueItem::invoke): Removed the check for isFailedCustomElement since the queue
+        is explicitly cleared in Element::setIsFailedCustomElement.
+        (WebCore::CustomElementReactionQueue::CustomElementReactionQueue): Now takes JSCustomElementInterface since
+        each item in the queue no longer stores Element or JSCustomElementInterface.
+        (WebCore::CustomElementReactionQueue::clear):
+        (WebCore::CustomElementReactionQueue::enqueueElementUpgrade):
+        (WebCore::CustomElementReactionQueue::enqueueElementUpgradeIfDefined):
+        (WebCore::CustomElementReactionQueue::enqueueConnectedCallbackIfNeeded):
+        (WebCore::CustomElementReactionQueue::enqueueDisconnectedCallbackIfNeeded):
+        (WebCore::CustomElementReactionQueue::enqueueAdoptedCallbackIfNeeded):
+        (WebCore::CustomElementReactionQueue::enqueueAttributeChangedCallbackIfNeeded):
+        (WebCore::CustomElementReactionQueue::enqueuePostUpgradeReactions):
+        (WebCore::CustomElementReactionQueue::invokeAll):
+        (WebCore::CustomElementReactionStack::ElementQueue::add): Added.
+        (WebCore::CustomElementReactionStack::ElementQueue::invokeAll): Added.
+        (WebCore::CustomElementReactionStack::ensureCurrentQueue):
+        (WebCore::BackupElementQueueMicrotask): Added.
+        (WebCore::CustomElementReactionStack::ensureBackupQueue): Added.
+        (WebCore::CustomElementReactionStack::processBackupQueue): Added.
+        (WebCore::CustomElementReactionStack::backupElementQueue): Added.
+        * dom/CustomElementReactionQueue.h:
+        * dom/CustomElementRegistry.cpp:
+        (WebCore::enqueueUpgradeInShadowIncludingTreeOrder):
+        * dom/Document.cpp:
+        (WebCore::createFallbackHTMLElement):
+        * dom/Element.cpp:
+        (WebCore::Element::setIsDefinedCustomElement): Create a new reaction queue if there isn't already one; when
+        this element had been upgraded, the reaction queue have already been created in Element::enqueueToUpgrade.
+        (WebCore::Element::setIsFailedCustomElement): Clear the reaction queue when the upgrading had failed.
+        (WebCore::Element::enqueueToUpgrade): Added.
+        (WebCore::Element::reactionQueue): Added.
+        * dom/Element.h:
+        * dom/ElementRareData.h:
+        (WebCore::ElementRareData::customElementReactionQueue): Replaced customElementInterface.
+        (WebCore::ElementRareData::setCustomElementReactionQueue): Replaced setCustomElementReactionQueue.
+
 2016-10-24  Jiewen Tan  <[email protected]>
 
         Update SubtleCrypto::generateKey to match the latest spec

Modified: trunk/Source/WebCore/bindings/js/JSCustomElementInterface.cpp (207809 => 207810)


--- trunk/Source/WebCore/bindings/js/JSCustomElementInterface.cpp	2016-10-25 06:07:04 UTC (rev 207809)
+++ trunk/Source/WebCore/bindings/js/JSCustomElementInterface.cpp	2016-10-25 06:18:13 UTC (rev 207810)
@@ -182,7 +182,7 @@
         return;
     }
 
-    CustomElementReactionQueue::enqueuePostUpgradeReactions(element, *this);
+    CustomElementReactionQueue::enqueuePostUpgradeReactions(element);
 
     m_constructionStack.append(&element);
 

Modified: trunk/Source/WebCore/dom/CustomElementReactionQueue.cpp (207809 => 207810)


--- trunk/Source/WebCore/dom/CustomElementReactionQueue.cpp	2016-10-25 06:07:04 UTC (rev 207809)
+++ trunk/Source/WebCore/dom/CustomElementReactionQueue.cpp	2016-10-25 06:18:13 UTC (rev 207810)
@@ -34,6 +34,7 @@
 #include "Element.h"
 #include "JSCustomElementInterface.h"
 #include "JSDOMBinding.h"
+#include "Microtasks.h"
 #include <heap/Heap.h>
 #include <wtf/Optional.h>
 #include <wtf/Ref.h>
@@ -50,49 +51,41 @@
         AttributeChanged,
     };
 
-    CustomElementReactionQueueItem(Type type, Element& element, JSCustomElementInterface& elementInterface)
+    CustomElementReactionQueueItem(Type type)
         : m_type(type)
-        , m_element(element)
-        , m_interface(elementInterface)
     { }
 
-    CustomElementReactionQueueItem(Element& element, JSCustomElementInterface& elementInterface, Document& oldDocument, Document& newDocument)
+    CustomElementReactionQueueItem(Document& oldDocument, Document& newDocument)
         : m_type(Type::Adopted)
-        , m_element(element)
-        , m_interface(elementInterface)
         , m_oldDocument(&oldDocument)
         , m_newDocument(&newDocument)
     { }
 
-    CustomElementReactionQueueItem(Element& element, JSCustomElementInterface& elementInterface, const QualifiedName& attributeName, const AtomicString& oldValue, const AtomicString& newValue)
+    CustomElementReactionQueueItem(const QualifiedName& attributeName, const AtomicString& oldValue, const AtomicString& newValue)
         : m_type(Type::AttributeChanged)
-        , m_element(element)
-        , m_interface(elementInterface)
         , m_attributeName(attributeName)
         , m_oldValue(oldValue)
         , m_newValue(newValue)
     { }
 
-    void invoke()
+    void invoke(Element& element, JSCustomElementInterface& elementInterface)
     {
-        if (m_element->isFailedCustomElement())
-            return;
         switch (m_type) {
         case Type::ElementUpgrade:
-            m_interface->upgradeElement(m_element.get());
+            elementInterface.upgradeElement(element);
             break;
         case Type::Connected:
-            m_interface->invokeConnectedCallback(m_element.get());
+            elementInterface.invokeConnectedCallback(element);
             break;
         case Type::Disconnected:
-            m_interface->invokeDisconnectedCallback(m_element.get());
+            elementInterface.invokeDisconnectedCallback(element);
             break;
         case Type::Adopted:
-            m_interface->invokeAdoptedCallback(m_element.get(), *m_oldDocument, *m_newDocument);
+            elementInterface.invokeAdoptedCallback(element, *m_oldDocument, *m_newDocument);
             break;
         case Type::AttributeChanged:
             ASSERT(m_attributeName);
-            m_interface->invokeAttributeChangedCallback(m_element.get(), m_attributeName.value(), m_oldValue, m_newValue);
+            elementInterface.invokeAttributeChangedCallback(element, m_attributeName.value(), m_oldValue, m_newValue);
             break;
         }
     }
@@ -99,8 +92,6 @@
 
 private:
     Type m_type;
-    Ref<Element> m_element;
-    Ref<JSCustomElementInterface> m_interface;
     RefPtr<Document> m_oldDocument;
     RefPtr<Document> m_newDocument;
     Optional<QualifiedName> m_attributeName;
@@ -108,7 +99,8 @@
     AtomicString m_newValue;
 };
 
-CustomElementReactionQueue::CustomElementReactionQueue()
+CustomElementReactionQueue::CustomElementReactionQueue(JSCustomElementInterface& elementInterface)
+    : m_interface(elementInterface)
 { }
 
 CustomElementReactionQueue::~CustomElementReactionQueue()
@@ -116,13 +108,17 @@
     ASSERT(m_items.isEmpty());
 }
 
-void CustomElementReactionQueue::enqueueElementUpgrade(Element& element, JSCustomElementInterface& elementInterface)
+void CustomElementReactionQueue::clear()
 {
-    ASSERT(element.tagQName() == elementInterface.name());
-    if (auto* queue = CustomElementReactionStack::ensureCurrentQueue())
-        queue->m_items.append({CustomElementReactionQueueItem::Type::ElementUpgrade, element, elementInterface});
+    m_items.clear();
 }
 
+void CustomElementReactionQueue::enqueueElementUpgrade(Element& element)
+{
+    auto& queue = CustomElementReactionStack::ensureCurrentQueue(element);
+    queue.m_items.append({CustomElementReactionQueueItem::Type::ElementUpgrade});
+}
+
 void CustomElementReactionQueue::enqueueElementUpgradeIfDefined(Element& element)
 {
     ASSERT(element.inDocument());
@@ -139,97 +135,102 @@
     if (!elementInterface)
         return;
 
-    enqueueElementUpgrade(element, *elementInterface);
+    element.enqueueToUpgrade(*elementInterface);
 }
 
 void CustomElementReactionQueue::enqueueConnectedCallbackIfNeeded(Element& element)
 {
     ASSERT(element.isDefinedCustomElement());
-    auto* elementInterface = element.customElementInterface();
-    ASSERT(elementInterface);
-    if (!elementInterface->hasConnectedCallback())
-        return;
-
-    if (auto* queue = CustomElementReactionStack::ensureCurrentQueue())
-        queue->m_items.append({CustomElementReactionQueueItem::Type::Connected, element, *elementInterface});
+    auto& queue = CustomElementReactionStack::ensureCurrentQueue(element);
+    if (queue.m_interface->hasConnectedCallback())
+        queue.m_items.append({CustomElementReactionQueueItem::Type::Connected});
 }
 
 void CustomElementReactionQueue::enqueueDisconnectedCallbackIfNeeded(Element& element)
 {
     ASSERT(element.isDefinedCustomElement());
-    auto* elementInterface = element.customElementInterface();
-    ASSERT(elementInterface);
-    if (!elementInterface->hasDisconnectedCallback())
-        return;
-
-    if (auto* queue = CustomElementReactionStack::ensureCurrentQueue())
-        queue->m_items.append({CustomElementReactionQueueItem::Type::Disconnected, element, *elementInterface});
+    auto& queue = CustomElementReactionStack::ensureCurrentQueue(element);
+    if (queue.m_interface->hasDisconnectedCallback())
+        queue.m_items.append({CustomElementReactionQueueItem::Type::Disconnected});
 }
 
 void CustomElementReactionQueue::enqueueAdoptedCallbackIfNeeded(Element& element, Document& oldDocument, Document& newDocument)
 {
     ASSERT(element.isDefinedCustomElement());
-    auto* elementInterface = element.customElementInterface();
-    ASSERT(elementInterface);
-    if (!elementInterface->hasAdoptedCallback())
-        return;
-
-    if (auto* queue = CustomElementReactionStack::ensureCurrentQueue())
-        queue->m_items.append({element, *elementInterface, oldDocument, newDocument});
+    auto& queue = CustomElementReactionStack::ensureCurrentQueue(element);
+    if (queue.m_interface->hasAdoptedCallback())
+        queue.m_items.append({oldDocument, newDocument});
 }
 
 void CustomElementReactionQueue::enqueueAttributeChangedCallbackIfNeeded(Element& element, const QualifiedName& attributeName, const AtomicString& oldValue, const AtomicString& newValue)
 {
     ASSERT(element.isDefinedCustomElement());
-    auto* elementInterface = element.customElementInterface();
-    ASSERT(elementInterface);
-    if (!elementInterface->observesAttribute(attributeName.localName()))
-        return;
-
-    if (auto* queue = CustomElementReactionStack::ensureCurrentQueue())
-        queue->m_items.append({element, *elementInterface, attributeName, oldValue, newValue});
+    auto& queue = CustomElementReactionStack::ensureCurrentQueue(element);
+    if (queue.m_interface->observesAttribute(attributeName.localName()))
+        queue.m_items.append({attributeName, oldValue, newValue});
 }
 
-void CustomElementReactionQueue::enqueuePostUpgradeReactions(Element& element, JSCustomElementInterface& elementInterface)
+void CustomElementReactionQueue::enqueuePostUpgradeReactions(Element& element)
 {
+    ASSERT(element.isCustomElementUpgradeCandidate());
     if (!element.hasAttributes() && !element.inDocument())
         return;
 
-    auto* queue = CustomElementReactionStack::ensureCurrentQueue();
-    if (!queue)
-        return;
+    auto* queue = element.reactionQueue();
+    ASSERT(queue);
 
     if (element.hasAttributes()) {
         for (auto& attribute : element.attributesIterator()) {
-            if (elementInterface.observesAttribute(attribute.localName()))
-                queue->m_items.append({element, elementInterface, attribute.name(), nullAtom, attribute.value()});
+            if (queue->m_interface->observesAttribute(attribute.localName()))
+                queue->m_items.append({attribute.name(), nullAtom, attribute.value()});
         }
     }
 
-    if (element.inDocument() && elementInterface.hasConnectedCallback())
-        queue->m_items.append({CustomElementReactionQueueItem::Type::Connected, element, elementInterface});
+    if (element.inDocument() && queue->m_interface->hasConnectedCallback())
+        queue->m_items.append({CustomElementReactionQueueItem::Type::Connected});
 }
 
-void CustomElementReactionQueue::invokeAll()
+void CustomElementReactionQueue::invokeAll(Element& element)
 {
-    // FIXME: This queue needs to be per element.
     while (!m_items.isEmpty()) {
         Vector<CustomElementReactionQueueItem> items = WTFMove(m_items);
         for (auto& item : items)
-            item.invoke();
+            item.invoke(element, m_interface.get());
     }
 }
 
-CustomElementReactionQueue* CustomElementReactionStack::ensureCurrentQueue()
+inline void CustomElementReactionStack::ElementQueue::add(Element& element)
 {
-    // FIXME: This early exit indicates a bug that some DOM API is missing CEReactions
-    if (!s_currentProcessingStack)
-        return nullptr;
+    // FIXME: Avoid inserting the same element multiple times.
+    m_elements.append(element);
+}
 
+inline void CustomElementReactionStack::ElementQueue::invokeAll()
+{
+    Vector<Ref<Element>> elements;
+    elements.swap(m_elements);
+    for (auto& element : elements) {
+        auto* queue = element->reactionQueue();
+        ASSERT(queue);
+        queue->invokeAll(element.get());
+    }
+    ASSERT(m_elements.isEmpty());
+}
+
+CustomElementReactionQueue& CustomElementReactionStack::ensureCurrentQueue(Element& element)
+{
+    ASSERT(element.reactionQueue());
+    if (!s_currentProcessingStack) {
+        auto& queue = CustomElementReactionStack::ensureBackupQueue();
+        queue.add(element);
+        return *element.reactionQueue();
+    }
+
     auto*& queue = s_currentProcessingStack->m_queue;
     if (!queue) // We use a raw pointer to avoid genearing code to delete it in ~CustomElementReactionStack.
-        queue = new CustomElementReactionQueue;
-    return queue;
+        queue = new ElementQueue;
+    queue->add(element);
+    return *element.reactionQueue();
 }
 
 CustomElementReactionStack* CustomElementReactionStack::s_currentProcessingStack = nullptr;
@@ -242,6 +243,39 @@
     m_queue = nullptr;
 }
 
+class BackupElementQueueMicrotask final : public Microtask {
+    WTF_MAKE_FAST_ALLOCATED;
+private:
+    Result run() final
+    {
+        CustomElementReactionStack::processBackupQueue();
+        return Result::Done;
+    }
+};
+
+static bool s_processingBackupElementQueue = false;
+
+CustomElementReactionStack::ElementQueue& CustomElementReactionStack::ensureBackupQueue()
+{
+    if (!s_processingBackupElementQueue) {
+        s_processingBackupElementQueue = true;
+        MicrotaskQueue::mainThreadQueue().append(std::make_unique<BackupElementQueueMicrotask>());
+    }
+    return backupElementQueue();
 }
 
+void CustomElementReactionStack::processBackupQueue()
+{
+    backupElementQueue().invokeAll();
+    s_processingBackupElementQueue = false;
+}
+
+CustomElementReactionStack::ElementQueue& CustomElementReactionStack::backupElementQueue()
+{
+    static NeverDestroyed<ElementQueue> queue;
+    return queue.get();
+}
+
+}
+
 #endif

Modified: trunk/Source/WebCore/dom/CustomElementReactionQueue.h (207809 => 207810)


--- trunk/Source/WebCore/dom/CustomElementReactionQueue.h	2016-10-25 06:07:04 UTC (rev 207809)
+++ trunk/Source/WebCore/dom/CustomElementReactionQueue.h	2016-10-25 06:18:13 UTC (rev 207810)
@@ -42,20 +42,22 @@
 class CustomElementReactionQueue {
     WTF_MAKE_NONCOPYABLE(CustomElementReactionQueue);
 public:
-    CustomElementReactionQueue();
+    CustomElementReactionQueue(JSCustomElementInterface&);
     ~CustomElementReactionQueue();
 
-    static void enqueueElementUpgrade(Element&, JSCustomElementInterface&);
+    static void enqueueElementUpgrade(Element&);
     static void enqueueElementUpgradeIfDefined(Element&);
     static void enqueueConnectedCallbackIfNeeded(Element&);
     static void enqueueDisconnectedCallbackIfNeeded(Element&);
     static void enqueueAdoptedCallbackIfNeeded(Element&, Document& oldDocument, Document& newDocument);
     static void enqueueAttributeChangedCallbackIfNeeded(Element&, const QualifiedName&, const AtomicString& oldValue, const AtomicString& newValue);
-    static void enqueuePostUpgradeReactions(Element&, JSCustomElementInterface&);
+    static void enqueuePostUpgradeReactions(Element&);
 
-    void invokeAll();
+    void invokeAll(Element&);
+    void clear();
 
 private:
+    Ref<JSCustomElementInterface> m_interface;
     Vector<CustomElementReactionQueueItem> m_items;
 };
 
@@ -74,15 +76,28 @@
         s_currentProcessingStack = m_previousProcessingStack;
     }
 
-    // FIXME: This should be a reference once "ensure" starts to work.
-    static CustomElementReactionQueue* ensureCurrentQueue();
+    static CustomElementReactionQueue& ensureCurrentQueue(Element&);
 
     static bool hasCurrentProcessingStack() { return s_currentProcessingStack; }
 
+    static void processBackupQueue();
+
 private:
+    class ElementQueue {
+    public:
+        void add(Element&);
+        void invokeAll();
+
+    private:
+        Vector<Ref<Element>> m_elements;
+    };
+
     WEBCORE_EXPORT void processQueue();
 
-    CustomElementReactionQueue* m_queue { nullptr };
+    static ElementQueue& ensureBackupQueue();
+    static ElementQueue& backupElementQueue();
+
+    ElementQueue* m_queue { nullptr };
     CustomElementReactionStack* m_previousProcessingStack;
 
     WEBCORE_EXPORT static CustomElementReactionStack* s_currentProcessingStack;

Modified: trunk/Source/WebCore/dom/CustomElementRegistry.cpp (207809 => 207810)


--- trunk/Source/WebCore/dom/CustomElementRegistry.cpp	2016-10-25 06:07:04 UTC (rev 207809)
+++ trunk/Source/WebCore/dom/CustomElementRegistry.cpp	2016-10-25 06:18:13 UTC (rev 207810)
@@ -60,7 +60,7 @@
 {
     for (Element* element = ElementTraversal::firstWithin(node); element; element = ElementTraversal::next(*element)) {
         if (element->isCustomElementUpgradeCandidate() && element->tagQName() == elementInterface.name())
-            CustomElementReactionQueue::enqueueElementUpgrade(*element, elementInterface);
+            element->enqueueToUpgrade(elementInterface);
         if (auto* shadowRoot = element->shadowRoot()) {
             if (shadowRoot->mode() != ShadowRoot::Mode::UserAgent)
                 enqueueUpgradeInShadowIncludingTreeOrder(*shadowRoot, elementInterface);

Modified: trunk/Source/WebCore/dom/Document.cpp (207809 => 207810)


--- trunk/Source/WebCore/dom/Document.cpp	2016-10-25 06:07:04 UTC (rev 207809)
+++ trunk/Source/WebCore/dom/Document.cpp	2016-10-25 06:18:13 UTC (rev 207810)
@@ -1075,8 +1075,7 @@
         if (UNLIKELY(registry)) {
             if (auto* elementInterface = registry->findInterface(name)) {
                 auto element = HTMLElement::create(name, document);
-                element->setIsCustomElementUpgradeCandidate();
-                CustomElementReactionQueue::enqueueElementUpgrade(element.get(), *elementInterface);
+                element->enqueueToUpgrade(*elementInterface);
                 return element;
             }
         }

Modified: trunk/Source/WebCore/dom/Element.cpp (207809 => 207810)


--- trunk/Source/WebCore/dom/Element.cpp	2016-10-25 06:07:04 UTC (rev 207809)
+++ trunk/Source/WebCore/dom/Element.cpp	2016-10-25 06:18:13 UTC (rev 207810)
@@ -1902,15 +1902,22 @@
 {
     clearFlag(IsEditingTextOrUndefinedCustomElementFlag);
     setFlag(IsCustomElement);
-    ensureElementRareData().setCustomElementInterface(elementInterface);
+    auto& data = ""
+    if (!data.customElementReactionQueue())
+        data.setCustomElementReactionQueue(std::make_unique<CustomElementReactionQueue>(elementInterface));
 }
 
-void Element::setIsFailedCustomElement(JSCustomElementInterface& elementInterface)
+void Element::setIsFailedCustomElement(JSCustomElementInterface&)
 {
     ASSERT(isUndefinedCustomElement());
     ASSERT(getFlag(IsEditingTextOrUndefinedCustomElementFlag));
     clearFlag(IsCustomElement);
-    ensureElementRareData().setCustomElementInterface(elementInterface);
+
+    if (hasRareData()) {
+        // Clear the queue instead of deleting it since this function can be called inside CustomElementReactionQueue::invokeAll during upgrades.
+        if (auto* queue = elementRareData()->customElementReactionQueue())
+            queue->clear();
+    }
 }
 
 void Element::setIsCustomElementUpgradeCandidate()
@@ -1920,12 +1927,25 @@
     setFlag(IsEditingTextOrUndefinedCustomElementFlag);
 }
 
-JSCustomElementInterface* Element::customElementInterface() const
+void Element::enqueueToUpgrade(JSCustomElementInterface& elementInterface)
 {
-    ASSERT(isDefinedCustomElement());
+    ASSERT(!isDefinedCustomElement() && !isFailedCustomElement());
+    setFlag(IsCustomElement);
+    setFlag(IsEditingTextOrUndefinedCustomElementFlag);
+
+    auto& data = ""
+    ASSERT(!data.customElementReactionQueue());
+
+    data.setCustomElementReactionQueue(std::make_unique<CustomElementReactionQueue>(elementInterface));
+    data.customElementReactionQueue()->enqueueElementUpgrade(*this);
+}
+
+CustomElementReactionQueue* Element::reactionQueue() const
+{
+    ASSERT(isDefinedCustomElement() || isCustomElementUpgradeCandidate());
     if (!hasRareData())
         return nullptr;
-    return elementRareData()->customElementInterface();
+    return elementRareData()->customElementReactionQueue();
 }
 
 #endif

Modified: trunk/Source/WebCore/dom/Element.h (207809 => 207810)


--- trunk/Source/WebCore/dom/Element.h	2016-10-25 06:07:04 UTC (rev 207809)
+++ trunk/Source/WebCore/dom/Element.h	2016-10-25 06:18:13 UTC (rev 207810)
@@ -39,6 +39,7 @@
 
 class ClientRect;
 class ClientRectList;
+class CustomElementReactionQueue;
 class DatasetDOMStringMap;
 class Dictionary;
 class DOMTokenList;
@@ -284,7 +285,8 @@
     void setIsDefinedCustomElement(JSCustomElementInterface&);
     void setIsFailedCustomElement(JSCustomElementInterface&);
     void setIsCustomElementUpgradeCandidate();
-    JSCustomElementInterface* customElementInterface() const;
+    void enqueueToUpgrade(JSCustomElementInterface&);
+    CustomElementReactionQueue* reactionQueue() const;
 #endif
 
     // FIXME: this should not be virtual, do not override this.

Modified: trunk/Source/WebCore/dom/ElementRareData.h (207809 => 207810)


--- trunk/Source/WebCore/dom/ElementRareData.h	2016-10-25 06:07:04 UTC (rev 207809)
+++ trunk/Source/WebCore/dom/ElementRareData.h	2016-10-25 06:18:13 UTC (rev 207810)
@@ -22,6 +22,7 @@
 #ifndef ElementRareData_h
 #define ElementRareData_h
 
+#include "CustomElementReactionQueue.h"
 #include "DOMTokenList.h"
 #include "DatasetDOMStringMap.h"
 #include "JSCustomElementInterface.h"
@@ -95,8 +96,8 @@
     void setShadowRoot(RefPtr<ShadowRoot>&& shadowRoot) { m_shadowRoot = WTFMove(shadowRoot); }
 
 #if ENABLE(CUSTOM_ELEMENTS)
-    JSCustomElementInterface* customElementInterface() { return m_customElementInterface.get(); }
-    void setCustomElementInterface(JSCustomElementInterface& customElementInterface) { m_customElementInterface = &customElementInterface; }
+    CustomElementReactionQueue* customElementReactionQueue() { return m_customElementReactionQueue.get(); }
+    void setCustomElementReactionQueue(std::unique_ptr<CustomElementReactionQueue>&& queue) { m_customElementReactionQueue = WTFMove(queue); }
 #endif
 
     NamedNodeMap* attributeMap() const { return m_attributeMap.get(); }
@@ -156,7 +157,7 @@
     std::unique_ptr<DOMTokenList> m_classList;
     RefPtr<ShadowRoot> m_shadowRoot;
 #if ENABLE(CUSTOM_ELEMENTS)
-    RefPtr<JSCustomElementInterface> m_customElementInterface;
+    std::unique_ptr<CustomElementReactionQueue> m_customElementReactionQueue;
 #endif
     std::unique_ptr<NamedNodeMap> m_attributeMap;
 
_______________________________________________
webkit-changes mailing list
[email protected]
https://lists.webkit.org/mailman/listinfo/webkit-changes

Reply via email to