void DistributionPool::distributeTo(InsertionPoint* insertionPoint,
ElementShadowV0* elementShadow) {
DistributedNodes distributedNodes;
for (size_t i = 0; i < m_nodes.size(); ++i) {
if (m_distributed[i])
continue;
if (isHTMLContentElement(*insertionPoint) &&
!toHTMLContentElement(insertionPoint)->canSelectNode(m_nodes, i))
continue;
Node* node = m_nodes[i];
distributedNodes.append(node);
elementShadow->didDistributeNode(node, insertionPoint);
m_distributed[i] = true;
}
// Distributes fallback elements
if (insertionPoint->isContentInsertionPoint() && distributedNodes.isEmpty()) {
for (Node* fallbackNode = insertionPoint->firstChild(); fallbackNode;
fallbackNode = fallbackNode->nextSibling()) {
distributedNodes.append(fallbackNode);
elementShadow->didDistributeNode(fallbackNode, insertionPoint);
}
}
insertionPoint->setDistributedNodes(distributedNodes);
}
Node* ComposedTreeWalker::traverseNode(const Node* node, TraversalDirection direction)
{
ASSERT(node);
if (!isActiveInsertionPoint(*node))
return const_cast<Node*>(node);
const InsertionPoint* insertionPoint = toInsertionPoint(node);
if (Node* found = traverseDistributedNodes(direction == TraversalDirectionForward ? insertionPoint->first() : insertionPoint->last(), insertionPoint, direction))
return found;
ASSERT(isHTMLShadowElement(node) || (isHTMLContentElement(node) && !node->hasChildren()));
return 0;
}
Node* FlatTreeTraversal::v0ResolveDistributionStartingAt(const Node& node, TraversalDirection direction)
{
DCHECK(!isHTMLSlotElement(node));
for (const Node* sibling = &node; sibling; sibling = (direction == TraversalDirectionForward ? sibling->nextSibling() : sibling->previousSibling())) {
if (!isActiveInsertionPoint(*sibling))
return const_cast<Node*>(sibling);
const InsertionPoint& insertionPoint = toInsertionPoint(*sibling);
if (Node* found = (direction == TraversalDirectionForward ? insertionPoint.firstDistributedNode() : insertionPoint.lastDistributedNode()))
return found;
DCHECK(isHTMLShadowElement(insertionPoint) || (isHTMLContentElement(insertionPoint) && !insertionPoint.hasChildren()));
}
return nullptr;
}
void ElementShadow::collectSelectFeatureSetFrom(ShadowRoot& root)
{
if (!root.containsShadowRoots() && !root.containsContentElements())
return;
for (Element& element : ElementTraversal::descendantsOf(root)) {
if (ElementShadow* shadow = element.shadow())
m_selectFeatures.add(shadow->ensureSelectFeatureSet());
if (!isHTMLContentElement(element))
continue;
const CSSSelectorList& list = toHTMLContentElement(element).selectorList();
m_selectFeatures.collectFeaturesFromSelectorList(list);
}
}
void ElementShadow::collectSelectFeatureSetFrom(ShadowRoot& root)
{
if (!root.containsShadowRoots() && !root.containsContentElements())
return;
for (Element* element = ElementTraversal::firstWithin(root); element; element = ElementTraversal::next(*element, &root)) {
if (ElementShadow* shadow = element->shadow())
m_selectFeatures.add(shadow->ensureSelectFeatureSet());
if (!isHTMLContentElement(*element))
continue;
const CSSSelectorList& list = toHTMLContentElement(*element).selectorList();
for (const CSSSelector* selector = list.first(); selector; selector = CSSSelectorList::next(*selector)) {
for (const CSSSelector* component = selector; component; component = component->tagHistory())
m_selectFeatures.collectFeaturesFromSelector(*component);
}
}
}
