ContainerNodeAlgorithms.cpp [plain text]
#include "config.h"
#include "ContainerNodeAlgorithms.h"
#include "NoEventDispatchAssertion.h"
namespace WebCore {
void notifyNodeInsertedIntoTree(ContainerNode& insertionPoint, ContainerNode&, NodeVector& postInsertionNotificationTargets);
void notifyNodeInsertedIntoDocument(ContainerNode& insertionPoint, Node&, NodeVector& postInsertionNotificationTargets);
void notifyNodeRemovedFromTree(ContainerNode& insertionPoint, ContainerNode&);
void notifyNodeRemovedFromDocument(ContainerNode& insertionPoint, Node&);
static void notifyDescendantInsertedIntoDocument(ContainerNode& insertionPoint, ContainerNode& node, NodeVector& postInsertionNotificationTargets)
{
ChildNodesLazySnapshot snapshot(node);
while (RefPtr<Node> child = snapshot.nextNode()) {
if (node.inDocument() && child->parentNode() == &node)
notifyNodeInsertedIntoDocument(insertionPoint, *child, postInsertionNotificationTargets);
}
if (!is<Element>(node))
return;
if (RefPtr<ShadowRoot> root = downcast<Element>(node).shadowRoot()) {
if (node.inDocument() && root->host() == &node)
notifyNodeInsertedIntoDocument(insertionPoint, *root, postInsertionNotificationTargets);
}
}
static void notifyDescendantInsertedIntoTree(ContainerNode& insertionPoint, ContainerNode& node, NodeVector& postInsertionNotificationTargets)
{
for (Node* child = node.firstChild(); child; child = child->nextSibling()) {
if (is<ContainerNode>(*child))
notifyNodeInsertedIntoTree(insertionPoint, downcast<ContainerNode>(*child), postInsertionNotificationTargets);
}
if (ShadowRoot* root = node.shadowRoot())
notifyNodeInsertedIntoTree(insertionPoint, *root, postInsertionNotificationTargets);
}
void notifyNodeInsertedIntoDocument(ContainerNode& insertionPoint, Node& node, NodeVector& postInsertionNotificationTargets)
{
ASSERT(insertionPoint.inDocument());
if (node.insertedInto(insertionPoint) == Node::InsertionShouldCallFinishedInsertingSubtree)
postInsertionNotificationTargets.append(node);
if (is<ContainerNode>(node))
notifyDescendantInsertedIntoDocument(insertionPoint, downcast<ContainerNode>(node), postInsertionNotificationTargets);
}
void notifyNodeInsertedIntoTree(ContainerNode& insertionPoint, ContainerNode& node, NodeVector& postInsertionNotificationTargets)
{
NoEventDispatchAssertion assertNoEventDispatch;
ASSERT(!insertionPoint.inDocument());
if (node.insertedInto(insertionPoint) == Node::InsertionShouldCallFinishedInsertingSubtree)
postInsertionNotificationTargets.append(node);
notifyDescendantInsertedIntoTree(insertionPoint, node, postInsertionNotificationTargets);
}
void notifyChildNodeInserted(ContainerNode& insertionPoint, Node& node, NodeVector& postInsertionNotificationTargets)
{
ASSERT_WITH_SECURITY_IMPLICATION(!NoEventDispatchAssertion::isEventDispatchForbidden());
InspectorInstrumentation::didInsertDOMNode(node.document(), node);
Ref<Document> protectDocument(node.document());
Ref<Node> protectNode(node);
if (insertionPoint.inDocument())
notifyNodeInsertedIntoDocument(insertionPoint, node, postInsertionNotificationTargets);
else if (is<ContainerNode>(node))
notifyNodeInsertedIntoTree(insertionPoint, downcast<ContainerNode>(node), postInsertionNotificationTargets);
}
void notifyNodeRemovedFromDocument(ContainerNode& insertionPoint, Node& node)
{
ASSERT(insertionPoint.inDocument());
node.removedFrom(insertionPoint);
if (!is<ContainerNode>(node))
return;
ChildNodesLazySnapshot snapshot(node);
while (RefPtr<Node> child = snapshot.nextNode()) {
if (!node.inDocument() && child->parentNode() == &node)
notifyNodeRemovedFromDocument(insertionPoint, *child.get());
}
if (!is<Element>(node))
return;
if (node.document().cssTarget() == &node)
node.document().setCSSTarget(nullptr);
if (RefPtr<ShadowRoot> root = downcast<Element>(node).shadowRoot()) {
if (!node.inDocument() && root->host() == &node)
notifyNodeRemovedFromDocument(insertionPoint, *root.get());
}
}
void notifyNodeRemovedFromTree(ContainerNode& insertionPoint, ContainerNode& node)
{
NoEventDispatchAssertion assertNoEventDispatch;
ASSERT(!insertionPoint.inDocument());
node.removedFrom(insertionPoint);
for (Node* child = node.firstChild(); child; child = child->nextSibling()) {
if (is<ContainerNode>(*child))
notifyNodeRemovedFromTree(insertionPoint, downcast<ContainerNode>(*child));
}
if (!is<Element>(node))
return;
if (RefPtr<ShadowRoot> root = downcast<Element>(node).shadowRoot())
notifyNodeRemovedFromTree(insertionPoint, *root.get());
}
void notifyChildNodeRemoved(ContainerNode& insertionPoint, Node& child)
{
if (!child.inDocument()) {
if (is<ContainerNode>(child))
notifyNodeRemovedFromTree(insertionPoint, downcast<ContainerNode>(child));
return;
}
notifyNodeRemovedFromDocument(insertionPoint, child);
child.document().notifyRemovePendingSheetIfNeeded();
}
void addChildNodesToDeletionQueue(Node*& head, Node*& tail, ContainerNode& container)
{
Node* next = nullptr;
for (auto* node = container.firstChild(); node; node = next) {
ASSERT(!node->m_deletionHasBegun);
next = node->nextSibling();
node->setNextSibling(nullptr);
node->setParentNode(nullptr);
container.setFirstChild(next);
if (next)
next->setPreviousSibling(nullptr);
if (!node->refCount()) {
#ifndef NDEBUG
node->m_deletionHasBegun = true;
#endif
if (tail)
tail->setNextSibling(node);
else
head = node;
tail = node;
} else {
Ref<Node> protect(*node); if (Document* containerDocument = container.ownerDocument())
containerDocument->adoptIfNeeded(node);
if (node->isInTreeScope())
notifyChildNodeRemoved(container, *node);
}
}
container.setLastChild(nullptr);
}
void removeDetachedChildrenInContainer(ContainerNode& container)
{
Node* head = nullptr;
Node* tail = nullptr;
addChildNodesToDeletionQueue(head, tail, container);
Node* node;
Node* next;
while ((node = head)) {
ASSERT(node->m_deletionHasBegun);
next = node->nextSibling();
node->setNextSibling(nullptr);
head = next;
if (!next)
tail = nullptr;
if (is<ContainerNode>(node))
addChildNodesToDeletionQueue(head, tail, downcast<ContainerNode>(*node));
delete node;
}
}
#ifndef NDEBUG
static unsigned assertConnectedSubrameCountIsConsistent(ContainerNode& node)
{
unsigned count = 0;
if (is<Element>(node)) {
if (is<HTMLFrameOwnerElement>(node) && downcast<HTMLFrameOwnerElement>(node).contentFrame())
++count;
if (ShadowRoot* root = downcast<Element>(node).shadowRoot())
count += assertConnectedSubrameCountIsConsistent(*root);
}
for (auto& child : childrenOfType<Element>(node))
count += assertConnectedSubrameCountIsConsistent(child);
ASSERT(node.connectedSubframeCount() >= count);
ASSERT(node.connectedSubframeCount() == count);
return count;
}
#endif
static void collectFrameOwners(Vector<Ref<HTMLFrameOwnerElement>>& frameOwners, ContainerNode& root)
{
auto elementDescendants = descendantsOfType<Element>(root);
auto it = elementDescendants.begin();
auto end = elementDescendants.end();
while (it != end) {
Element& element = *it;
if (!element.connectedSubframeCount()) {
it.traverseNextSkippingChildren();
continue;
}
if (is<HTMLFrameOwnerElement>(element))
frameOwners.append(downcast<HTMLFrameOwnerElement>(element));
if (ShadowRoot* shadowRoot = element.shadowRoot())
collectFrameOwners(frameOwners, *shadowRoot);
++it;
}
}
void disconnectSubframes(ContainerNode& root, SubframeDisconnectPolicy policy)
{
#ifndef NDEBUG
assertConnectedSubrameCountIsConsistent(root);
#endif
ASSERT(root.connectedSubframeCount());
Vector<Ref<HTMLFrameOwnerElement>> frameOwners;
if (policy == RootAndDescendants) {
if (is<HTMLFrameOwnerElement>(root))
frameOwners.append(downcast<HTMLFrameOwnerElement>(root));
}
collectFrameOwners(frameOwners, root);
SubframeLoadingDisabler disabler(root);
bool isFirst = true;
for (auto& owner : frameOwners) {
if (isFirst || root.containsIncludingShadowDOM(&owner.get()))
owner.get().disconnectContentFrame();
isFirst = false;
}
}
}