Node* V8GCController::opaqueRootForGC(v8::Isolate*, Node* node)
{
ASSERT(node);
// FIXME: Remove the special handling for image elements.
// Maybe should image elements be active DOM nodes?
// See https://code.google.com/p/chromium/issues/detail?id=164882
if (node->inDocument() || (isHTMLImageElement(*node) && toHTMLImageElement(*node).hasPendingActivity())) {
Document& document = node->document();
if (HTMLImportsController* controller = document.importsController())
return controller->master();
return &document;
}
if (node->isAttributeNode()) {
Node* ownerElement = toAttr(node)->ownerElement();
if (!ownerElement)
return node;
node = ownerElement;
}
while (Node* parent = node->parentOrShadowHostOrTemplateHostNode())
node = parent;
return node;
}
static inline String expandedNamespaceURI(Node* node) {
switch (node->getNodeType()) {
case Node::kElementNode:
return toElement(node)->namespaceURI();
case Node::kAttributeNode:
return toAttr(node)->namespaceURI();
default:
return String();
}
}
static Node* findRootNode(Node* node) {
if (node->isAttributeNode())
node = toAttr(node)->ownerElement();
if (node->isConnected()) {
node = &node->document();
} else {
while (Node* parent = node->parentNode())
node = parent;
}
return node;
}
JSValue* jsElementPrototypeFunctionRemoveAttributeNode(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args)
{
if (!thisValue->isObject(&JSElement::s_info))
return throwError(exec, TypeError);
JSElement* castedThisObj = static_cast<JSElement*>(thisValue);
Element* imp = static_cast<Element*>(castedThisObj->impl());
ExceptionCode ec = 0;
Attr* oldAttr = toAttr(args[0]);
KJS::JSValue* result = toJS(exec, WTF::getPtr(imp->removeAttributeNode(oldAttr, ec)));
setDOMException(exec, ec);
return result;
}
static inline String expandedNameLocalPart(Node* node) {
// The local part of an XPath expanded-name matches DOM local name for most
// node types, except for namespace nodes and processing instruction nodes.
// But note that Blink does not support namespace nodes.
switch (node->getNodeType()) {
case Node::kElementNode:
return toElement(node)->localName();
case Node::kAttributeNode:
return toAttr(node)->localName();
case Node::kProcessingInstructionNode:
return toProcessingInstruction(node)->target();
default:
return String();
}
}
static inline String expandedName(Node* node) {
AtomicString prefix;
switch (node->getNodeType()) {
case Node::kElementNode:
prefix = toElement(node)->prefix();
break;
case Node::kAttributeNode:
prefix = toAttr(node)->prefix();
break;
default:
break;
}
return prefix.isEmpty() ? expandedNameLocalPart(node)
: prefix + ":" + expandedNameLocalPart(node);
}
void NodeSet::sort() const
{
if (m_isSorted)
return;
unsigned nodeCount = m_nodes.size();
if (nodeCount < 2) {
const_cast<bool&>(m_isSorted) = true;
return;
}
if (nodeCount > traversalSortCutoff) {
traversalSort();
return;
}
bool containsAttributeNodes = false;
WillBeHeapVector<NodeSetVector> parentMatrix(nodeCount);
for (unsigned i = 0; i < nodeCount; ++i) {
NodeSetVector& parentsVector = parentMatrix[i];
Node* n = m_nodes[i].get();
parentsVector.append(n);
if (n->isAttributeNode()) {
n = toAttr(n)->ownerElement();
parentsVector.append(n);
containsAttributeNodes = true;
}
while ((n = n->parentNode()))
parentsVector.append(n);
}
sortBlock(0, nodeCount, parentMatrix, containsAttributeNodes);
// It is not possible to just assign the result to m_nodes, because some
// nodes may get dereferenced and destroyed.
WillBeHeapVector<RefPtrWillBeMember<Node> > sortedNodes;
sortedNodes.reserveInitialCapacity(nodeCount);
for (unsigned i = 0; i < nodeCount; ++i)
sortedNodes.append(parentMatrix[i][0]);
const_cast<WillBeHeapVector<RefPtrWillBeMember<Node> >&>(m_nodes).swap(sortedNodes);
}
void InspectorNodeFinder::searchUsingXPath(Node* parentNode)
{
ExceptionCode ec = 0;
RefPtr<XPathResult> result = parentNode->document().evaluate(m_whitespaceTrimmedQuery, parentNode, nullptr, XPathResult::ORDERED_NODE_SNAPSHOT_TYPE, nullptr, ec);
if (ec || !result)
return;
unsigned long size = result->snapshotLength(ec);
if (ec)
return;
for (unsigned long i = 0; i < size; ++i) {
Node* node = result->snapshotItem(i, ec);
if (ec)
return;
if (node->isAttributeNode())
node = toAttr(node)->ownerElement();
// XPath can get out of the context node that we pass as the starting point to evaluate, so we need to filter for just the nodes we care about.
if (node == parentNode || node->isDescendantOf(parentNode))
m_results.add(node);
}
}
static void sortBlock(unsigned from, unsigned to, WillBeHeapVector<NodeSetVector>& parentMatrix, bool mayContainAttributeNodes)
{
// Should not call this function with less that two nodes to sort.
ASSERT(from + 1 < to);
unsigned minDepth = UINT_MAX;
for (unsigned i = from; i < to; ++i) {
unsigned depth = parentMatrix[i].size() - 1;
if (minDepth > depth)
minDepth = depth;
}
// Find the common ancestor.
unsigned commonAncestorDepth = minDepth;
Node* commonAncestor;
while (true) {
commonAncestor = parentWithDepth(commonAncestorDepth, parentMatrix[from]);
if (commonAncestorDepth == 0)
break;
bool allEqual = true;
for (unsigned i = from + 1; i < to; ++i) {
if (commonAncestor != parentWithDepth(commonAncestorDepth, parentMatrix[i])) {
allEqual = false;
break;
}
}
if (allEqual)
break;
--commonAncestorDepth;
}
if (commonAncestorDepth == minDepth) {
// One of the nodes is the common ancestor => it is the first in
// document order. Find it and move it to the beginning.
for (unsigned i = from; i < to; ++i) {
if (commonAncestor == parentMatrix[i][0]) {
parentMatrix[i].swap(parentMatrix[from]);
if (from + 2 < to)
sortBlock(from + 1, to, parentMatrix, mayContainAttributeNodes);
return;
}
}
}
if (mayContainAttributeNodes && commonAncestor->isElementNode()) {
// The attribute nodes and namespace nodes of an element occur before
// the children of the element. The namespace nodes are defined to occur
// before the attribute nodes. The relative order of namespace nodes is
// implementation-dependent. The relative order of attribute nodes is
// implementation-dependent.
unsigned sortedEnd = from;
// FIXME: namespace nodes are not implemented.
for (unsigned i = sortedEnd; i < to; ++i) {
Node* n = parentMatrix[i][0];
if (n->isAttributeNode() && toAttr(n)->ownerElement() == commonAncestor)
parentMatrix[i].swap(parentMatrix[sortedEnd++]);
}
if (sortedEnd != from) {
if (to - sortedEnd > 1)
sortBlock(sortedEnd, to, parentMatrix, mayContainAttributeNodes);
return;
}
}
// Children nodes of the common ancestor induce a subdivision of our
// node-set. Sort it according to this subdivision, and recursively sort
// each group.
WillBeHeapHashSet<RawPtrWillBeMember<Node> > parentNodes;
for (unsigned i = from; i < to; ++i)
parentNodes.add(parentWithDepth(commonAncestorDepth + 1, parentMatrix[i]));
unsigned previousGroupEnd = from;
unsigned groupEnd = from;
for (Node* n = commonAncestor->firstChild(); n; n = n->nextSibling()) {
// If parentNodes contains the node, perform a linear search to move its
// children in the node-set to the beginning.
if (parentNodes.contains(n)) {
for (unsigned i = groupEnd; i < to; ++i) {
if (parentWithDepth(commonAncestorDepth + 1, parentMatrix[i]) == n)
parentMatrix[i].swap(parentMatrix[groupEnd++]);
}
if (groupEnd - previousGroupEnd > 1)
sortBlock(previousGroupEnd, groupEnd, parentMatrix, mayContainAttributeNodes);
ASSERT(previousGroupEnd != groupEnd);
previousGroupEnd = groupEnd;
#ifndef NDEBUG
parentNodes.remove(n);
#endif
}
}
ASSERT(parentNodes.isEmpty());
}
// Result nodes are ordered in axis order. Node test (including merged predicates) is applied.
void Step::nodesInAxis(Node* context, NodeSet& nodes) const
{
ASSERT(nodes.isEmpty());
switch (m_axis) {
case ChildAxis:
if (context->isAttributeNode()) // In XPath model, attribute nodes do not have children.
return;
for (Node* n = context->firstChild(); n; n = n->nextSibling())
if (nodeMatches(n, ChildAxis, m_nodeTest))
nodes.append(n);
return;
case DescendantAxis:
if (context->isAttributeNode()) // In XPath model, attribute nodes do not have children.
return;
for (Node* n = context->firstChild(); n; n = NodeTraversal::next(*n, context))
if (nodeMatches(n, DescendantAxis, m_nodeTest))
nodes.append(n);
return;
case ParentAxis:
if (context->isAttributeNode()) {
Element* n = toAttr(context)->ownerElement();
if (nodeMatches(n, ParentAxis, m_nodeTest))
nodes.append(n);
} else {
ContainerNode* n = context->parentNode();
if (n && nodeMatches(n, ParentAxis, m_nodeTest))
nodes.append(n);
}
return;
case AncestorAxis: {
Node* n = context;
if (context->isAttributeNode()) {
n = toAttr(context)->ownerElement();
if (nodeMatches(n, AncestorAxis, m_nodeTest))
nodes.append(n);
}
for (n = n->parentNode(); n; n = n->parentNode())
if (nodeMatches(n, AncestorAxis, m_nodeTest))
nodes.append(n);
nodes.markSorted(false);
return;
}
case FollowingSiblingAxis:
if (context->nodeType() == Node::ATTRIBUTE_NODE ||
context->nodeType() == Node::XPATH_NAMESPACE_NODE)
return;
for (Node* n = context->nextSibling(); n; n = n->nextSibling())
if (nodeMatches(n, FollowingSiblingAxis, m_nodeTest))
nodes.append(n);
return;
case PrecedingSiblingAxis:
if (context->nodeType() == Node::ATTRIBUTE_NODE ||
context->nodeType() == Node::XPATH_NAMESPACE_NODE)
return;
for (Node* n = context->previousSibling(); n; n = n->previousSibling())
if (nodeMatches(n, PrecedingSiblingAxis, m_nodeTest))
nodes.append(n);
nodes.markSorted(false);
return;
case FollowingAxis:
if (context->isAttributeNode()) {
Node* p = toAttr(context)->ownerElement();
while ((p = NodeTraversal::next(*p))) {
if (nodeMatches(p, FollowingAxis, m_nodeTest))
nodes.append(p);
}
} else {
for (Node* p = context; !isRootDomNode(p); p = p->parentNode()) {
for (Node* n = p->nextSibling(); n; n = n->nextSibling()) {
if (nodeMatches(n, FollowingAxis, m_nodeTest))
nodes.append(n);
for (Node* c = n->firstChild(); c; c = NodeTraversal::next(*c, n))
if (nodeMatches(c, FollowingAxis, m_nodeTest))
nodes.append(c);
}
}
}
return;
case PrecedingAxis: {
if (context->isAttributeNode())
context = toAttr(context)->ownerElement();
Node* n = context;
while (ContainerNode* parent = n->parentNode()) {
for (n = NodeTraversal::previous(*n); n != parent; n = NodeTraversal::previous(*n))
if (nodeMatches(n, PrecedingAxis, m_nodeTest))
nodes.append(n);
n = parent;
}
nodes.markSorted(false);
return;
}
case AttributeAxis: {
if (!context->isElementNode())
return;
Element* contextElement = toElement(context);
// Avoid lazily creating attribute nodes for attributes that we do not need anyway.
if (m_nodeTest.kind() == NodeTest::NameTest && m_nodeTest.data() != starAtom) {
RefPtr<Node> n = contextElement->getAttributeNodeNS(m_nodeTest.namespaceURI(), m_nodeTest.data());
if (n && n->namespaceURI() != XMLNSNames::xmlnsNamespaceURI) { // In XPath land, namespace nodes are not accessible on the attribute axis.
if (nodeMatches(n.get(), AttributeAxis, m_nodeTest)) // Still need to check merged predicates.
nodes.append(n.release());
}
return;
}
if (!contextElement->hasAttributes())
return;
for (unsigned i = 0; i < contextElement->attributeCount(); ++i) {
RefPtr<Attr> attr = contextElement->ensureAttr(contextElement->attributeItem(i)->name());
if (nodeMatches(attr.get(), AttributeAxis, m_nodeTest))
nodes.append(attr.release());
}
return;
}
case NamespaceAxis:
// XPath namespace nodes are not implemented yet.
return;
case SelfAxis:
if (nodeMatches(context, SelfAxis, m_nodeTest))
nodes.append(context);
return;
case DescendantOrSelfAxis:
if (nodeMatches(context, DescendantOrSelfAxis, m_nodeTest))
nodes.append(context);
if (context->isAttributeNode()) // In XPath model, attribute nodes do not have children.
return;
for (Node* n = context->firstChild(); n; n = NodeTraversal::next(*n, context))
if (nodeMatches(n, DescendantOrSelfAxis, m_nodeTest))
nodes.append(n);
return;
case AncestorOrSelfAxis: {
if (nodeMatches(context, AncestorOrSelfAxis, m_nodeTest))
nodes.append(context);
Node* n = context;
if (context->isAttributeNode()) {
n = toAttr(context)->ownerElement();
if (nodeMatches(n, AncestorOrSelfAxis, m_nodeTest))
nodes.append(n);
}
for (n = n->parentNode(); n; n = n->parentNode())
if (nodeMatches(n, AncestorOrSelfAxis, m_nodeTest))
nodes.append(n);
nodes.markSorted(false);
return;
}
}
ASSERT_NOT_REACHED();
}
// Result nodes are ordered in axis order. Node test (including merged
// predicates) is applied.
void Step::nodesInAxis(EvaluationContext& evaluationContext, Node* context, NodeSet& nodes) const
{
ASSERT(nodes.isEmpty());
switch (m_axis) {
case ChildAxis:
// In XPath model, attribute nodes do not have children.
if (context->isAttributeNode())
return;
for (Node* n = context->firstChild(); n; n = n->nextSibling()) {
if (nodeMatches(evaluationContext, n, ChildAxis, nodeTest()))
nodes.append(n);
}
return;
case DescendantAxis:
// In XPath model, attribute nodes do not have children.
if (context->isAttributeNode())
return;
for (Node* n = context->firstChild(); n; n = NodeTraversal::next(*n, context)) {
if (nodeMatches(evaluationContext, n, DescendantAxis, nodeTest()))
nodes.append(n);
}
return;
case ParentAxis:
if (context->isAttributeNode()) {
Element* n = toAttr(context)->ownerElement();
if (nodeMatches(evaluationContext, n, ParentAxis, nodeTest()))
nodes.append(n);
} else {
ContainerNode* n = context->parentNode();
if (n && nodeMatches(evaluationContext, n, ParentAxis, nodeTest()))
nodes.append(n);
}
return;
case AncestorAxis: {
Node* n = context;
if (context->isAttributeNode()) {
n = toAttr(context)->ownerElement();
if (nodeMatches(evaluationContext, n, AncestorAxis, nodeTest()))
nodes.append(n);
}
for (n = n->parentNode(); n; n = n->parentNode()) {
if (nodeMatches(evaluationContext, n, AncestorAxis, nodeTest()))
nodes.append(n);
}
nodes.markSorted(false);
return;
}
case FollowingSiblingAxis:
if (context->nodeType() == Node::ATTRIBUTE_NODE)
return;
for (Node* n = context->nextSibling(); n; n = n->nextSibling()) {
if (nodeMatches(evaluationContext, n, FollowingSiblingAxis, nodeTest()))
nodes.append(n);
}
return;
case PrecedingSiblingAxis:
if (context->nodeType() == Node::ATTRIBUTE_NODE)
return;
for (Node* n = context->previousSibling(); n; n = n->previousSibling()) {
if (nodeMatches(evaluationContext, n, PrecedingSiblingAxis, nodeTest()))
nodes.append(n);
}
nodes.markSorted(false);
return;
case FollowingAxis:
if (context->isAttributeNode()) {
for (Node* p = NodeTraversal::next(*toAttr(context)->ownerElement()); p; p = NodeTraversal::next(*p)) {
if (nodeMatches(evaluationContext, p, FollowingAxis, nodeTest()))
nodes.append(p);
}
} else {
for (Node* p = context; !isRootDomNode(p); p = p->parentNode()) {
for (Node* n = p->nextSibling(); n; n = n->nextSibling()) {
if (nodeMatches(evaluationContext, n, FollowingAxis, nodeTest()))
nodes.append(n);
for (Node* c = n->firstChild(); c; c = NodeTraversal::next(*c, n)) {
if (nodeMatches(evaluationContext, c, FollowingAxis, nodeTest()))
nodes.append(c);
}
}
}
}
return;
case PrecedingAxis: {
if (context->isAttributeNode())
context = toAttr(context)->ownerElement();
Node* n = context;
while (ContainerNode* parent = n->parentNode()) {
for (n = NodeTraversal::previous(*n); n != parent; n = NodeTraversal::previous(*n)) {
if (nodeMatches(evaluationContext, n, PrecedingAxis, nodeTest()))
nodes.append(n);
}
n = parent;
}
nodes.markSorted(false);
return;
}
case AttributeAxis: {
if (!context->isElementNode())
return;
Element* contextElement = toElement(context);
// Avoid lazily creating attribute nodes for attributes that we do not
// need anyway.
if (nodeTest().kind() == NodeTest::NameTest && nodeTest().data() != starAtom) {
RefPtrWillBeRawPtr<Node> n = contextElement->getAttributeNodeNS(nodeTest().namespaceURI(), nodeTest().data());
// In XPath land, namespace nodes are not accessible on the attribute axis.
if (n && n->namespaceURI() != XMLNSNames::xmlnsNamespaceURI) {
// Still need to check merged predicates.
if (nodeMatches(evaluationContext, n.get(), AttributeAxis, nodeTest()))
nodes.append(n.release());
}
return;
}
AttributeCollection attributes = contextElement->attributes();
AttributeCollection::iterator end = attributes.end();
for (AttributeCollection::iterator it = attributes.begin(); it != end; ++it) {
RefPtrWillBeRawPtr<Attr> attr = contextElement->ensureAttr(it->name());
if (nodeMatches(evaluationContext, attr.get(), AttributeAxis, nodeTest()))
nodes.append(attr.release());
}
return;
}
case NamespaceAxis:
// XPath namespace nodes are not implemented.
return;
case SelfAxis:
if (nodeMatches(evaluationContext, context, SelfAxis, nodeTest()))
nodes.append(context);
return;
case DescendantOrSelfAxis:
if (nodeMatches(evaluationContext, context, DescendantOrSelfAxis, nodeTest()))
nodes.append(context);
// In XPath model, attribute nodes do not have children.
if (context->isAttributeNode())
return;
for (Node* n = context->firstChild(); n; n = NodeTraversal::next(*n, context)) {
if (nodeMatches(evaluationContext, n, DescendantOrSelfAxis, nodeTest()))
nodes.append(n);
}
return;
case AncestorOrSelfAxis: {
if (nodeMatches(evaluationContext, context, AncestorOrSelfAxis, nodeTest()))
nodes.append(context);
Node* n = context;
if (context->isAttributeNode()) {
n = toAttr(context)->ownerElement();
if (nodeMatches(evaluationContext, n, AncestorOrSelfAxis, nodeTest()))
nodes.append(n);
}
for (n = n->parentNode(); n; n = n->parentNode()) {
if (nodeMatches(evaluationContext, n, AncestorOrSelfAxis, nodeTest()))
nodes.append(n);
}
nodes.markSorted(false);
return;
}
}
ASSERT_NOT_REACHED();
}