Attachment 348711 Details for Bug 189144 – WIP6 (with code change)

[patch] WIP6 (with code change)

wip189144f.patch (text/plain), 59.41 KB, created by Ryosuke Niwa on 2018-09-01 00:56:26 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Ryosuke Niwa

Created: 2018-09-01 00:56:26 PDT

Size: 59.41 KB

patch

obsolete

>Index: Source/WebCore/dom/ContainerNode.cpp
>===================================================================
>--- Source/WebCore/dom/ContainerNode.cpp	(revision 235581)
>+++ Source/WebCore/dom/ContainerNode.cpp	(working copy)
>@@ -59,6 +59,7 @@
> #include "SVGUseElement.h"
> #include "ScriptDisallowedScope.h"
> #include "SelectorQuery.h"
>+#include "SlotAssignment.h"
> #include "TemplateContentDocumentFragment.h"
> #include <algorithm>
> #include <wtf/IsoMallocInlines.h>
>@@ -104,6 +105,9 @@
> WidgetHierarchyUpdatesSuspensionScope suspendWidgetHierarchyUpdates;
> ScriptDisallowedScope::InMainThread scriptDisallowedScope;
> 
>+ if (UNLIKELY(isShadowRoot() || isInShadowTree()))
>+ containingShadowRoot()->willRemoveAllChildren(*this);
>+
> document().nodeChildrenWillBeRemoved(*this);
> 
> while (RefPtr<Node> child = m_firstChild) {
>@@ -150,6 +154,9 @@
> WidgetHierarchyUpdatesSuspensionScope suspendWidgetHierarchyUpdates;
> ScriptDisallowedScope::InMainThread scriptDisallowedScope;
> 
>+ if (UNLIKELY(isShadowRoot() || isInShadowTree()))
>+ containingShadowRoot()->resolveSlotsBeforeNodeInsertionOrRemoval();
>+
> document().nodeWillBeRemoved(childToRemove);
> 
> ASSERT_WITH_SECURITY_IMPLICATION(childToRemove.parentNode() == this);
>@@ -181,6 +188,10 @@
> NodeVector postInsertionNotificationTargets;
> {
> ScriptDisallowedScope::InMainThread scriptDisallowedScope;
>+
>+ if (UNLIKELY(containerNode.isShadowRoot() || containerNode.isInShadowTree()))
>+ containerNode.containingShadowRoot()->resolveSlotsBeforeNodeInsertionOrRemoval();
>+
> doNodeInsertion();
> ChildListMutationScope(containerNode).childAdded(child);
> postInsertionNotificationTargets = notifyChildNodeInserted(containerNode, child);
>Index: Source/WebCore/dom/ShadowRoot.cpp
>===================================================================
>--- Source/WebCore/dom/ShadowRoot.cpp	(revision 235581)
>+++ Source/WebCore/dom/ShadowRoot.cpp	(working copy)
>@@ -82,6 +82,9 @@
> // to access it Document reference after that.
> willBeDeletedFrom(document());
> 
>+ ASSERT(!m_hasBegunDeletingDetachedChildren);
>+ m_hasBegunDeletingDetachedChildren = true;
>+
> // We must remove all of our children first before the TreeScope destructor
> // runs so we don't go through Node::setTreeScopeRecursively for each child with a
> // destructed tree scope in each descendant.
>@@ -181,6 +184,12 @@
> return m_slotAssignment->findAssignedSlot(node, *this);
> }
> 
>+void ShadowRoot::renameSlotElement(HTMLSlotElement& slot, const AtomicString& oldName, const AtomicString& newName)
>+{
>+ ASSERT(m_slotAssignment);
>+ return m_slotAssignment->renameSlotElement(slot, oldName, newName, *this);
>+}
>+
> void ShadowRoot::addSlotElementByName(const AtomicString& name, HTMLSlotElement& slot)
> {
> ASSERT(&slot.rootNode() == this);
>@@ -190,9 +199,10 @@
> return m_slotAssignment->addSlotElementByName(name, slot, *this);
> }
> 
>-void ShadowRoot::removeSlotElementByName(const AtomicString& name, HTMLSlotElement& slot)
>+void ShadowRoot::removeSlotElementByName(const AtomicString& name, HTMLSlotElement& slot, ContainerNode& oldParentOfRemovedTree)
> {
>- return m_slotAssignment->removeSlotElementByName(name, slot, *this);
>+ ASSERT(m_slotAssignment);
>+ return m_slotAssignment->removeSlotElementByName(name, slot, &oldParentOfRemovedTree, *this);
> }
> 
> void ShadowRoot::slotFallbackDidChange(HTMLSlotElement& slot)
>Index: Source/WebCore/dom/ShadowRoot.h
>===================================================================
>--- Source/WebCore/dom/ShadowRoot.h	(revision 235581)
>+++ Source/WebCore/dom/ShadowRoot.h	(working copy)
>@@ -58,6 +58,11 @@
> bool resetStyleInheritance() const { return m_resetStyleInheritance; }
> void setResetStyleInheritance(bool);
> 
>+ bool hasBegunDeletingDetachedChildren() const { return m_hasBegunDeletingDetachedChildren; }
>+
>+ ShadowRootMode mode() const { return m_type; }
>+ bool shouldFireSlotchangeEvent() const { return m_type != ShadowRootMode::UserAgent && !m_hasBegunDeletingDetachedChildren; }
>+
> Element* host() const { return m_host; }
> void setHost(Element* host) { m_host = host; }
> 
>@@ -66,15 +71,16 @@
> 
> Element* activeElement() const;
> 
>- ShadowRootMode mode() const { return m_type; }
>-
> void removeAllEventListeners() override;
> 
> HTMLSlotElement* findAssignedSlot(const Node&);
> 
>+ void renameSlotElement(HTMLSlotElement&, const AtomicString& oldName, const AtomicString& newName);
> void addSlotElementByName(const AtomicString&, HTMLSlotElement&);
>- void removeSlotElementByName(const AtomicString&, HTMLSlotElement&);
>+ void removeSlotElementByName(const AtomicString&, HTMLSlotElement&, ContainerNode& oldParentOfRemovedTree);
> void slotFallbackDidChange(HTMLSlotElement&);
>+ void resolveSlotsBeforeNodeInsertionOrRemoval();
>+ void willRemoveAllChildren(ContainerNode&);
> 
> void didRemoveAllChildrenOfShadowHost();
> void didChangeDefaultSlot();
>@@ -103,6 +109,7 @@
> void removedFromAncestor(RemovalType, ContainerNode& insertionPoint) override;
> 
> bool m_resetStyleInheritance { false };
>+ bool m_hasBegunDeletingDetachedChildren { false };
> ShadowRootMode m_type { ShadowRootMode::UserAgent };
> 
> Element* m_host { nullptr };
>Index: Source/WebCore/dom/SlotAssignment.cpp
>===================================================================
>--- Source/WebCore/dom/SlotAssignment.cpp	(revision 235581)
>+++ Source/WebCore/dom/SlotAssignment.cpp	(working copy)
>@@ -64,6 +64,20 @@
> return findFirstSlotElement(*slot, shadowRoot);
> }
> 
>+void SlotAssignment::renameSlotElement(HTMLSlotElement& slotElement, const AtomicString& oldName, const AtomicString& newName, ShadowRoot& shadowRoot)
>+{
>+ m_slotMutationVersion++;
>+ removeSlotElementByName(oldName, slotElement, nullptr, shadowRoot);
>+ addSlotElementByName(newName, slotElement, shadowRoot);
>+}
>+
>+inline bool SlotAssignment::hasAssignedNodes(ShadowRoot& shadowRoot, Slot& slot)
>+{
>+ if (!m_slotAssignmentsIsValid)
>+ assignSlots(shadowRoot);
>+ return !slot.assignedNodes.isEmpty();
>+}
>+
> void SlotAssignment::addSlotElementByName(const AtomicString& name, HTMLSlotElement& slotElement, ShadowRoot& shadowRoot)
> {
> #ifndef NDEBUG
>@@ -83,21 +97,52 @@
> 
> return std::make_unique<Slot>();
> });
>+ auto& slot = *addResult.iterator->value;
>+ bool needsSlotchangeEvent = shadowRoot.shouldFireSlotchangeEvent() && hasAssignedNodes(shadowRoot, slot);
> 
>- auto& slot = *addResult.iterator->value;
>- if (!slot.hasSlotElements())
>+ slot.elementCount++;
>+ if (slot.elementCount == 1) {
> slot.element = makeWeakPtr(slotElement);
>- else {
>+ if (needsSlotchangeEvent)
>+ slotElement.enqueueSlotChangeEvent();
>+ return;
>+ }
>+
>+ if (!needsSlotchangeEvent) {
>+ ASSERT(slot.element || m_needsToResolveSlotElements);
> slot.element = nullptr;
>-#ifndef NDEBUG
> m_needsToResolveSlotElements = true;
>-#endif
>+ return;
> }
>- slot.elementCount++;
>+
>+ resolveSlotsAfterSlotMutation(shadowRoot, nullptr, SlotMutationType::Insertion);
> }
> 
>-void SlotAssignment::removeSlotElementByName(const AtomicString& name, HTMLSlotElement& slotElement, ShadowRoot& shadowRoot)
>+#if !ASSERT_DISABLED
>+static HTMLSlotElement* findSlotElement(ShadowRoot& shadowRoot, const AtomicString& slotName)
> {
>+ for (auto& slotElement : descendantsOfType<HTMLSlotElement>(shadowRoot)) {
>+ if (slotNameFromAttributeValue(slotElement.attributeWithoutSynchronization(nameAttr)) == slotName)
>+ return &slotElement;
>+ }
>+ return nullptr;
>+}
>+#endif
>+
>+static HTMLSlotElement* nextSlotElementSkippingSubtree(ContainerNode& startingNode, ContainerNode* skippedSubtree)
>+{
>+ Node* node = &startingNode;
>+ do {
>+ if (UNLIKELY(node == skippedSubtree))
>+ node = NodeTraversal::nextSkippingChildren(*node);
>+ else
>+ node = NodeTraversal::next(*node);
>+ } while (node && !is<HTMLSlotElement>(node));
>+ return downcast<HTMLSlotElement>(node);
>+}
>+
>+void SlotAssignment::removeSlotElementByName(const AtomicString& name, HTMLSlotElement& slotElement, ContainerNode* oldParentOfRemovedTree, ShadowRoot& shadowRoot)
>+{
> #ifndef NDEBUG
> ASSERT(m_slotElementsForConsistencyCheck.contains(&slotElement));
> m_slotElementsForConsistencyCheck.remove(&slotElement);
>@@ -108,15 +153,107 @@
> 
> auto* slot = m_slots.get(slotNameFromAttributeValue(name));
> RELEASE_ASSERT(slot && slot->hasSlotElements());
>+ bool needsSlotchangeEvent = shadowRoot.shouldFireSlotchangeEvent() && hasAssignedNodes(shadowRoot, *slot);
> 
> slot->elementCount--;
>- if (slot->element == &slotElement) {
>+ if (!slot->elementCount) {
> slot->element = nullptr;
>-#ifndef NDEBUG
>+ if (needsSlotchangeEvent && m_slotResolutionVersion != m_slotMutationVersion)
>+ slotElement.enqueueSlotChangeEvent();
>+ return;
>+ }
>+
>+ if (!needsSlotchangeEvent) {
>+ ASSERT(slot->element || m_needsToResolveSlotElements);
>+ slot->element = nullptr;
> m_needsToResolveSlotElements = true;
>+ return;
>+ }
>+
>+ if (!slot->element) // A previous invocation to resolveSlotsAfterSlotMutation during this removal has updated this slot.
>+ ASSERT(m_slotResolutionVersion == m_slotMutationVersion && !findSlotElement(shadowRoot, name));
>+ else {
>+ resolveSlotsAfterSlotMutation(shadowRoot, m_willBeRemovingAllChildren ? oldParentOfRemovedTree : nullptr,
>+ oldParentOfRemovedTree ? SlotMutationType::Removal : SlotMutationType::Insertion);
>+ }
>+
>+ if (slot->oldElement == &slotElement) {
>+ slotElement.enqueueSlotChangeEvent();
>+ slot->oldElement = nullptr;
>+ }
>+}
>+
>+void SlotAssignment::resolveSlotsAfterSlotMutation(ShadowRoot& shadowRoot, ContainerNode* subtreeToSkip, SlotMutationType mutationType)
>+{
>+ if (m_slotResolutionVersion == m_slotMutationVersion)
>+ return;
>+ m_slotResolutionVersion = m_slotMutationVersion;
>+
>+ ASSERT(!subtreeToSkip || mutationType == SlotMutationType::Removal);
>+ m_needsToResolveSlotElements = false;
>+
>+ for (auto& slot : m_slots.values())
>+ slot->seenFirstElement = false;
>+
>+ unsigned slotCount = 0;
>+ HTMLSlotElement* nextSlotElement = nextSlotElementSkippingSubtree(shadowRoot, subtreeToSkip);
>+ for (; nextSlotElement; nextSlotElement = nextSlotElementSkippingSubtree(*nextSlotElement, subtreeToSkip)) {
>+ auto& curentElement = *nextSlotElement;
>+ auto& currentSlotName = slotNameFromAttributeValue(curentElement.attributeWithoutSynchronization(nameAttr));
>+ auto* currentSlot = m_slots.get(currentSlotName);
>+ if (!currentSlot) {
>+ // A new slot may have been inserted with this node but appears later in the tree order.
>+ // Such a slot would go through the fast path in addSlotElementByName,
>+ // and any subsequently inserted slot of the same name would not result in any slotchange or invokation of this function.
>+ ASSERT(mutationType == SlotMutationType::Insertion);
>+ continue;
>+ }
>+ if (currentSlot->seenFirstElement) {
>+ if (mutationType == SlotMutationType::Insertion && currentSlot->oldElement == &curentElement) {
>+ curentElement.enqueueSlotChangeEvent();
>+ currentSlot->oldElement = nullptr;
>+ }
>+ continue;
>+ }
>+ currentSlot->seenFirstElement = true;
>+ slotCount++;
>+ ASSERT(currentSlot->element);
>+ if (currentSlot->element != &curentElement) {
>+ if (hasAssignedNodes(shadowRoot, *currentSlot)) {
>+ currentSlot->oldElement = WTFMove(currentSlot->element);
>+ curentElement.enqueueSlotChangeEvent();
>+ }
>+ currentSlot->element = makeWeakPtr(curentElement);
>+ }
>+ }
>+
>+ if (slotCount == m_slots.size())
>+ return;
>+
>+ if (mutationType == SlotMutationType::Insertion) {
>+ // This code path is taken only when continue above for !currentSlot is taken.
>+ // i.e. there is a new slot being inserted into the tree but we have yet to invoke addSlotElementByName on it.
>+#if !ASSERT_DISABLED
>+ for (auto& entry : m_slots)
>+ ASSERT(entry.value->seenFirstElement || !findSlotElement(shadowRoot, entry.key));
> #endif
>+ return;
> }
>- ASSERT(slot->element || m_needsToResolveSlotElements);
>+
>+ for (auto& slot : m_slots.values()) {
>+ if (slot->seenFirstElement)
>+ continue;
>+ if (!slot->elementCount) { // Taken the fast path for removal.
>+ ASSERT(!slot->element);
>+ continue;
>+ }
>+ // All slot elements have been removed for this slot.
>+ slot->seenFirstElement = true;
>+ ASSERT(slot->element);
>+ if (hasAssignedNodes(shadowRoot, *slot))
>+ slot->oldElement = WTFMove(slot->element);
>+ slot->element = nullptr;
>+ }
> }
> 
> void SlotAssignment::slotFallbackDidChange(HTMLSlotElement& slotElement, ShadowRoot& shadowRoot)
>@@ -129,6 +266,23 @@
> slotElement.enqueueSlotChangeEvent();
> }
> 
>+void SlotAssignment::resolveSlotsBeforeNodeInsertionOrRemoval(ShadowRoot& shadowRoot)
>+{
>+ ASSERT(shadowRoot.shouldFireSlotchangeEvent());
>+ m_slotMutationVersion++;
>+ m_willBeRemovingAllChildren = false;
>+ if (m_needsToResolveSlotElements)
>+ resolveAllSlotElements(shadowRoot);
>+}
>+
>+void SlotAssignment::willRemoveAllChildren(ShadowRoot& shadowRoot)
>+{
>+ m_slotMutationVersion++;
>+ m_willBeRemovingAllChildren = true;
>+ if (m_needsToResolveSlotElements)
>+ resolveAllSlotElements(shadowRoot);
>+}
>+
> void SlotAssignment::didChangeSlot(const AtomicString& slotAttrValue, ShadowRoot& shadowRoot)
> {
> auto& slotName = slotNameFromAttributeValue(slotAttrValue);
>@@ -145,10 +299,8 @@
> 
> shadowRoot.host()->invalidateStyleAndRenderersForSubtree();
> 
>- if (shadowRoot.mode() == ShadowRootMode::UserAgent)
>- return;
>-
>- slotElement->enqueueSlotChangeEvent();
>+ if (shadowRoot.shouldFireSlotchangeEvent())
>+ slotElement->enqueueSlotChangeEvent();
> }
> 
> void SlotAssignment::hostChildElementDidChange(const Element& childElement, ShadowRoot& shadowRoot)
>@@ -196,14 +348,12 @@
> 
> void SlotAssignment::resolveAllSlotElements(ShadowRoot& shadowRoot)
> {
>-#ifndef NDEBUG
> ASSERT(m_needsToResolveSlotElements);
> m_needsToResolveSlotElements = false;
>-#endif
> 
> // FIXME: It's inefficient to reset all values. We should be able to void this in common case.
> for (auto& entry : m_slots)
>- entry.value->element = nullptr;
>+ entry.value->seenFirstElement = false;
> 
> unsigned slotCount = m_slots.size();
> for (auto& slotElement : descendantsOfType<HTMLSlotElement>(shadowRoot)) {
>@@ -212,9 +362,9 @@
> auto* slot = m_slots.get(slotName);
> RELEASE_ASSERT(slot); // slot must have been created when a slot was inserted.
> 
>- bool hasSeenSlotWithSameName = !!slot->element;
>- if (hasSeenSlotWithSameName)
>+ if (slot->seenFirstElement)
> continue;
>+ slot->seenFirstElement = true;
> 
> slot->element = makeWeakPtr(slotElement);
> slotCount--;
>Index: Source/WebCore/dom/SlotAssignment.h
>===================================================================
>--- Source/WebCore/dom/SlotAssignment.h	(revision 235581)
>+++ Source/WebCore/dom/SlotAssignment.h	(working copy)
>@@ -50,9 +50,12 @@
> 
> HTMLSlotElement* findAssignedSlot(const Node&, ShadowRoot&);
> 
>+ void renameSlotElement(HTMLSlotElement&, const AtomicString& oldName, const AtomicString& newName, ShadowRoot&);
> void addSlotElementByName(const AtomicString&, HTMLSlotElement&, ShadowRoot&);
>- void removeSlotElementByName(const AtomicString&, HTMLSlotElement&, ShadowRoot&);
>+ void removeSlotElementByName(const AtomicString&, HTMLSlotElement&, ContainerNode* oldParentOfRemovedTree, ShadowRoot&);
> void slotFallbackDidChange(HTMLSlotElement&, ShadowRoot&);
>+ void resolveSlotsBeforeNodeInsertionOrRemoval(ShadowRoot&);
>+ void willRemoveAllChildren(ShadowRoot&);
> 
> void didChangeSlot(const AtomicString&, ShadowRoot&);
> void enqueueSlotChangeEvent(const AtomicString&, ShadowRoot&);
>@@ -72,10 +75,16 @@
> bool shouldResolveSlotElement() { return !element && elementCount; }
> 
> WeakPtr<HTMLSlotElement> element;
>+ WeakPtr<HTMLSlotElement> oldElement;
> unsigned elementCount { 0 };
>+ bool seenFirstElement { false };
> Vector<Node*> assignedNodes;
> };
>- 
>+
>+ bool hasAssignedNodes(ShadowRoot&, Slot&);
>+ enum class SlotMutationType { Insertion, Removal };
>+ void resolveSlotsAfterSlotMutation(ShadowRoot&, ContainerNode* oldParentOfRemovedTree, SlotMutationType);
>+
> virtual const AtomicString& slotNameForHostChild(const Node&) const;
> 
> HTMLSlotElement* findFirstSlotElement(Slot&, ShadowRoot&);
>@@ -88,12 +97,27 @@
> 
> #ifndef NDEBUG
> HashSet<HTMLSlotElement*> m_slotElementsForConsistencyCheck;
>- bool m_needsToResolveSlotElements { false };
> #endif
> 
>+ bool m_needsToResolveSlotElements { false };
> bool m_slotAssignmentsIsValid { false };
>+ bool m_willBeRemovingAllChildren { false };
>+ unsigned m_slotMutationVersion { 0 };
>+ unsigned m_slotResolutionVersion { 0 };
> };
> 
>+inline void ShadowRoot::resolveSlotsBeforeNodeInsertionOrRemoval()
>+{
>+ if (UNLIKELY(shouldFireSlotchangeEvent() && m_slotAssignment))
>+ m_slotAssignment->resolveSlotsBeforeNodeInsertionOrRemoval(*this);
>+}
>+
>+inline void ShadowRoot::willRemoveAllChildren(ContainerNode&)
>+{
>+ if (UNLIKELY(shouldFireSlotchangeEvent() && m_slotAssignment))
>+ m_slotAssignment->willRemoveAllChildren(*this);
>+}
>+
> inline void ShadowRoot::didRemoveAllChildrenOfShadowHost()
> {
> if (m_slotAssignment) // FIXME: This is incorrect when there were no elements or text nodes removed.
>Index: Source/WebCore/html/HTMLSlotElement.cpp
>===================================================================
>--- Source/WebCore/html/HTMLSlotElement.cpp	(revision 235581)
>+++ Source/WebCore/html/HTMLSlotElement.cpp	(working copy)
>@@ -69,7 +69,7 @@
> if (removalType.treeScopeChanged && oldParentOfRemovedTree.isInShadowTree()) {
> auto* oldShadowRoot = oldParentOfRemovedTree.containingShadowRoot();
> ASSERT(oldShadowRoot);
>- oldShadowRoot->removeSlotElementByName(attributeWithoutSynchronization(nameAttr), *this);
>+ oldShadowRoot->removeSlotElementByName(attributeWithoutSynchronization(nameAttr), *this, oldParentOfRemovedTree);
> }
> 
> HTMLElement::removedFromAncestor(removalType, oldParentOfRemovedTree);
>@@ -90,10 +90,8 @@
> HTMLElement::attributeChanged(name, oldValue, newValue, reason);
> 
> if (isInShadowTree() && name == nameAttr) {
>- if (auto shadowRoot = makeRefPtr(containingShadowRoot())) {
>- shadowRoot->removeSlotElementByName(oldValue, *this);
>- shadowRoot->addSlotElementByName(newValue, *this);
>- }
>+ if (auto shadowRoot = makeRefPtr(containingShadowRoot()))
>+ shadowRoot->renameSlotElement(*this, oldValue, newValue);
> }
> }
> 
>Index: LayoutTests/fast/shadow-dom/slotchange-for-slot-mutation-expected.txt
>===================================================================
>--- LayoutTests/fast/shadow-dom/slotchange-for-slot-mutation-expected.txt	(nonexistent)
>+++ LayoutTests/fast/shadow-dom/slotchange-for-slot-mutation-expected.txt	(working copy)
>@@ -0,0 +1,61 @@
>+
>+PASS slotchange event should not fire when inserting a default slot element into a shadow host with no children in a disconnected open mode shadow root 
>+PASS slotchange event should not fire when inserting a named slot element into a shadow host with no children in a disconnected open mode shadow root 
>+PASS slotchange event should not fire when inserting a default slot element when there is an element assigned to another slot in a disconnected open mode shadow root 
>+PASS slotchange event should fire when inserting a default slot element when there is an element assigned to the default slot in a disconnected open mode shadow root 
>+PASS slotchange event should fire when inserting a default slot element when there is a Text node assigned to the default slot in a disconnected open mode shadow root 
>+PASS slotchange event should not fire when inserting a named slot element when there is an element assigned to another slot in a disconnected open mode shadow root 
>+PASS slotchange event should not fire when inserting a named slot element when there is an element assigned to the default slot in a disconnected open mode shadow root 
>+PASS slotchange event should fire when inserting a named slot element when there is an element assigned to the slot in a disconnected open mode shadow root 
>+PASS slotchange event should not fire when inserting a named slot element when there is a Text node assigned to the default slot in a disconnected open mode shadow root 
>+PASS slotchange event should not fire when inserting a default slot element after an existing default slot in a disconnected open mode shadow root 
>+PASS slotchange event should fire when inserting a default slot element before an existing default slot in the tree order in a disconnected open mode shadow root 
>+PASS slotchange event should not fire when inserting a default slot element between two existing default slots in a disconnected open mode shadow root 
>+PASS slotchange event should not fire when inserting a named slot element after an existing slot of the same name in a disconnected open mode shadow root 
>+PASS slotchange event should fire when inserting a named slot element before an existing slot of the same name in the tree order in a disconnected open mode shadow root 
>+PASS slotchange event should not fire when inserting a named slot element between two existing slots of the same name in a disconnected open mode shadow root 
>+PASS slotchange event should fire when inserting the ancestor of a default slot element before an existing default slot in the tree order in a disconnected open mode shadow root 
>+PASS slotchange event should fire when inserting the ancestor of a named slot element before an existing named slot element in the tree order in a disconnected open mode shadow root 
>+PASS slotchange event should fire on the first default slot inserted in the tree order in a disconnected open mode shadow root 
>+PASS slotchange event should fire on the first named slot inserted in the tree order in a disconnected open mode shadow root 
>+PASS slotchange event should fire on the first named slot of the same name inserted in the tree order in a disconnected open mode shadow root 
>+PASS slotchange event should fire when inserting a named slot element before an existing slot of the same name before a default slot in the tree order in a disconnected open mode shadow root 
>+PASS slotchange event should fire on all newly inserted slots with assigned nodes and their previously-first counterparts in the tree order in a disconnected open mode shadow root 
>+PASS slotchange event should fire on all newly inserted slots with assigned nodes but not on those without in the tree order in a disconnected open mode shadow root 
>+PASS slotchange event should not fire when removing a default slot element into a shadow host with no children in a disconnected open mode shadow root 
>+PASS slotchange event should not fire when removing a named slot element into a shadow host with no children in a disconnected open mode shadow root 
>+PASS slotchange event should not fire when removing a default slot element when there is an element assigned to another slot in a disconnected open mode shadow root 
>+PASS slotchange event should fire when removing a default slot element when there is an element assigned to the default slot in a disconnected open mode shadow root 
>+PASS slotchange event should fire when removing a default slot element when there is a Text node assigned to the default slot in a disconnected open mode shadow root 
>+PASS slotchange event should not fire when removing a named slot element when there is an element assigned to another slot in a disconnected open mode shadow root 
>+PASS slotchange event should not fire when removing a named slot element when there is an element assigned to the default slot in a disconnected open mode shadow root 
>+PASS slotchange event should fire when removing a named slot element when there is an element assigned to the slot in a disconnected open mode shadow root 
>+PASS slotchange event should not fire when removing a named slot element when there is a Text node assigned to the default slot in a disconnected open mode shadow root 
>+PASS slotchange event should not fire when removing a default slot element after an existing default slot in a disconnected open mode shadow root 
>+PASS slotchange event should fire when removing the first default slot element even if it had duplicates in a disconnected open mode shadow root 
>+PASS slotchange event should not fire when removing a duplicate default slot, which is the first child of a default slot element in a disconnected open mode shadow root 
>+PASS slotchange event should not fire when removing a named slot element after an existing named slot of the same name in a disconnected open mode shadow root 
>+PASS slotchange event should fire when removing the first named slot element even if it had duplicates in a disconnected open mode shadow root 
>+PASS slotchange event should not fire when removing a duplicate named slot, which is the first child of a named slot element of the same name in a disconnected open mode shadow root 
>+PASS slotchange event should fire when removing the ancestor of a default slot element before another default slot in the tree order in a disconnected open mode shadow root 
>+PASS slotchange event should fire when removing the ancestor of a named slot element before another slot of the same name in the tree order in a disconnected open mode shadow root 
>+PASS slotchange event should fire on the first default slot removed in the tree order in a disconnected open mode shadow root 
>+PASS slotchange event should fire on the first named slot removed in the tree order in a disconnected open mode shadow root 
>+PASS slotchange event should fire on the first default slot removed in the tree order when replacing all children in a disconnected open mode shadow root 
>+PASS slotchange event should fire on the first default slot removed in the tree order when replacing all children in a disconnected open mode shadow root 
>+PASS slotchange event should fire on the first named slot of the same name removed in the tree order in a disconnected open mode shadow root 
>+PASS slotchange event should fire when inserting a named slot element before an existing slot of the same name before a default slot in the tree order in a disconnected open mode shadow root 
>+PASS slotchange event should fire on all first slots of its kind with assigned nodes and their previously-first counterparts in the tree order in a disconnected open mode shadow root 
>+PASS slotchange event should fire on all removed slots with assigned nodes but not on those without in the tree order in a disconnected open mode shadow root 
>+PASS slotchange event should not fire when renaming a default slot element to a named slot when there are no assigned nodes in a disconnected open mode shadow root 
>+PASS slotchange event should fire when renaming a default slot element to a named slot when there is an assigned node to the named slot in a disconnected open mode shadow root 
>+PASS slotchange event should fire when renaming a default slot element to a named slot when there is an assigned node to the default slot in a disconnected open mode shadow root 
>+PASS slotchange event should not fire when renaming a named slot element to a default slot when there are no assigned nodes in a disconnected open mode shadow root 
>+PASS slotchange event should fire when renaming a named slot element to a default slot when there is a node assigned to the default slot in a disconnected open mode shadow root 
>+PASS slotchange event should fire when renaming a named slot element to a default slot when there is a node assigned to the named slot in a disconnected open mode shadow root 
>+PASS slotchange event should not fire when renaming a named slot element when there are no assigned nodes in a disconnected open mode shadow root 
>+PASS slotchange event should fire when renaming a named slot element when there is an assigned node to the slot of the new name in a disconnected open mode shadow root 
>+PASS slotchange event should fire when renaming a named slot element when there is an assigned node to the slot of the old name in a disconnected open mode shadow root 
>+PASS slotchange event should not fire when renaming the second slot element of a given name and there is no assigned node of the new name in a disconnected open mode shadow root 
>+FAIL slotchange event should fire when renaming the slot element of a given name and there is an assigned node and a second slot element in a disconnected open mode shadow root assert_array_equals: property 0, expected "slot1" but got "slot2"
>+
>Index: LayoutTests/fast/shadow-dom/slotchange-for-slot-mutation.html
>===================================================================
>--- LayoutTests/fast/shadow-dom/slotchange-for-slot-mutation.html	(nonexistent)
>+++ LayoutTests/fast/shadow-dom/slotchange-for-slot-mutation.html	(working copy)
>@@ -0,0 +1,295 @@
>+<!DOCTYPE html>
>+<html>
>+<head>
>+<title>Shadow DOM: slotchange event when inserting or removing a slot element</title>
>+<meta name="author" title="Ryosuke Niwa" href="mailto:rniwa@webkit.org">
>+<link rel="help" href="https://dom.spec.whatwg.org/#signaling-slot-change">
>+<link rel="help" href="https://dom.spec.whatwg.org/#concept-node-insert">
>+<script src="../../resources/testharness.js"></script>
>+<script src="../../resources/testharnessreport.js"></script>
>+</head>
>+<body>
>+<div id="log"></div>
>+<script>
>+
>+function generateTests(...args) {
>+/* testMutatingSlot('closed', true, ...args);
>+ testMutatingSlot('closed', false, ...args);
>+ testMutatingSlot('open', true, ...args);*/
>+ testMutatingSlot('open', false, ...args);
>+}
>+
>+let slotchangeEventTargets;
>+function testMutatingSlot(mode, connectedToDocument, hostContent, shadowContent, mutateSlot, expectedTargets, description)
>+{
>+ promise_test(async function () {
>+ const host = document.createElement('div');
>+ if (connectedToDocument)
>+ document.body.appendChild(host);
>+ if (hostContent)
>+ host.innerHTML = hostContent;
>+
>+ const shadowRoot = host.attachShadow({mode});
>+ slotchangeEventTargets = [];
>+ if (shadowContent) {
>+ shadowRoot.innerHTML = shadowContent;
>+ addEventListners(shadowRoot);
>+ }
>+
>+ await Promise.resolve();
>+ slotchangeEventTargets.length = 0;
>+
>+ mutateSlot(shadowRoot);
>+ await Promise.resolve();
>+
>+ assert_array_equals(slotchangeEventTargets, expectedTargets);
>+
>+ host.remove();
>+ }, description + ` in a ${connectedToDocument ? 'connected' : 'disconnected'} ${mode} mode shadow root`);
>+}
>+
>+function addEventListners(container)
>+{
>+ for (const existingSlots of container.querySelectorAll('slot'))
>+ existingSlots.addEventListener('slotchange', (event) => slotchangeEventTargets.push(event.target.id));
>+}
>+
>+function newSlot(slotName)
>+{
>+ const slot = document.createElement('slot');
>+ slot.id = 'newSlot';
>+ if (slotName)
>+ slot.name = slotName;
>+ slot.addEventListener('slotchange', (event) => slotchangeEventTargets.push(event.target.id));
>+ return slot;
>+}
>+
>+// Insertions
>+
>+generateTests(null, null, (shadowRoot) => shadowRoot.append(newSlot()), [],
>+ 'slotchange event should not fire when inserting a default slot element into a shadow host with no children');
>+generateTests(null, null, (shadowRoot) => shadowRoot.append(newSlot('foo')), [],
>+ 'slotchange event should not fire when inserting a named slot element into a shadow host with no children');
>+
>+generateTests('', null, (shadowRoot) => shadowRoot.append(newSlot()), [],
>+ 'slotchange event should not fire when inserting a default slot element when there is an element assigned to another slot');
>+generateTests('', null, (shadowRoot) => shadowRoot.append(newSlot()), ['newSlot'],
>+ 'slotchange event should fire when inserting a default slot element when there is an element assigned to the default slot');
>+generateTests('hello', null, (shadowRoot) => shadowRoot.append(newSlot()), ['newSlot'],
>+ 'slotchange event should fire when inserting a default slot element when there is a Text node assigned to the default slot');
>+
>+generateTests('', null, (shadowRoot) => shadowRoot.append(newSlot('foo')), [],
>+ 'slotchange event should not fire when inserting a named slot element when there is an element assigned to another slot');
>+generateTests('', null, (shadowRoot) => shadowRoot.append(newSlot('foo')), [],
>+ 'slotchange event should not fire when inserting a named slot element when there is an element assigned to the default slot');
>+generateTests('', null, (shadowRoot) => shadowRoot.append(newSlot('foo')), ['newSlot'],
>+ 'slotchange event should fire when inserting a named slot element when there is an element assigned to the slot');
>+generateTests('hello', null, (shadowRoot) => shadowRoot.append(newSlot('foo')), [],
>+ 'slotchange event should not fire when inserting a named slot element when there is a Text node assigned to the default slot');
>+
>+generateTests('', '<slot id="oldSlot"></slot>',
>+ (shadowRoot) => shadowRoot.append(newSlot()), [],
>+ 'slotchange event should not fire when inserting a default slot element after an existing default slot');
>+generateTests('', '<slot id="oldSlot"></slot>',
>+ (shadowRoot) => shadowRoot.prepend(newSlot()), ['newSlot', 'oldSlot'],
>+ 'slotchange event should fire when inserting a default slot element before an existing default slot in the tree order');
>+generateTests('', '<slot id="oldSlot1"></slot><slot id="oldSlot2"></slot>',
>+ (shadowRoot) => shadowRoot.firstChild.after(newSlot()), [],
>+ 'slotchange event should not fire when inserting a default slot element between two existing default slots');
>+
>+generateTests('', '<slot id="oldSlot" name="foo"></slot>',
>+ (shadowRoot) => shadowRoot.append(newSlot('foo')), [],
>+ 'slotchange event should not fire when inserting a named slot element after an existing slot of the same name');
>+generateTests('', '<slot id="oldSlot" name="foo"></slot>',
>+ (shadowRoot) => shadowRoot.prepend(newSlot('foo')), ['newSlot', 'oldSlot'],
>+ 'slotchange event should fire when inserting a named slot element before an existing slot of the same name in the tree order');
>+generateTests('', '<slot id="oldSlot1" name="foo"></slot><slot id="oldSlot2" name="foo"></slot>',
>+ (shadowRoot) => shadowRoot.firstChild.after(newSlot('foo')), [],
>+ 'slotchange event should not fire when inserting a named slot element between two existing slots of the same name');
>+
>+generateTests('', '<div><slot id="oldSlot"></slot></div>',
>+ (shadowRoot) => {
>+ const ancestor = document.createElement('div');
>+ ancestor.innerHTML = '<slot id="newSlot"></slot>';
>+ addEventListners(ancestor);
>+ shadowRoot.prepend(ancestor);
>+ }, ['newSlot', 'oldSlot'],
>+ 'slotchange event should fire when inserting the ancestor of a default slot element before an existing default slot in the tree order');
>+generateTests('', '<div><slot name="foo" id="oldSlot"></slot></div>',
>+ (shadowRoot) => {
>+ const ancestor = document.createElement('div');
>+ ancestor.innerHTML = '<slot id="newSlot" name="foo"></slot>';
>+ addEventListners(ancestor);
>+ shadowRoot.prepend(ancestor);
>+ }, ['newSlot', 'oldSlot'],
>+ 'slotchange event should fire when inserting the ancestor of a named slot element before an existing named slot element in the tree order');
>+
>+generateTests('', null,
>+ (shadowRoot) => {
>+ const ancestor = document.createElement('div');
>+ ancestor.innerHTML = '<slot id="slot1"></slot><slot id="slot2"></slot><slot id="slot3"></slot>';
>+ addEventListners(ancestor);
>+ shadowRoot.append(ancestor);
>+ }, ['slot1'],
>+ 'slotchange event should fire on the first default slot inserted in the tree order');
>+generateTests('', null,
>+ (shadowRoot) => {
>+ const ancestor = document.createElement('div');
>+ ancestor.innerHTML = '<slot id="slot1" name="foo"></slot><slot id="slot2" name="foo"></slot><slot id="slot3" name="foo"></slot>';
>+ addEventListners(ancestor);
>+ shadowRoot.append(ancestor);
>+ }, ['slot1'],
>+ 'slotchange event should fire on the first named slot inserted in the tree order');
>+
>+generateTests('', null,
>+ (shadowRoot) => {
>+ const ancestor = document.createElement('div');
>+ ancestor.innerHTML = '<slot id="slot1" name="a"></slot><slot id="slot2" name="b"></slot><slot id="slot3" name="b"></slot>';
>+ addEventListners(ancestor);
>+ shadowRoot.append(ancestor);
>+ }, ['slot2'],
>+ 'slotchange event should fire on the first named slot of the same name inserted in the tree order');
>+
>+generateTests('', '<slot id="oldSlot" name="a"></slot><slot></slot>',
>+ (shadowRoot) => shadowRoot.prepend(newSlot('a')), ['newSlot', 'oldSlot'],
>+ 'slotchange event should fire when inserting a named slot element before an existing slot of the same name before a default slot in the tree order');
>+
>+generateTests('', '<slot id="oldDefault"></slot><slot id="oldA" name="a"></slot>',
>+ (shadowRoot) => {
>+ const ancestor = document.createElement('div');
>+ ancestor.innerHTML = `<slot id="newDefault1"></slot><slot id="newDefault2"></slot><slot id="newB" name="b"></slot><slot id="newA" name="a"></slot>`;
>+ addEventListners(ancestor);
>+ shadowRoot.prepend(ancestor);
>+ }, ['newDefault1', 'newA', 'oldDefault', 'oldA'],
>+ 'slotchange event should fire on all newly inserted slots with assigned nodes and their previously-first counterparts in the tree order');
>+
>+generateTests('', '<slot id="oldDefault"></slot><slot id="oldA" name="a"></slot><slot id="oldB" name="b"></slot>',
>+ (shadowRoot) => {
>+ const ancestor = document.createElement('div');
>+ ancestor.innerHTML = `<slot id="newDefault1"></slot><slot id="newDefault2"></slot><slot id="newB" name="b"></slot><slot id="newA" name="a"></slot>`;
>+ addEventListners(ancestor);
>+ shadowRoot.prepend(ancestor);
>+ }, ['newDefault1', 'newA', 'oldDefault', 'oldA'],
>+ 'slotchange event should fire on all newly inserted slots with assigned nodes but not on those without in the tree order');
>+
>+
>+// Removals
>+
>+generateTests(null, '<slot id="oldSlot"></slot>', (shadowRoot) => shadowRoot.querySelector('slot').remove(), [],
>+ 'slotchange event should not fire when removing a default slot element into a shadow host with no children');
>+generateTests(null, '<slot id="oldSlot" name="foo"></slot>', (shadowRoot) => shadowRoot.querySelector('slot').remove(), [],
>+ 'slotchange event should not fire when removing a named slot element into a shadow host with no children');
>+
>+generateTests('', '<slot id="oldSlot"></slot>', (shadowRoot) => shadowRoot.querySelector('slot').remove(), [],
>+ 'slotchange event should not fire when removing a default slot element when there is an element assigned to another slot');
>+generateTests('', '<slot id="oldSlot"></slot>', (shadowRoot) => shadowRoot.querySelector('slot').remove(), ['oldSlot'],
>+ 'slotchange event should fire when removing a default slot element when there is an element assigned to the default slot');
>+generateTests('hello', '<slot id="oldSlot"></slot>', (shadowRoot) => shadowRoot.querySelector('slot').remove(), ['oldSlot'],
>+ 'slotchange event should fire when removing a default slot element when there is a Text node assigned to the default slot');
>+
>+generateTests('', '<slot id="oldSlot" name="foo"></slot>', (shadowRoot) => shadowRoot.querySelector('slot').remove(), [],
>+ 'slotchange event should not fire when removing a named slot element when there is an element assigned to another slot');
>+generateTests('', '<slot id="oldSlot" name="foo"></slot>', (shadowRoot) => shadowRoot.querySelector('slot').remove(), [],
>+ 'slotchange event should not fire when removing a named slot element when there is an element assigned to the default slot');
>+generateTests('', '<slot id="oldSlot" name="foo"></slot>', (shadowRoot) => shadowRoot.querySelector('slot').remove(), ['oldSlot'],
>+ 'slotchange event should fire when removing a named slot element when there is an element assigned to the slot');
>+generateTests('hello', '<slot id="oldSlot" name="foo"></slot>', (shadowRoot) => shadowRoot.querySelector('slot').remove(), [],
>+ 'slotchange event should not fire when removing a named slot element when there is a Text node assigned to the default slot');
>+
>+generateTests('', '<slot id="slot1"></slot><slot id="slot2"></slot>',
>+ (shadowRoot) => shadowRoot.getElementById('slot2').remove(), [],
>+ 'slotchange event should not fire when removing a default slot element after an existing default slot');
>+generateTests('', '<slot id="slot1"></slot><slot id="slot2"></slot>',
>+ (shadowRoot) => shadowRoot.getElementById('slot1').remove(), ['slot2', 'slot1'],
>+ 'slotchange event should fire when removing the first default slot element even if it had duplicates');
>+generateTests('', '<slot id="slot1"><slot id="slot2"></slot></slot><slot id="slot3"></slot>',
>+ (shadowRoot) => shadowRoot.getElementById('slot2').remove(), [],
>+ 'slotchange event should not fire when removing a duplicate default slot, which is the first child of a default slot element');
>+
>+generateTests('', '<slot id="slot1" name="foo"></slot><slot id="slot2" name="foo"></slot>',
>+ (shadowRoot) => shadowRoot.getElementById('slot2').remove(), [],
>+ 'slotchange event should not fire when removing a named slot element after an existing named slot of the same name');
>+generateTests('', '<slot id="slot1" name="foo"></slot><slot id="slot2" name="foo"></slot>',
>+ (shadowRoot) => shadowRoot.getElementById('slot1').remove(), ['slot2', 'slot1'],
>+ 'slotchange event should fire when removing the first named slot element even if it had duplicates');
>+generateTests('', '<slot id="slot1" name="foo"><slot id="slot2" name="foo"></slot></slot><slot id="slot3" name="foo"></slot>',
>+ (shadowRoot) => shadowRoot.getElementById('slot2').remove(), [],
>+ 'slotchange event should not fire when removing a duplicate named slot, which is the first child of a named slot element of the same name');
>+
>+generateTests('', '<div><slot id="slot1"></slot></div><slot id="slot2"></slot>',
>+ (shadowRoot) => shadowRoot.querySelector('div').remove(), ['slot2', 'slot1'],
>+ 'slotchange event should fire when removing the ancestor of a default slot element before another default slot in the tree order');
>+generateTests('', '<div><slot id="slot1"></slot></div><slot id="slot2"></slot>',
>+ (shadowRoot) => shadowRoot.querySelector('div').remove(), ['slot2', 'slot1'],
>+ 'slotchange event should fire when removing the ancestor of a named slot element before another slot of the same name in the tree order');
>+
>+generateTests('', '<div><slot id="slot1"></slot><slot id="slot2"></slot><slot id="slot3"></slot></div>',
>+ (shadowRoot) => shadowRoot.querySelector('p').remove(), ['slot1'],
>+ 'slotchange event should fire on the first default slot removed in the tree order');
>+generateTests('',
>+ '<div><slot id="slot1" name="foo"></slot><slot id="slot2" name="foo"></slot><slot id="slot3" name="foo"></slot></div>',
>+ (shadowRoot) => shadowRoot.querySelector('p').remove(), ['slot1'],
>+ 'slotchange event should fire on the first named slot removed in the tree order');
>+
>+generateTests('', '<div><slot id="slot1"></slot><slot id="slot2"></slot><slot id="slot3"></slot></div>',
>+ (shadowRoot) => shadowRoot.querySelector('p').textContent = '', ['slot1'],
>+ 'slotchange event should fire on the first default slot removed in the tree order when replacing all children');
>+
>+generateTests('', '<div><slot id="slot1"></slot><slot id="slot2"></slot><slot id="slot3"></slot></div>',
>+ (shadowRoot) => shadowRoot.querySelector('p').textContent = '', ['slot1'],
>+ 'slotchange event should fire on the first default slot removed in the tree order when replacing all children');
>+
>+generateTests('',
>+ '<slot id="slot1" name="a"></slot><slot id="slot2" name="b"></slot><slot id="slot3" name="b"></slot>',
>+ (shadowRoot) => shadowRoot.querySelector('p').remove(), ['slot2'],
>+ 'slotchange event should fire on the first named slot of the same name removed in the tree order');
>+
>+generateTests('', '<slot id="a1" name="a"></slot><slot id="a2" name="a"></slot><slot></slot>',
>+ (shadowRoot) => shadowRoot.getElementById('a1').remove(), ['a2', 'a1'],
>+ 'slotchange event should fire when inserting a named slot element before an existing slot of the same name before a default slot in the tree order');
>+
>+generateTests('', '<slot id="default1"></slot><slot id="b1" name="b"></slot>'
>+ + '<slot id="a1" name="a"></slot><slot id="default2"></slot><slot id="a2" name="a"></slot>',
>+ (shadowRoot) => shadowRoot.querySelector('span').remove(), ['default2', 'a2', 'default1', 'a1'],
>+ 'slotchange event should fire on all first slots of its kind with assigned nodes and their previously-first counterparts in the tree order');
>+
>+generateTests('', '<slot id="default1"></slot><slot id="default2"></slot>'
>+ + '<slot id="b1" name="b"></slot><slot id="a1" name="a"></slot>'
>+ + '<slot id="default3"></slot><slot id="a2" name="a"></slot><slot id="b2" name="b"></slot>',
>+ (shadowRoot) => shadowRoot.querySelector('span').remove(), ['default3', 'a2', 'default1', 'a1'],
>+ 'slotchange event should fire on all removed slots with assigned nodes but not on those without in the tree order');
>+
>+
>+// Changing the name
>+
>+generateTests(null, '<slot id="slot"></slot>', (shadowRoot) => shadowRoot.querySelector('slot').name = 'foo', [],
>+ 'slotchange event should not fire when renaming a default slot element to a named slot when there are no assigned nodes');
>+generateTests('', '<slot id="slot"></slot>', (shadowRoot) => shadowRoot.querySelector('slot').name = 'foo', ['slot'],
>+ 'slotchange event should fire when renaming a default slot element to a named slot when there is an assigned node to the named slot');
>+generateTests('hello', '<slot id="slot"></slot>', (shadowRoot) => shadowRoot.querySelector('slot').name = 'foo', ['slot'],
>+ 'slotchange event should fire when renaming a default slot element to a named slot when there is an assigned node to the default slot');
>+
>+generateTests(null, '<slot id="slot" name="foo"></slot>', (shadowRoot) => shadowRoot.querySelector('slot').name = null, [],
>+ 'slotchange event should not fire when renaming a named slot element to a default slot when there are no assigned nodes');
>+generateTests('', '<slot id="slot" name="foo"></slot>', (shadowRoot) => shadowRoot.querySelector('slot').name = '', ['slot'],
>+ 'slotchange event should fire when renaming a named slot element to a default slot when there is a node assigned to the default slot');
>+generateTests('', '<slot id="slot" name="foo"></slot>', (shadowRoot) => shadowRoot.querySelector('slot').name = '', ['slot'],
>+ 'slotchange event should fire when renaming a named slot element to a default slot when there is a node assigned to the named slot');
>+
>+generateTests(null, '<slot id="slot" name="foo"></slot>', (shadowRoot) => shadowRoot.querySelector('slot').name = 'bar', [],
>+ 'slotchange event should not fire when renaming a named slot element when there are no assigned nodes');
>+generateTests('', '<slot id="slot" name="foo"></slot>', (shadowRoot) => shadowRoot.querySelector('slot').name = 'bar', ['slot'],
>+ 'slotchange event should fire when renaming a named slot element when there is an assigned node to the slot of the new name');
>+generateTests('', '<slot id="slot" name="foo"></slot>', (shadowRoot) => shadowRoot.querySelector('slot').name = 'bar', ['slot'],
>+ 'slotchange event should fire when renaming a named slot element when there is an assigned node to the slot of the old name');
>+
>+generateTests('', '<slot id="slot1" name="foo"></slot><slot id="slot2" name="foo"></slot>',
>+ (shadowRoot) => shadowRoot.getElementById('slot2').name = 'bar', [],
>+ 'slotchange event should not fire when renaming the second slot element of a given name and there is no assigned node of the new name');
>+generateTests('', '<slot id="slot1" name="foo"></slot><slot id="slot2" name="foo"></slot>',
>+ (shadowRoot) => shadowRoot.getElementById('slot1').name = 'bar', ['slot1', 'slot2'],
>+ 'slotchange event should fire when renaming the slot element of a given name and there is an assigned node and a second slot element');
>+
>+</script>
>+</body>
>+</html>
>Index: LayoutTests/imported/w3c/web-platform-tests/shadow-dom/slotchange-customelements-expected.txt
>===================================================================
>--- LayoutTests/imported/w3c/web-platform-tests/shadow-dom/slotchange-customelements-expected.txt	(revision 235581)
>+++ LayoutTests/imported/w3c/web-platform-tests/shadow-dom/slotchange-customelements-expected.txt	(working copy)
>@@ -1,3 +1,3 @@
> 
>-FAIL slotchange must fire on initialization of custom elements with slotted children assert_true: expected true got false
>+PASS slotchange must fire on initialization of custom elements with slotted children 
> 
>Index: LayoutTests/imported/w3c/web-platform-tests/shadow-dom/slotchange-event-expected.txt
>===================================================================
>--- LayoutTests/imported/w3c/web-platform-tests/shadow-dom/slotchange-event-expected.txt	(revision 235581)
>+++ LayoutTests/imported/w3c/web-platform-tests/shadow-dom/slotchange-event-expected.txt	(working copy)
>@@ -1,10 +1,4 @@
>-CONSOLE MESSAGE: line 2659: Error: assert_equals: slotchange must not be fired on a slot element if the assigned nodes changed after the slot was removed expected 2 but got 0
>-CONSOLE MESSAGE: line 2659: Error: assert_equals: slotchange must not be fired on a slot element if the assigned nodes changed after the slot was removed expected 2 but got 0
>-CONSOLE MESSAGE: line 2659: Error: assert_equals: slotchange must not be fired on a slot element if the assigned nodes changed after the slot was removed expected 2 but got 0
>-CONSOLE MESSAGE: line 2659: Error: assert_equals: slotchange must not be fired on a slot element if the assigned nodes changed after the slot was removed expected 2 but got 0
> 
>-Harness Error (FAIL), message = Error: assert_equals: slotchange must not be fired on a slot element if the assigned nodes changed after the slot was removed expected 2 but got 0
>-
> PASS slotchange event must fire on a default slot element inside an open shadow root in a document 
> PASS slotchange event must fire on a default slot element inside a closed shadow root in a document 
> PASS slotchange event must fire on a default slot element inside an open shadow root not in a document 
>@@ -17,10 +11,10 @@
> PASS slotchange event must not fire on a slot element inside a closed shadow root in a document when another slot's assigned nodes change 
> PASS slotchange event must not fire on a slot element inside an open shadow root not in a document when another slot's assigned nodes change 
> PASS slotchange event must not fire on a slot element inside a closed shadow root not in a document when another slot's assigned nodes change 
>-FAIL slotchange event must fire on a slot element when a shadow host has a slotable and the slot was inserted and must not fire when the shadow host was mutated after the slot was removed inside an open shadow root in a document assert_equals: slotchange must be fired on a slot element if there is assigned nodes when the slot was inserted expected 1 but got 0
>-FAIL slotchange event must fire on a slot element when a shadow host has a slotable and the slot was inserted and must not fire when the shadow host was mutated after the slot was removed inside a closed shadow root in a document assert_equals: slotchange must be fired on a slot element if there is assigned nodes when the slot was inserted expected 1 but got 0
>-FAIL slotchange event must fire on a slot element when a shadow host has a slotable and the slot was inserted and must not fire when the shadow host was mutated after the slot was removed inside an open shadow root not in a document assert_equals: slotchange must be fired on a slot element if there is assigned nodes when the slot was inserted expected 1 but got 0
>-FAIL slotchange event must fire on a slot element when a shadow host has a slotable and the slot was inserted and must not fire when the shadow host was mutated after the slot was removed inside a closed shadow root not in a document assert_equals: slotchange must be fired on a slot element if there is assigned nodes when the slot was inserted expected 1 but got 0
>+PASS slotchange event must fire on a slot element when a shadow host has a slotable and the slot was inserted and must not fire when the shadow host was mutated after the slot was removed inside an open shadow root in a document 
>+PASS slotchange event must fire on a slot element when a shadow host has a slotable and the slot was inserted and must not fire when the shadow host was mutated after the slot was removed inside a closed shadow root in a document 
>+PASS slotchange event must fire on a slot element when a shadow host has a slotable and the slot was inserted and must not fire when the shadow host was mutated after the slot was removed inside an open shadow root not in a document 
>+PASS slotchange event must fire on a slot element when a shadow host has a slotable and the slot was inserted and must not fire when the shadow host was mutated after the slot was removed inside a closed shadow root not in a document 
> PASS slotchange event must fire on a slot element inside an open shadow root in a document even if the slot was removed immediately after the assigned nodes were mutated 
> PASS slotchange event must fire on a slot element inside a closed shadow root in a document even if the slot was removed immediately after the assigned nodes were mutated 
> PASS slotchange event must fire on a slot element inside an open shadow root not in a document even if the slot was removed immediately after the assigned nodes were mutated 
>@@ -29,10 +23,10 @@
> PASS slotchange event must fire on a slot element inside a closed shadow root in a document when innerHTML modifies the children of the shadow host 
> PASS slotchange event must fire on a slot element inside an open shadow root not in a document when innerHTML modifies the children of the shadow host 
> PASS slotchange event must fire on a slot element inside a closed shadow root not in a document when innerHTML modifies the children of the shadow host 
>-FAIL slotchange event must fire on a slot element inside an open shadow root in a document when nested slots's contents change assert_equals: slotchange event's target must be the inner slot element at 1st slotchange expected Element node <slot></slot> but got Element node <slot></slot>
>-FAIL slotchange event must fire on a slot element inside a closed shadow root in a document when nested slots's contents change assert_equals: slotchange event's target must be the inner slot element at 1st slotchange expected Element node <slot></slot> but got Element node <slot></slot>
>-FAIL slotchange event must fire on a slot element inside an open shadow root not in a document when nested slots's contents change assert_equals: slotchange event's target must be the inner slot element at 1st slotchange expected Element node <slot></slot> but got Element node <slot></slot>
>-FAIL slotchange event must fire on a slot element inside a closed shadow root not in a document when nested slots's contents change assert_equals: slotchange event's target must be the inner slot element at 1st slotchange expected Element node <slot></slot> but got Element node <slot></slot>
>+PASS slotchange event must fire on a slot element inside an open shadow root in a document when nested slots's contents change 
>+PASS slotchange event must fire on a slot element inside a closed shadow root in a document when nested slots's contents change 
>+PASS slotchange event must fire on a slot element inside an open shadow root not in a document when nested slots's contents change 
>+PASS slotchange event must fire on a slot element inside a closed shadow root not in a document when nested slots's contents change 
> PASS slotchange event must fire at the end of current microtask after mutation observers are invoked inside an open shadow root in a document when slots's contents change 
> PASS slotchange event must fire at the end of current microtask after mutation observers are invoked inside a closed shadow root in a document when slots's contents change 
> PASS slotchange event must fire at the end of current microtask after mutation observers are invoked inside an open shadow root not in a document when slots's contents change 
>Index: LayoutTests/imported/w3c/web-platform-tests/shadow-dom/slotchange-expected.txt
>===================================================================
>--- LayoutTests/imported/w3c/web-platform-tests/shadow-dom/slotchange-expected.txt	(revision 235581)
>+++ LayoutTests/imported/w3c/web-platform-tests/shadow-dom/slotchange-expected.txt	(working copy)
>@@ -1,19 +1,17 @@
> 
>-Harness Error (TIMEOUT), message = null
>-
> PASS slotchange event: Append a child to a host. 
> PASS slotchange event: Remove a child from a host. 
> PASS slotchange event: Remove a child before adding an event listener. 
> PASS slotchange event: Change slot= attribute to make it un-assigned. 
>-TIMEOUT slotchange event: Change slot's name= attribute so that none is assigned. Test timed out
>+PASS slotchange event: Change slot's name= attribute so that none is assigned. 
> PASS slotchange event: Change slot= attribute to make it assigned. 
>-TIMEOUT slotchange event: Change slot's name= attribute so that a node is assigned to the slot. Test timed out
>+PASS slotchange event: Change slot's name= attribute so that a node is assigned to the slot. 
> PASS slotchange event: Add a fallback content. 
> PASS slotchange event: Remove a fallback content. 
> PASS slotchange event: Add a fallback content to nested slots. 
> PASS slotchange event: Remove a fallback content from nested slots. 
>-TIMEOUT slotchange event: Insert a slot before an existing slot. Test timed out
>-TIMEOUT slotchange event: Remove a preceding slot. Test timed out
>+PASS slotchange event: Insert a slot before an existing slot. 
>+PASS slotchange event: Remove a preceding slot. 
> PASS slotchange event: A slot is assigned to another slot. 
> PASS slotchange event: Even if distributed nodes do not change, slotchange should be fired if assigned nodes are changed. 
>

Actions: View | Formatted Diff | Diff

Attachments on bug 189144: 348477 | 348486 | 348490 | 348583 | 348594 | 348697 | 348699 | 348709 | 348710 | 348711 | 348839