ContainerNodeAlgorithms.h [plain text]
#ifndef ContainerNodeAlgorithms_h
#define ContainerNodeAlgorithms_h
#include "Document.h"
#include "ElementIterator.h"
#include "Frame.h"
#include "HTMLFrameOwnerElement.h"
#include "InspectorInstrumentation.h"
#include "NodeTraversal.h"
#include "ShadowRoot.h"
#include <wtf/Assertions.h>
#include <wtf/Ref.h>
namespace WebCore {
class ChildNodeInsertionNotifier {
public:
explicit ChildNodeInsertionNotifier(ContainerNode& insertionPoint)
: m_insertionPoint(insertionPoint)
{
}
void notify(Node&, NodeVector& postInsertionNotificationTargets);
private:
void notifyDescendantInsertedIntoDocument(ContainerNode&, NodeVector& postInsertionNotificationTargets);
void notifyDescendantInsertedIntoTree(ContainerNode&, NodeVector& postInsertionNotificationTargets);
void notifyNodeInsertedIntoDocument(Node&, NodeVector& postInsertionNotificationTargets);
void notifyNodeInsertedIntoTree(ContainerNode&, NodeVector& postInsertionNotificationTargets);
ContainerNode& m_insertionPoint;
};
class ChildNodeRemovalNotifier {
public:
explicit ChildNodeRemovalNotifier(ContainerNode& insertionPoint)
: m_insertionPoint(insertionPoint)
{
}
void notify(Node&);
private:
void notifyDescendantRemovedFromDocument(ContainerNode&);
void notifyDescendantRemovedFromTree(ContainerNode&);
void notifyNodeRemovedFromDocument(Node&);
void notifyNodeRemovedFromTree(ContainerNode&);
ContainerNode& m_insertionPoint;
};
namespace Private {
template<class GenericNode, class GenericNodeContainer>
void addChildNodesToDeletionQueue(GenericNode*& head, GenericNode*& tail, GenericNodeContainer&);
}
template<class GenericNode, class GenericNodeContainer>
inline void removeDetachedChildrenInContainer(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->setParentNode(&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->setNextSibling(0);
n->setParentNode(0);
container.setFirstChild(next);
if (next)
next->setPreviousSibling(0);
if (!n->refCount()) {
#ifndef NDEBUG
n->m_deletionHasBegun = true;
#endif
if (tail)
tail->setNextSibling(n);
else
head = n;
tail = n;
} else {
Ref<GenericNode> protect(*n); NodeRemovalDispatcher<GenericNode, GenericNodeContainer, ShouldDispatchRemovalNotification<GenericNode>::value>::dispatch(*n, container);
}
}
container.setLastChild(0);
}
}
inline void ChildNodeInsertionNotifier::notifyNodeInsertedIntoDocument(Node& node, NodeVector& postInsertionNotificationTargets)
{
ASSERT(m_insertionPoint.inDocument());
if (Node::InsertionShouldCallDidNotifySubtreeInsertions == node.insertedInto(m_insertionPoint))
postInsertionNotificationTargets.append(node);
if (node.isContainerNode())
notifyDescendantInsertedIntoDocument(toContainerNode(node), postInsertionNotificationTargets);
}
inline void ChildNodeInsertionNotifier::notifyNodeInsertedIntoTree(ContainerNode& node, NodeVector& postInsertionNotificationTargets)
{
NoEventDispatchAssertion assertNoEventDispatch;
ASSERT(!m_insertionPoint.inDocument());
if (Node::InsertionShouldCallDidNotifySubtreeInsertions == node.insertedInto(m_insertionPoint))
postInsertionNotificationTargets.append(node);
notifyDescendantInsertedIntoTree(node, postInsertionNotificationTargets);
}
inline void ChildNodeInsertionNotifier::notify(Node& node, NodeVector& postInsertionNotificationTargets)
{
ASSERT(!NoEventDispatchAssertion::isEventDispatchForbidden());
#if ENABLE(INSPECTOR)
InspectorInstrumentation::didInsertDOMNode(&node.document(), &node);
#endif
Ref<Document> protectDocument(node.document());
Ref<Node> protectNode(node);
if (m_insertionPoint.inDocument())
notifyNodeInsertedIntoDocument(node, postInsertionNotificationTargets);
else if (node.isContainerNode())
notifyNodeInsertedIntoTree(toContainerNode(node), postInsertionNotificationTargets);
}
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)
{
NoEventDispatchAssertion assertNoEventDispatch;
ASSERT(!m_insertionPoint.inDocument());
node.removedFrom(m_insertionPoint);
notifyDescendantRemovedFromTree(node);
}
inline void ChildNodeRemovalNotifier::notify(Node& node)
{
if (node.inDocument()) {
notifyNodeRemovedFromDocument(node);
node.document().notifyRemovePendingSheetIfNeeded();
} else if (node.isContainerNode())
notifyNodeRemovedFromTree(toContainerNode(node));
}
enum SubframeDisconnectPolicy {
RootAndDescendants,
DescendantsOnly
};
void disconnectSubframes(ContainerNode& root, SubframeDisconnectPolicy);
inline void disconnectSubframesIfNeeded(ContainerNode& root, SubframeDisconnectPolicy policy)
{
if (!root.connectedSubframeCount())
return;
disconnectSubframes(root, policy);
}
}
#endif // ContainerNodeAlgorithms_h