Make slots in non-shadow trees participate in a flat tree

third_party/WebKit/Source/core/html/HTMLSlotElement.cpp

 /*
  * Copyright (C) 2015 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 50 matching lines @@
 const HeapVector<Member<Node>>& HTMLSlotElement::assignedNodes() {
   DCHECK(!needsDistributionRecalc());
   DCHECK(isInShadowTree() || m_assignedNodes.isEmpty());
   return m_assignedNodes;
 }
 
 const HeapVector<Member<Node>> HTMLSlotElement::assignedNodesForBinding(
     const AssignedNodesOptions& options) {
   updateDistribution();
   if (options.hasFlatten() && options.flatten())
-    return getDistributedNodes();
+    return getDistributedNodesForBinding();
   return m_assignedNodes;
 }
 
-void HTMLSlotElement::updateDistributedNodesManually() {
-  DCHECK(!supportsDistribution());
-  // A slot is unlikely to be used outside of a shadow tree.
-  // We do not need to optimize this case in most cases.
-  // TODO(hayato): If this path causes a performance issue, we should move
-  // ShadowRoot::m_slotAssignment into TreeScopreRareData-ish and
-  // update the distribution code so it considers a document tree too.
-  clearDistribution();
+const HeapVector<Member<Node>>
+HTMLSlotElement::getDistributedNodesForBinding() {
+  DCHECK(!needsDistributionRecalc());
+  if (supportsDistribution())
+    return m_distributedNodes;
+
+  // If a slot does not support distribution, its m_distributedNodes should not
+  // be used.  Instead, calculate distribution manually here. This happens only
+  // in a slot in non-shadow trees, so its assigned nodes are always empty.
+  HeapVector<Member<Node>> distributedNodes;
   Node* child = NodeTraversal::firstChild(*this);
   while (child) {
     if (!child->isSlotable()) {
       child = NodeTraversal::nextSkippingChildren(*child, this);
       continue;
     }
     if (isHTMLSlotElement(child)) {
       child = NodeTraversal::next(*child, this);
     } else {
-      m_distributedNodes.append(child);
+      distributedNodes.append(child);
       child = NodeTraversal::nextSkippingChildren(*child, this);
     }
   }
+  return distributedNodes;
 }
 
 const HeapVector<Member<Node>>& HTMLSlotElement::getDistributedNodes() {
   DCHECK(!needsDistributionRecalc());
-  // m_distributedNodes of slots in non-shadow trees are not updated in recalc
-  // distribution flow.
-  if (!supportsDistribution())
-    updateDistributedNodesManually();
+  DCHECK(supportsDistribution() || m_distributedNodes.isEmpty());
   return m_distributedNodes;
 }
 
 void HTMLSlotElement::appendAssignedNode(Node& hostChild) {
   DCHECK(hostChild.isSlotable());
   m_assignedNodes.append(&hostChild);
 }
 
 void HTMLSlotElement::resolveDistributedNodes() {
   for (auto& node : m_assignedNodes) {
@@ skipping 35 matching lines @@
 }
 
 void HTMLSlotElement::dispatchSlotChangeEvent() {
   m_slotchangeEventEnqueued = false;
   Event* event = Event::createBubble(EventTypeNames::slotchange);
   event->setTarget(this);
   dispatchScopedEvent(event);
 }
 
 Node* HTMLSlotElement::distributedNodeNextTo(const Node& node) const {
+  DCHECK(supportsDistribution());
   const auto& it = m_distributedIndices.find(&node);
   if (it == m_distributedIndices.end())
     return nullptr;
   size_t index = it->value;
   if (index + 1 == m_distributedNodes.size())
     return nullptr;
   return m_distributedNodes[index + 1].get();
 }
 
 Node* HTMLSlotElement::distributedNodePreviousTo(const Node& node) const {
+  DCHECK(supportsDistribution());
   const auto& it = m_distributedIndices.find(&node);
   if (it == m_distributedIndices.end())
     return nullptr;
   size_t index = it->value;
   if (index == 0)
     return nullptr;
   return m_distributedNodes[index - 1].get();
 }
 
 AtomicString HTMLSlotElement::name() const {
   return normalizeSlotName(fastGetAttribute(HTMLNames::nameAttr));
 }
 
 void HTMLSlotElement::attachLayoutTree(const AttachContext& context) {
-  for (auto& node : getDistributedNodes()) {
-    if (node->needsAttach())
-      node->attachLayoutTree(context);
+  if (supportsDistribution()) {
+    for (auto& node : m_distributedNodes) {
+      if (node->needsAttach())
+        node->attachLayoutTree(context);
+    }
   }
-
   HTMLElement::attachLayoutTree(context);
 }
 
 void HTMLSlotElement::detachLayoutTree(const AttachContext& context) {
-  for (auto& node : m_distributedNodes)
-    node->lazyReattachIfAttached();
-
+  if (supportsDistribution()) {
+    for (auto& node : m_distributedNodes)
+      node->lazyReattachIfAttached();
+  }
   HTMLElement::detachLayoutTree(context);
 }
 
 void HTMLSlotElement::attributeChanged(const QualifiedName& name,
                                        const AtomicString& oldValue,
                                        const AtomicString& newValue,
                                        AttributeModificationReason reason) {
   if (name == nameAttr) {
     if (ShadowRoot* root = containingShadowRoot()) {
       if (root->isV1() && oldValue != newValue)
@@ skipping 148 matching lines @@
 
 DEFINE_TRACE(HTMLSlotElement) {
   visitor->trace(m_assignedNodes);
   visitor->trace(m_distributedNodes);
   visitor->trace(m_oldDistributedNodes);
   visitor->trace(m_distributedIndices);
   HTMLElement::trace(visitor);
 }
 
 }  // namespace blink