ContainerNodeAlgorithms.h [plain text]
#ifndef ContainerNodeAlgorithms_h
#define ContainerNodeAlgorithms_h
#include "Document.h"
#include "InspectorInstrumentation.h"
#include <wtf/Assertions.h>
namespace WebCore {
class Node;
class ChildNodeInsertionNotifier {
public:
explicit ChildNodeInsertionNotifier(Node* insertionPoint)
: m_insertionPoint(insertionPoint)
{ }
void notifyInsertedIntoDocument(Node*);
void notify(Node*);
private:
void notifyDescendantInsertedIntoDocument(ContainerNode*);
void notifyDescendantInsertedIntoTree(ContainerNode*);
void notifyNodeInsertedIntoDocument(Node*);
void notifyNodeInsertedIntoTree(ContainerNode*);
Node* m_insertionPoint;
Vector< RefPtr<Node> > m_postInsertionNotificationTargets;
};
class ChildNodeRemovalNotifier {
public:
explicit ChildNodeRemovalNotifier(Node* insertionPoint)
: m_insertionPoint(insertionPoint)
{ }
void notify(Node*);
private:
void notifyDescendantRemovedFromDocument(ContainerNode*);
void notifyDescendantRemovedFromTree(ContainerNode*);
void notifyNodeRemovedFromDocument(Node*);
void notifyNodeRemovedFromTree(ContainerNode*);
Node* m_insertionPoint;
};
namespace Private {
template<class GenericNode, class GenericNodeContainer>
void addChildNodesToDeletionQueue(GenericNode*& head, GenericNode*& tail, GenericNodeContainer* container);
};
template<class GenericNode, class GenericNodeContainer>
inline void removeAllChildrenInContainer(GenericNodeContainer* container)
{
GenericNode* head = 0;
GenericNode* tail = 0;
Private::addChildNodesToDeletionQueue<GenericNode, GenericNodeContainer>(head, tail, container);
GenericNode* n;
GenericNode* next;
while ((n = head) != 0) {
ASSERT(n->m_deletionHasBegun);
next = n->nextSibling();
n->setNextSibling(0);
head = next;
if (next == 0)
tail = 0;
if (n->hasChildNodes())
Private::addChildNodesToDeletionQueue<GenericNode, GenericNodeContainer>(head, tail, static_cast<GenericNodeContainer*>(n));
delete n;
}
}
template<class GenericNode, class GenericNodeContainer>
inline void appendChildToContainer(GenericNode* child, GenericNodeContainer* container)
{
child->setParent(container);
GenericNode* lastChild = container->lastChild();
if (lastChild) {
child->setPreviousSibling(lastChild);
lastChild->setNextSibling(child);
} else
container->setFirstChild(child);
container->setLastChild(child);
}
namespace Private {
template<class GenericNode, class GenericNodeContainer, bool dispatchRemovalNotification>
struct NodeRemovalDispatcher {
static void dispatch(GenericNode*, GenericNodeContainer*)
{
}
};
template<class GenericNode, class GenericNodeContainer>
struct NodeRemovalDispatcher<GenericNode, GenericNodeContainer, true> {
static void dispatch(GenericNode* node, GenericNodeContainer* container)
{
if (Document* containerDocument = container->ownerDocument())
containerDocument->adoptIfNeeded(node);
if (node->inDocument())
ChildNodeRemovalNotifier(container).notify(node);
}
};
template<class GenericNode>
struct ShouldDispatchRemovalNotification {
static const bool value = false;
};
template<>
struct ShouldDispatchRemovalNotification<Node> {
static const bool value = true;
};
template<class GenericNode, class GenericNodeContainer>
void addChildNodesToDeletionQueue(GenericNode*& head, GenericNode*& tail, GenericNodeContainer* container)
{
GenericNode* next = 0;
for (GenericNode* n = container->firstChild(); n != 0; n = next) {
ASSERT(!n->m_deletionHasBegun);
next = n->nextSibling();
n->setPreviousSibling(0);
n->setNextSibling(0);
n->setParent(0);
if (!n->refCount()) {
#ifndef NDEBUG
n->m_deletionHasBegun = true;
#endif
if (tail)
tail->setNextSibling(n);
else
head = n;
tail = n;
} else {
RefPtr<GenericNode> protect(n); NodeRemovalDispatcher<GenericNode, GenericNodeContainer, ShouldDispatchRemovalNotification<GenericNode>::value>::dispatch(n, container);
}
}
container->setFirstChild(0);
container->setLastChild(0);
}
}
inline void ChildNodeInsertionNotifier::notifyNodeInsertedIntoDocument(Node* node)
{
ASSERT(m_insertionPoint->inDocument());
RefPtr<Node> protect(node);
Node::InsertionNotificationRequest request = node->insertedInto(m_insertionPoint);
if (node->isContainerNode())
notifyDescendantInsertedIntoDocument(toContainerNode(node));
switch (request) {
case Node::InsertionDone:
break;
case Node::InsertionShouldCallDidNotifyDescendantInseretions:
node->didNotifyDescendantInseretions(m_insertionPoint);
break;
case Node::InsertionShouldCallDidNotifySubtreeInsertions:
m_postInsertionNotificationTargets.append(node);
break;
}
}
inline void ChildNodeInsertionNotifier::notifyNodeInsertedIntoTree(ContainerNode* node)
{
ASSERT(!m_insertionPoint->inDocument());
forbidEventDispatch();
Node::InsertionNotificationRequest request = node->insertedInto(m_insertionPoint);
notifyDescendantInsertedIntoTree(node);
if (request == Node::InsertionShouldCallDidNotifyDescendantInseretions)
node->didNotifyDescendantInseretions(m_insertionPoint);
allowEventDispatch();
}
inline void ChildNodeInsertionNotifier::notifyInsertedIntoDocument(Node* node)
{
notifyNodeInsertedIntoDocument(node);
}
inline void ChildNodeInsertionNotifier::notify(Node* node)
{
ASSERT(!eventDispatchForbidden());
#if ENABLE(INSPECTOR)
InspectorInstrumentation::didInsertDOMNode(node->document(), node);
#endif
RefPtr<Document> protectDocument(node->document());
RefPtr<Node> protectNode(node);
if (m_insertionPoint->inDocument())
notifyNodeInsertedIntoDocument(node);
else if (node->isContainerNode())
notifyNodeInsertedIntoTree(toContainerNode(node));
for (size_t i = 0; i < m_postInsertionNotificationTargets.size(); ++i)
m_postInsertionNotificationTargets[i]->didNotifySubtreeInsertions(m_insertionPoint);
}
inline void ChildNodeRemovalNotifier::notifyNodeRemovedFromDocument(Node* node)
{
ASSERT(m_insertionPoint->inDocument());
node->removedFrom(m_insertionPoint);
if (node->isContainerNode())
notifyDescendantRemovedFromDocument(toContainerNode(node));
}
inline void ChildNodeRemovalNotifier::notifyNodeRemovedFromTree(ContainerNode* node)
{
ASSERT(!m_insertionPoint->inDocument());
forbidEventDispatch();
node->removedFrom(m_insertionPoint);
notifyDescendantRemovedFromTree(node);
allowEventDispatch();
}
inline void ChildNodeRemovalNotifier::notify(Node* node)
{
if (node->inDocument()) {
notifyNodeRemovedFromDocument(node);
node->document()->notifyRemovePendingSheetIfNeeded();
} else if (node->isContainerNode())
notifyNodeRemovedFromTree(toContainerNode(node));
}
class ChildFrameDisconnector {
public:
enum ShouldIncludeRoot {
DoNotIncludeRoot,
IncludeRoot
};
explicit ChildFrameDisconnector(Node* root, ShouldIncludeRoot shouldIncludeRoot = IncludeRoot)
: m_root(root)
{
collectDescendant(m_root, shouldIncludeRoot);
rootNodes().add(m_root);
}
~ChildFrameDisconnector()
{
rootNodes().remove(m_root);
}
void disconnect();
static bool nodeHasDisconnector(Node*);
private:
void collectDescendant(Node* root, ShouldIncludeRoot);
void collectDescendant(ShadowTree*);
static HashSet<Node*>& rootNodes()
{
DEFINE_STATIC_LOCAL(HashSet<Node*>, nodes, ());
return nodes;
}
class Target {
public:
Target(Node* element)
: m_owner(element)
, m_ownerParent(element->parentNode())
{ }
bool isValid() const { return m_owner->parentNode() == m_ownerParent; }
void disconnect();
private:
RefPtr<Node> m_owner;
Node* m_ownerParent;
};
Vector<Target, 10> m_list;
Node* m_root;
};
inline void ChildFrameDisconnector::collectDescendant(Node* root, ShouldIncludeRoot shouldIncludeRoot)
{
for (Node* node = shouldIncludeRoot == IncludeRoot ? root : root->firstChild(); node;
node = node->traverseNextNode(root)) {
if (!node->isElementNode())
continue;
Element* element = toElement(node);
if (element->isFrameOwnerElement())
m_list.append(node);
if (element->hasShadowRoot())
collectDescendant(element->shadowTree());
}
}
inline void ChildFrameDisconnector::disconnect()
{
unsigned size = m_list.size();
for (unsigned i = 0; i < size; ++i) {
Target& target = m_list[i];
if (target.isValid())
target.disconnect();
};
}
inline bool ChildFrameDisconnector::nodeHasDisconnector(Node* node)
{
HashSet<Node*>& nodes = rootNodes();
if (nodes.isEmpty())
return false;
for (; node; node = node->parentNode())
if (nodes.contains(node))
return true;
return false;
}
}
#endif // ContainerNodeAlgorithms_h