Rewrite Shadow DOM distribution engine to support partial synchronous distribution for v1

third_party/WebKit/Source/core/dom/Node.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 41 matching lines @@
 #include "core/dom/StaticNodeList.h"
 #include "core/dom/StyleEngine.h"
 #include "core/dom/TemplateContentDocumentFragment.h"
 #include "core/dom/Text.h"
 #include "core/dom/TreeScopeAdopter.h"
 #include "core/dom/UserActionElementSet.h"
 #include "core/dom/shadow/ElementShadow.h"
 #include "core/dom/shadow/FlatTreeTraversal.h"
 #include "core/dom/shadow/InsertionPoint.h"
 #include "core/dom/shadow/ShadowRoot.h"
+#include "core/dom/shadow/SlotAssignment.h"
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/markers/DocumentMarkerController.h"
 #include "core/events/Event.h"
 #include "core/events/EventDispatchMediator.h"
 #include "core/events/EventDispatcher.h"
 #include "core/events/EventListener.h"
 #include "core/events/GestureEvent.h"
 #include "core/events/InputEvent.h"
 #include "core/events/KeyboardEvent.h"
 #include "core/events/MouseEvent.h"
@@ skipping 556 matching lines @@
         return document();
     Node* root = const_cast<Node*>(this);
     while (Node* host = root->shadowHost())
         root = host;
     while (Node* ancestor = root->parentNode())
         root = ancestor;
     DCHECK(!root->shadowHost());
     return *root;
 }
 
-#if DCHECK_IS_ON()
 bool Node::needsDistributionRecalc() const
 {
     return shadowIncludingRoot().childNeedsDistributionRecalc();
 }
-#endif
 
 void Node::updateDistribution()
 {
     // Extra early out to avoid spamming traces.
     if (inShadowIncludingDocument() && !document().childNeedsDistributionRecalc())
         return;
     TRACE_EVENT0("blink", "Node::updateDistribution");
     ScriptForbiddenScope forbidScript;
     Node& root = shadowIncludingRoot();
     if (root.childNeedsDistributionRecalc())
@@ skipping 39 matching lines @@
 {
     ScriptForbiddenScope forbidScriptDuringRawIteration;
     for (Node* node = parentOrShadowHostNode(); node && !node->childNeedsStyleInvalidation(); node = node->parentOrShadowHostNode())
         node->setChildNeedsStyleInvalidation();
     document().scheduleLayoutTreeUpdateIfNeeded();
 }
 
 void Node::markAncestorsWithChildNeedsDistributionRecalc()
 {
     ScriptForbiddenScope forbidScriptDuringRawIteration;
-    if (RuntimeEnabledFeatures::shadowDOMV1Enabled() && inShadowIncludingDocument() && !document().childNeedsDistributionRecalc()) {
-        // TODO(hayato): Support a non-document composed tree.
-        // TODO(hayato): Enqueue a task only if a 'slotchange' event listner is registered in the document composed tree.
-        Microtask::enqueueMicrotask(WTF::bind(&Document::updateDistribution, &document()));
-    }
     for (Node* node = this; node && !node->childNeedsDistributionRecalc(); node = node->parentOrShadowHostNode())
         node->setChildNeedsDistributionRecalc();
     document().scheduleLayoutTreeUpdateIfNeeded();
 }
 
 inline void Node::setStyleChange(StyleChangeType changeType)
 {
     m_nodeFlags = (m_nodeFlags & ~StyleChangeMask) | changeType;
 }
 
@@ skipping 269 matching lines @@
     return !isShadowRoot() && !isSlotOrActiveInsertionPoint();
 }
 
 bool Node::isSlotOrActiveInsertionPoint() const
 {
     return isHTMLSlotElement(*this) || isActiveInsertionPoint(*this);
 }
 
 AtomicString Node::slotName() const
 {
-    DCHECK(slottable());
+    DCHECK(isSlotable());
     if (isElementNode())
-        return normalizeSlotName(toElement(*this).fastGetAttribute(HTMLNames::slotAttr));
+        return HTMLSlotElement::normalizeSlotName(toElement(*this).fastGetAttribute(HTMLNames::slotAttr));
     DCHECK(isTextNode());
     return emptyAtom;
 }
 
-// static
-AtomicString Node::normalizeSlotName(const AtomicString& name)
-{
-    return (name.isNull() || name.isEmpty()) ? emptyAtom : name;
-}
-
 bool Node::isInV1ShadowTree() const
 {
     ShadowRoot* shadowRoot = containingShadowRoot();
     return shadowRoot && shadowRoot->isV1();
 }
 
 bool Node::isInV0ShadowTree() const
 {
     ShadowRoot* shadowRoot = containingShadowRoot();
     return shadowRoot && !shadowRoot->isV1();
@@ skipping 10 matching lines @@
     ElementShadow* parentShadow = parentElementShadow();
     return parentShadow && parentShadow->isV1();
 }
 
 bool Node::isChildOfV0ShadowHost() const
 {
     ElementShadow* parentShadow = parentElementShadow();
     return parentShadow && !parentShadow->isV1();
 }
 
