#ifndef ContainerNodeAlgorithms_h
#define ContainerNodeAlgorithms_h
#include "core/dom/Document.h"
#include "core/html/HTMLFrameOwnerElement.h"
#include "core/inspector/InspectorInstrumentation.h"
#include "wtf/Assertions.h"
namespace WebCore {
class ChildNodeInsertionNotifier {
public:
explicit ChildNodeInsertionNotifier(ContainerNode& insertionPoint)
: m_insertionPoint(insertionPoint)
{
}
void notify(Node&);
private:
void notifyDescendantInsertedIntoDocument(ContainerNode&);
void notifyDescendantInsertedIntoTree(ContainerNode&);
void notifyNodeInsertedIntoDocument(Node&);
void notifyNodeInsertedIntoTree(ContainerNode&);
ContainerNode& m_insertionPoint;
Vector< RefPtr<Node> > m_postInsertionNotificationTargets;
};
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) {
#if !ENABLE(OILPAN)
ASSERT_WITH_SECURITY_IMPLICATION(n->m_deletionHasBegun);
#endif
next = n->nextSibling();
n->setNextSibling(0);
head = next;
if (next == 0)
tail = 0;
if (n->hasChildren())
Private::addChildNodesToDeletionQueue<GenericNode, GenericNodeContainer>(head, tail, static_cast<GenericNodeContainer&>(*n));
#if !ENABLE(OILPAN)
delete n;
#endif
}
}
template<class GenericNode, class GenericNodeContainer>
inline void appendChildToContainer(GenericNode& child, GenericNodeContainer& container)
{
child.setParentOrShadowHostNode(&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; n = next) {
ASSERT_WITH_SECURITY_IMPLICATION(!n->m_deletionHasBegun);
next = n->nextSibling();
n->setNextSibling(0);
n->setParentOrShadowHostNode(0);
container.setFirstChild(next);
if (next)
next->setPreviousSibling(0);
#if ENABLE(OILPAN)
{
RefPtr<GenericNode> protect(n);
NodeRemovalDispatcher<GenericNode, GenericNodeContainer, ShouldDispatchRemovalNotification<GenericNode>::value>::dispatch(*n, container);
}
if (!n->refCount()) {
if (tail)
tail->setNextSibling(n);
else
head = n;
tail = n;
}
#else
if (!n->refCount()) {
#if SECURITY_ASSERT_ENABLED
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);
}
#endif
}
container.setLastChild(0);
}
}
inline void ChildNodeInsertionNotifier::notifyNodeInsertedIntoDocument(Node& node)
{
ASSERT(m_insertionPoint.inDocument());
RefPtr<Node> protect(node);
if (Node::InsertionShouldCallDidNotifySubtreeInsertions == node.insertedInto(&m_insertionPoint))
m_postInsertionNotificationTargets.append(&node);
if (node.isContainerNode())
notifyDescendantInsertedIntoDocument(toContainerNode(node));
}
inline void ChildNodeInsertionNotifier::notifyNodeInsertedIntoTree(ContainerNode& node)
{
NoEventDispatchAssertion assertNoEventDispatch;
ASSERT(!m_insertionPoint.inDocument());
if (Node::InsertionShouldCallDidNotifySubtreeInsertions == node.insertedInto(&m_insertionPoint))
m_postInsertionNotificationTargets.append(&node);
notifyDescendantInsertedIntoTree(node);
}
inline void ChildNodeInsertionNotifier::notify(Node& node)
{
ASSERT(!NoEventDispatchAssertion::isEventDispatchForbidden());
InspectorInstrumentation::didInsertDOMNode(&node);
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) {
Node* targetNode = m_postInsertionNotificationTargets[i].get();
if (targetNode->inDocument())
targetNode->didNotifySubtreeInsertionsToDocument();
}
}
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));
}
class ChildFrameDisconnector {
public:
enum DisconnectPolicy {
RootAndDescendants,
DescendantsOnly
};
explicit ChildFrameDisconnector(Node& root)
: m_root(root)
{
}
void disconnect(DisconnectPolicy = RootAndDescendants);
private:
void collectFrameOwners(Node& root);
void collectFrameOwners(ElementShadow&);
void disconnectCollectedFrameOwners();
Vector<RefPtr<HTMLFrameOwnerElement>, 10> m_frameOwners;
Node& m_root;
};
#ifndef NDEBUG
unsigned assertConnectedSubrameCountIsConsistent(Node&);
#endif
inline void ChildFrameDisconnector::collectFrameOwners(Node& root)
{
if (!root.connectedSubframeCount())
return;
if (root.isHTMLElement() && root.isFrameOwnerElement())
m_frameOwners.append(&toHTMLFrameOwnerElement(root));
for (Node* child = root.firstChild(); child; child = child->nextSibling())
collectFrameOwners(*child);
ElementShadow* shadow = root.isElementNode() ? toElement(root).shadow() : 0;
if (shadow)
collectFrameOwners(*shadow);
}
inline void ChildFrameDisconnector::disconnectCollectedFrameOwners()
{
SubframeLoadingDisabler disabler(m_root);
for (unsigned i = 0; i < m_frameOwners.size(); ++i) {
HTMLFrameOwnerElement* owner = m_frameOwners[i].get();
if (!i || m_root.containsIncludingShadowDOM(owner))
owner->disconnectContentFrame();
}
}
inline void ChildFrameDisconnector::disconnect(DisconnectPolicy policy)
{
#ifndef NDEBUG
assertConnectedSubrameCountIsConsistent(m_root);
#endif
if (!m_root.connectedSubframeCount())
return;
if (policy == RootAndDescendants)
collectFrameOwners(m_root);
else {
for (Node* child = m_root.firstChild(); child; child = child->nextSibling())
collectFrameOwners(*child);
}
disconnectCollectedFrameOwners();
}
}
#endif