static bool anyAttributeMatches(Element& element, CSSSelector::Match match, const CSSSelector& selector)
{
const QualifiedName& selectorAttr = selector.attribute();
ASSERT(selectorAttr.localName() != starAtom); // Should not be possible from the CSS grammar.
// Synchronize the attribute in case it is lazy-computed.
element.synchronizeAttribute(selectorAttr.localName());
const AtomicString& selectorValue = selector.value();
bool caseInsensitive = selector.attributeMatchType() == CSSSelector::CaseInsensitive;
AttributeCollection attributes = element.attributesWithoutUpdate();
AttributeCollection::iterator end = attributes.end();
for (AttributeCollection::iterator it = attributes.begin(); it != end; ++it) {
const Attribute& attributeItem = *it;
if (!attributeItem.matches(selectorAttr))
continue;
if (attributeValueMatches(attributeItem, match, selectorValue, !caseInsensitive))
return true;
}
return false;
}
void Element::cloneAttributesFromElement(const Element& other)
{
other.synchronizeAllAttributes();
if (!other.m_elementData) {
m_elementData.clear();
return;
}
const AtomicString& oldID = getIdAttribute();
const AtomicString& newID = other.getIdAttribute();
if (!oldID.isNull() || !newID.isNull())
updateId(oldID, newID);
// If 'other' has a mutable ElementData, convert it to an immutable one so we can share it between both elements.
// We can only do this if there are no presentation attributes and sharing the data won't result in different case sensitivity of class or id.
if (other.m_elementData->isUnique())
const_cast<Element&>(other).m_elementData = toUniqueElementData(other.m_elementData)->makeShareableCopy();
if (!other.m_elementData->isUnique())
m_elementData = other.m_elementData;
else
m_elementData = other.m_elementData->makeUniqueCopy();
AttributeCollection attributes = m_elementData->attributes();
AttributeCollection::iterator end = attributes.end();
for (AttributeCollection::iterator it = attributes.begin(); it != end; ++it)
attributeChangedFromParserOrByCloning(it->name(), it->value(), ModifiedByCloning);
}
PassRefPtr<Attr> NamedNodeMap::item(unsigned index) const
{
AttributeCollection attributes = m_element->attributes();
if (index >= attributes.size())
return nullptr;
return m_element->ensureAttr(attributes[index].name());
}
void StyledMarkupAccumulator::appendElement(StringBuilder& out, Element& element, bool addDisplayInline)
{
const bool documentIsHTML = element.document().isHTMLDocument();
appendOpenTag(out, element, 0);
const bool shouldAnnotateOrForceInline = element.isHTMLElement() && (shouldAnnotate() || addDisplayInline);
const bool shouldOverrideStyleAttr = shouldAnnotateOrForceInline || shouldApplyWrappingStyle(element);
AttributeCollection attributes = element.attributes();
AttributeCollection::iterator end = attributes.end();
for (AttributeCollection::iterator it = attributes.begin(); it != end; ++it) {
// We'll handle the style attribute separately, below.
if (it->name() == HTMLNames::styleAttr && shouldOverrideStyleAttr)
continue;
appendAttribute(out, element, *it, 0);
}
if (shouldOverrideStyleAttr) {
RefPtr<EditingStyle> newInlineStyle = nullptr;
if (shouldApplyWrappingStyle(element)) {
newInlineStyle = m_wrappingStyle->copy();
newInlineStyle->removePropertiesInElementDefaultStyle(&element);
newInlineStyle->removeStyleConflictingWithStyleOfElement(&element);
} else
newInlineStyle = EditingStyle::create();
if (element.isStyledElement() && element.inlineStyle())
newInlineStyle->overrideWithStyle(element.inlineStyle());
if (shouldAnnotateOrForceInline) {
if (shouldAnnotate())
newInlineStyle->mergeStyleFromRulesForSerialization(&toHTMLElement(element));
if (&element == m_highestNodeToBeSerialized && m_shouldAnnotate == AnnotateForNavigationTransition)
newInlineStyle->addAbsolutePositioningFromElement(element);
if (addDisplayInline)
newInlineStyle->forceInline();
}
if (!newInlineStyle->isEmpty()) {
out.appendLiteral(" style=\"");
appendAttributeValue(out, newInlineStyle->style()->asText(), documentIsHTML);
out.append('\"');
}
}
appendCloseTag(out, element);
}
bool DOMPatchSupport::innerPatchNode(Digest* oldDigest, Digest* newDigest, ExceptionState& exceptionState)
{
if (oldDigest->m_sha1 == newDigest->m_sha1)
return true;
Node* oldNode = oldDigest->m_node;
Node* newNode = newDigest->m_node;
if (newNode->nodeType() != oldNode->nodeType() || newNode->nodeName() != oldNode->nodeName())
return m_domEditor->replaceChild(oldNode->parentNode(), newNode, oldNode, exceptionState);
if (oldNode->nodeValue() != newNode->nodeValue()) {
if (!m_domEditor->setNodeValue(oldNode, newNode->nodeValue(), exceptionState))
return false;
}
if (!oldNode->isElementNode())
return true;
// Patch attributes
Element* oldElement = toElement(oldNode);
Element* newElement = toElement(newNode);
if (oldDigest->m_attrsSHA1 != newDigest->m_attrsSHA1) {
// FIXME: Create a function in Element for removing all properties. Take in account whether did/willModifyAttribute are important.
if (oldElement->hasAttributesWithoutUpdate()) {
while (oldElement->attributeCount()) {
const Attribute& attribute = oldElement->attributeAt(0);
if (!m_domEditor->removeAttribute(oldElement, attribute.localName(), exceptionState))
return false;
}
}
// FIXME: Create a function in Element for copying properties. cloneDataFromElement() is close but not enough for this case.
if (newElement->hasAttributesWithoutUpdate()) {
AttributeCollection attributes = newElement->attributes();
AttributeCollection::const_iterator end = attributes.end();
for (AttributeCollection::const_iterator it = attributes.begin(); it != end; ++it) {
if (!m_domEditor->setAttribute(oldElement, it->name().localName(), it->value(), exceptionState))
return false;
}
}
}
bool result = innerPatchChildren(oldElement, oldDigest->m_children, newDigest->m_children, exceptionState);
m_unusedNodesMap.remove(newDigest->m_sha1);
return result;
}
PassOwnPtr<DOMPatchSupport::Digest> DOMPatchSupport::createDigest(Node* node, UnusedNodesMap* unusedNodesMap)
{
Digest* digest = new Digest(node);
OwnPtr<blink::WebCryptoDigestor> digestor = createDigestor(HashAlgorithmSha1);
DigestValue digestResult;
Node::NodeType nodeType = node->nodeType();
digestor->consume(reinterpret_cast<const unsigned char*>(&nodeType), sizeof(nodeType));
addStringToDigestor(digestor.get(), node->nodeName());
addStringToDigestor(digestor.get(), node->nodeValue());
if (node->isElementNode()) {
Element& element = toElement(*node);
Node* child = element.firstChild();
while (child) {
OwnPtr<Digest> childInfo = createDigest(child, unusedNodesMap);
addStringToDigestor(digestor.get(), childInfo->m_sha1);
child = child->nextSibling();
digest->m_children.append(childInfo.release());
}
if (element.hasAttributesWithoutUpdate()) {
OwnPtr<blink::WebCryptoDigestor> attrsDigestor = createDigestor(HashAlgorithmSha1);
AttributeCollection attributes = element.attributes();
AttributeCollection::const_iterator end = attributes.end();
for (AttributeCollection::const_iterator it = attributes.begin(); it != end; ++it) {
addStringToDigestor(attrsDigestor.get(), it->name().toString());
addStringToDigestor(attrsDigestor.get(), it->value().string());
}
finishDigestor(attrsDigestor.get(), digestResult);
digest->m_attrsSHA1 = base64Encode(reinterpret_cast<const char*>(digestResult.data()), 10);
addStringToDigestor(digestor.get(), digest->m_attrsSHA1);
digestResult.clear();
}
}
finishDigestor(digestor.get(), digestResult);
digest->m_sha1 = base64Encode(reinterpret_cast<const char*>(digestResult.data()), 10);
if (unusedNodesMap)
unusedNodesMap->add(digest->m_sha1, digest);
return adoptPtr(digest);
}
void Element::setAttribute(const AtomicString& localName, const AtomicString& value, ExceptionState& exceptionState)
{
if (!Document::isValidName(localName)) {
exceptionState.ThrowDOMException(InvalidCharacterError, "'" + localName + "' is not a valid attribute name.");
return;
}
synchronizeAttribute(localName);
if (!elementData()) {
setAttributeInternal(kNotFound, QualifiedName(localName), value, NotInSynchronizationOfLazyAttribute);
return;
}
AttributeCollection attributes = elementData()->attributes();
size_t index = attributes.findIndex(localName);
const QualifiedName& qName = index != kNotFound ? attributes[index].name() : QualifiedName(localName);
setAttributeInternal(index, qName, value, NotInSynchronizationOfLazyAttribute);
}
void NodeSet::traversalSort() const
{
WillBeHeapHashSet<RawPtrWillBeMember<Node> > nodes;
bool containsAttributeNodes = false;
unsigned nodeCount = m_nodes.size();
ASSERT(nodeCount > 1);
for (unsigned i = 0; i < nodeCount; ++i) {
Node* node = m_nodes[i].get();
nodes.add(node);
if (node->isAttributeNode())
containsAttributeNodes = true;
}
WillBeHeapVector<RefPtrWillBeMember<Node> > sortedNodes;
sortedNodes.reserveInitialCapacity(nodeCount);
for (Node* n = findRootNode(m_nodes.first().get()); n; n = NodeTraversal::next(*n)) {
if (nodes.contains(n))
sortedNodes.append(n);
if (!containsAttributeNodes || !n->isElementNode())
continue;
Element* element = toElement(n);
if (!element->hasAttributes())
continue;
AttributeCollection attributes = element->attributes();
AttributeCollection::const_iterator end = attributes.end();
for (AttributeCollection::const_iterator it = attributes.begin(); it != end; ++it) {
RefPtrWillBeRawPtr<Attr> attr = element->attrIfExists(it->name());
if (attr && nodes.contains(attr.get()))
sortedNodes.append(attr);
}
}
ASSERT(sortedNodes.size() == nodeCount);
const_cast<WillBeHeapVector<RefPtrWillBeMember<Node> >&>(m_nodes).swap(sortedNodes);
}
AtomicString Element::computeInheritedLanguage() const
{
const Node* n = this;
AtomicString value;
// The language property is inherited, so we iterate over the parents to find the first language.
do {
if (n->isElementNode()) {
if (const ElementData* elementData = toElement(n)->elementData()) {
AttributeCollection attributes = elementData->attributes();
if (const Attribute* attribute = attributes.find(HTMLNames::langAttr))
value = attribute->value();
}
} else if (n->isDocumentNode()) {
// checking the MIME content-language
value = toDocument(n)->contentLanguage();
}
n = n->parentNode();
} while (n && value.isNull());
return value;
}
bool ElementData::isEquivalent(const ElementData* other) const
{
AttributeCollection attributes = this->attributes();
if (!other)
return attributes.isEmpty();
AttributeCollection otherAttributes = other->attributes();
if (attributes.size() != otherAttributes.size())
return false;
AttributeCollection::iterator end = attributes.end();
for (AttributeCollection::iterator it = attributes.begin(); it != end; ++it) {
const Attribute* otherAttr = otherAttributes.find(it->name());
if (!otherAttr || it->value() != otherAttr->value())
return false;
}
return true;
}
bool ElementData::isEquivalent(const ElementData* other) const
{
AttributeCollection attributes = this->attributes();
if (!other)
return attributes.isEmpty();
AttributeCollection otherAttributes = other->attributes();
if (attributes.size() != otherAttributes.size())
return false;
for (const Attribute& attribute : attributes) {
const Attribute* otherAttr = otherAttributes.find(attribute.name());
if (!otherAttr || attribute.value() != otherAttr->value())
return false;
}
return true;
}
// TODO(yosin): We should utilize |MarkupFormatter| here to share code,
// especially escaping attribute values, done by |WebEntities| |m_htmlEntities|
// and |m_xmlEntities|.
void WebPageSerializerImpl::openTagToString(Element* element,
SerializeDomParam* param)
{
bool needSkip;
StringBuilder result;
// Do pre action for open tag.
result.append(preActionBeforeSerializeOpenTag(element, param, &needSkip));
if (needSkip)
return;
// Add open tag
result.append('<');
result.append(element->nodeName().lower());
// Go through all attributes and serialize them.
AttributeCollection attributes = element->attributes();
AttributeCollection::iterator end = attributes.end();
for (AttributeCollection::iterator it = attributes.begin(); it != end; ++it) {
result.append(' ');
// Add attribute pair
result.append(it->name().toString());
result.appendLiteral("=\"");
if (!it->value().isEmpty()) {
const String& attrValue = it->value();
// Check whether we need to replace some resource links
// with local resource paths.
const QualifiedName& attrName = it->name();
if (element->hasLegalLinkAttribute(attrName)) {
// For links start with "javascript:", we do not change it.
if (attrValue.startsWith("javascript:", TextCaseInsensitive)) {
result.append(m_htmlEntities.convertEntitiesInString(attrValue));
} else {
// Get the absolute link
WebLocalFrameImpl* subFrame = WebLocalFrameImpl::fromFrameOwnerElement(element);
String completeURL = subFrame ? subFrame->frame()->document()->url() :
param->document->completeURL(attrValue);
// Check whether we have local files for those link.
if (m_localLinks.contains(completeURL)) {
if (!param->directoryName.isEmpty()) {
result.appendLiteral("./");
result.append(param->directoryName);
result.append('/');
}
result.append(m_htmlEntities.convertEntitiesInString(m_localLinks.get(completeURL)));
} else {
result.append(m_htmlEntities.convertEntitiesInString(completeURL));
}
}
} else {
if (param->isHTMLDocument)
result.append(m_htmlEntities.convertEntitiesInString(attrValue));
else
result.append(m_xmlEntities.convertEntitiesInString(attrValue));
}
}
result.append('\"');
}
// Do post action for open tag.
String addedContents = postActionAfterSerializeOpenTag(element, param);
// Complete the open tag for element when it has child/children.
if (element->hasChildren() || param->haveAddedContentsBeforeEnd)
result.append('>');
// Append the added contents generate in post action of open tag.
result.append(addedContents);
// Save the result to data buffer.
saveHTMLContentToBuffer(result.toString(), param);
}
// 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();
}
// FIXME: This function should not deal with url or serviceType!
void HTMLObjectElement::parametersForPlugin(Vector<String>& paramNames, Vector<String>& paramValues, String& url, String& serviceType)
{
HashSet<StringImpl*, CaseFoldingHash> uniqueParamNames;
String urlParameter;
// Scan the PARAM children and store their name/value pairs.
// Get the URL and type from the params if we don't already have them.
for (HTMLParamElement* p = Traversal<HTMLParamElement>::firstChild(*this); p; p = Traversal<HTMLParamElement>::nextSibling(*p)) {
String name = p->name();
if (name.isEmpty())
continue;
uniqueParamNames.add(name.impl());
paramNames.append(p->name());
paramValues.append(p->value());
// FIXME: url adjustment does not belong in this function.
if (url.isEmpty() && urlParameter.isEmpty() && (equalIgnoringCase(name, "src") || equalIgnoringCase(name, "movie") || equalIgnoringCase(name, "code") || equalIgnoringCase(name, "url")))
urlParameter = stripLeadingAndTrailingHTMLSpaces(p->value());
// FIXME: serviceType calculation does not belong in this function.
if (serviceType.isEmpty() && equalIgnoringCase(name, "type")) {
serviceType = p->value();
size_t pos = serviceType.find(";");
if (pos != kNotFound)
serviceType = serviceType.left(pos);
}
}
// When OBJECT is used for an applet via Sun's Java plugin, the CODEBASE attribute in the tag
// points to the Java plugin itself (an ActiveX component) while the actual applet CODEBASE is
// in a PARAM tag. See <http://java.sun.com/products/plugin/1.2/docs/tags.html>. This means
// we have to explicitly suppress the tag's CODEBASE attribute if there is none in a PARAM,
// else our Java plugin will misinterpret it. [4004531]
String codebase;
if (MIMETypeRegistry::isJavaAppletMIMEType(serviceType)) {
codebase = "codebase";
uniqueParamNames.add(codebase.impl()); // pretend we found it in a PARAM already
}
// Turn the attributes of the <object> element into arrays, but don't override <param> values.
if (hasAttributes()) {
AttributeCollection attributes = this->attributes();
AttributeCollection::const_iterator end = attributes.end();
for (AttributeCollection::const_iterator it = attributes.begin(); it != end; ++it) {
const AtomicString& name = it->name().localName();
if (!uniqueParamNames.contains(name.impl())) {
paramNames.append(name.string());
paramValues.append(it->value().string());
}
}
}
mapDataParamToSrc(¶mNames, ¶mValues);
// HTML5 says that an object resource's URL is specified by the object's data
// attribute, not by a param element. However, for compatibility, allow the
// resource's URL to be given by a param named "src", "movie", "code" or "url"
// if we know that resource points to a plug-in.
if (url.isEmpty() && !urlParameter.isEmpty()) {
KURL completedURL = document().completeURL(urlParameter);
bool useFallback;
if (shouldUsePlugin(completedURL, serviceType, false, useFallback))
url = urlParameter;
}
}