+ShadowRoot* Node::v1ShadowRootOfParent() const
+{
+    if (Element* parent = parentElement())
+        return parent->shadowRootIfV1();
+    return nullptr;
+}
+
 Element* Node::shadowHost() const
 {
     if (ShadowRoot* root = containingShadowRoot())
         return root->host();
     return nullptr;
 }
 
 ShadowRoot* Node::containingShadowRoot() const
 {
     Node& root = treeScope().rootNode();
@@ skipping 1190 matching lines @@
         DCHECK(insertionPoint->containingShadowRoot());
         if (!insertionPoint->containingShadowRoot()->isOpenOrV0())
             break;
         filteredInsertionPoints.append(insertionPoint);
     }
     return StaticNodeList::adopt(filteredInsertionPoints);
 }
 
 HTMLSlotElement* Node::assignedSlot() const
 {
-    Element* parent = parentElement();
-    ShadowRoot* root = parent ? parent->youngestShadowRoot() : nullptr;
-    if (root && root->isV1())
-        return root->assignedSlotFor(*this);
+    if (ShadowRoot* root = v1ShadowRootOfParent())
+        return root->ensureSlotAssignment().findSlot(*this);
     return nullptr;
 }
 
 HTMLSlotElement* Node::assignedSlotForBinding()
 {
     updateDistribution();
-    Element* parent = parentElement();
-    ShadowRoot* root = parent ? parent->youngestShadowRoot() : nullptr;
-    if (root && root->type() == ShadowRootType::Open)
-        return root->assignedSlotFor(*this);
+    if (ShadowRoot* root = v1ShadowRootOfParent()) {
+        if (root->type() == ShadowRootType::Open)
+            return root->ensureSlotAssignment().findSlot(*this);
+    }
     return nullptr;
 }
 
 void Node::setFocus(bool flag)
 {
     document().userActionElements().setFocused(this, flag);
 }
 
 void Node::setActive(bool flag)
 {
@@ skipping 98 matching lines @@
 
     DCHECK(isHTMLElement() || isSVGElement());
     DCHECK(CustomElementState::Custom != getCustomElementState());
     setFlag(V0CustomElementFlag);
     setFlag(newState == V0Upgraded, V0CustomElementUpgradedFlag);
 
     if (oldState == V0NotCustomElement || newState == V0Upgraded)
         toElement(this)->pseudoStateChanged(CSSSelector::PseudoUnresolved);
 }
 
-void Node::updateAssignmentForInsertedInto(ContainerNode* insertionPoint)
+void Node::checkSlotChange()
 {
-    if (isShadowHost(insertionPoint)) {
-        ShadowRoot* root = insertionPoint->youngestShadowRoot();
-        if (root && root->isV1())
-            root->assignV1();
+    // Common check logic is used in both cases, "after inserted" and "before removed".
+    if (!isSlotable())
+        return;
+    if (ShadowRoot* root = v1ShadowRootOfParent()) {
+        // Relevant DOM Standard:
+        // https://dom.spec.whatwg.org/#concept-node-insert
+        // - 6.1.2: If parent is a shadow host and node is a slotable, then assign a slot for node.
+        // https://dom.spec.whatwg.org/#concept-node-remove
+        // - 10. If node is assigned, then run assign slotables for node’s assigned slot.
+
+        // Although DOM Standard requires "assign a slot for node / run assign slotables" at this timing,
+        // we skip it as an optimization.
+        if (HTMLSlotElement* slot = root->ensureSlotAssignment().findSlot(*this))
+            slot->enqueueSlotChangeEvent();
+    } else {
+        // Relevant DOM Standard:
+        // https://dom.spec.whatwg.org/#concept-node-insert
+        // - 6.1.3: If parent is a slot whose assigned nodes is the empty list, then run signal a slot change for parent.
+        // https://dom.spec.whatwg.org/#concept-node-remove
+        // - 11. If parent is a slot whose assigned nodes is the empty list, then run signal a slot change for parent.
+        Element* parent = parentElement();
+        if (parent && isHTMLSlotElement(parent)) {
+            HTMLSlotElement& parentSlot = toHTMLSlotElement(*parent);
+            if (ShadowRoot* root = containingShadowRoot()) {
+                if (root && root->isV1() && !parentSlot.hasAssignedNodesSlow())
+                    parentSlot.enqueueSlotChangeEvent();
+            }
+        }
     }
 }
 
 DEFINE_TRACE(Node)
 {
     visitor->trace(m_parentOrShadowHostNode);
     visitor->trace(m_previous);
     visitor->trace(m_next);
     // rareData() and m_data.m_layoutObject share their storage. We have to trace
     // only one of them.
@@ skipping 76 matching lines @@
 
 void showNodePath(const blink::Node* node)
 {
     if (node)
         node->showNodePathForThis();
     else
         fprintf(stderr, "Cannot showNodePath for (nil)\n");
 }
 
 #endif