Fix assignedNodes({flatten:true}) to return fallback content in document 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 52 matching lines @@
 const HeapVector<Member<Node>>& HTMLSlotElement::AssignedNodes() {
   DCHECK(!NeedsDistributionRecalc());
   DCHECK(IsInShadowTree() || assigned_nodes_.IsEmpty());
   return assigned_nodes_;
 }
 
 const HeapVector<Member<Node>> HTMLSlotElement::assignedNodesForBinding(
     const AssignedNodesOptions& options) {
   UpdateDistribution();
   if (options.hasFlatten() && options.flatten())
-    return GetDistributedNodesForBinding();
+    return GetDistributedNodes();
   return assigned_nodes_;
 }
 
-const HeapVector<Member<Node>>
-HTMLSlotElement::GetDistributedNodesForBinding() {
+const HeapVector<Member<Node>> HTMLSlotElement::GetDistributedNodes() const {
   DCHECK(!NeedsDistributionRecalc());
+  DCHECK(SupportsDistribution() || distributed_nodes_.IsEmpty());
   if (SupportsDistribution())
     return distributed_nodes_;
+  // If a slot does not support distribution, its distributed_nodes_ is not
+  // pre-calculated and empty.  Instead, return fallback content for this slot.
+  // This happens only in a slot in non-shadow trees, so its assigned nodes
+  // are always empty.
+  return GetFallbackContent();
+}
 
-  // 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.
+const HeapVector<Member<Node>>
+HTMLSlotElement::GetFallbackContent() const {
+  DCHECK(!SupportsDistribution() && distributed_nodes_.IsEmpty());
   HeapVector<Member<Node>> distributed_nodes;
   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 {
       distributed_nodes.push_back(child);
       child = NodeTraversal::NextSkippingChildren(*child, this);
     }
   }
   return distributed_nodes;
 }
 
-const HeapVector<Member<Node>>& HTMLSlotElement::GetDistributedNodes() {
-  DCHECK(!NeedsDistributionRecalc());
-  DCHECK(SupportsDistribution() || distributed_nodes_.IsEmpty());
-  return distributed_nodes_;
-}
-
 void HTMLSlotElement::AppendAssignedNode(Node& host_child) {
   DCHECK(host_child.IsSlotable());
   assigned_nodes_.push_back(&host_child);
 }
 
 void HTMLSlotElement::ResolveDistributedNodes() {
   for (auto& node : assigned_nodes_) {
     DCHECK(node->IsSlotable());
     if (isHTMLSlotElement(*node))
       AppendDistributedNodesFrom(toHTMLSlotElement(*node));
     else
       AppendDistributedNode(*node);
 
     if (IsChildOfV1ShadowHost())
       ParentElementShadow()->SetNeedsDistributionRecalc();
   }
 }
 
 void HTMLSlotElement::AppendDistributedNode(Node& node) {
   size_t size = distributed_nodes_.size();
   distributed_nodes_.push_back(&node);
   distributed_indices_.Set(&node, size);
 }
 
 void HTMLSlotElement::AppendDistributedNodesFrom(const HTMLSlotElement& other) {
   size_t index = distributed_nodes_.size();
-  distributed_nodes_.AppendVector(other.distributed_nodes_);
-  for (const auto& node : other.distributed_nodes_)
+  const HeapVector<Member<Node>>& other_distributed_nodes =
+      SupportsDistribution() ? other.distributed_nodes_ :
+      other.GetFallbackContent();
+  distributed_nodes_.AppendVector(other_distributed_nodes);
+  for (const auto& node : other_distributed_nodes)
     distributed_indices_.Set(node.Get(), index++);
 }
 
 void HTMLSlotElement::ClearDistribution() {
   // TODO(hayato): Figure out when to call
   // lazyReattachDistributedNodesIfNeeded()
   assigned_nodes_.clear();
   distributed_nodes_.clear();
   distributed_indices_.clear();
 }
@@ skipping 229 matching lines @@
 
 DEFINE_TRACE(HTMLSlotElement) {
   visitor->Trace(assigned_nodes_);
   visitor->Trace(distributed_nodes_);
   visitor->Trace(old_distributed_nodes_);
   visitor->Trace(distributed_indices_);
   HTMLElement::Trace(visitor);
 }
 
 }  // namespace blink