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 61 matching lines @@
   if (options.hasFlatten() && options.flatten())
     return GetDistributedNodesForBinding();
   return assigned_nodes_;
 }
 
 const HeapVector<Member<Node>>
 HTMLSlotElement::GetDistributedNodesForBinding() {
   DCHECK(!NeedsDistributionRecalc());
   if (SupportsDistribution())
     return distributed_nodes_;
+  return GetDistributedNodesOfSlotInDocument();
+}
 
+const HeapVector<Member<Node>>
+HTMLSlotElement::GetDistributedNodesOfSlotInDocument() const {
   // 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>> distributed_nodes;
   Node* child = NodeTraversal::FirstChild(*this);
   while (child) {
     if (!child->IsSlotable()) {
       child = NodeTraversal::NextSkippingChildren(*child, this);
       continue;
     }
@@ skipping 32 matching lines @@
 }
 
 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_);
+
+  if (other.SupportsDistribution()) {

[hayato, 2017/05/12 03:19:09]

Could you avoid if else here?
It looks a functional duplication of GetDistributedNodesForBinding.

[kochi, 2017/05/12 07:26:33]

I see, having inconsistent distributed_nodes_ and distributed_indices_
would be also problematic.  Let me work on it.

[kochi, 2017/05/12 07:53:14]

Hmm, this function is called when resolving distribution, to have
a cached distributed nodes in |distributed_nodes_|.

|distributed_nodes_| of slots in non-shadow tree are still empty.

If we don't calculate |distributed_nodes_| for slots in shadow
tree here, GetDistributedNodesForBinding() has to go though all
|distributed_nodes_| to see if there is any slot that contains
fallback content in it, and insert manually calculated distributed
nodes. This will make assignedNodes({flatten:true}) slower.

GetDistributedNodesForBinding() does manual calculation if |this|
is a slot in non-shadow tree.  So I don't think this is duplicate.

+    distributed_nodes_.AppendVector(other.distributed_nodes_);
+  } else {
+    distributed_nodes_.AppendVector(
+        other.GetDistributedNodesOfSlotInDocument());
+  }
+
   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 216 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