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);
}
static HTMLElement* ancestorToRetainStructureAndAppearanceForBlock(
Element* commonAncestorBlock) {
if (!commonAncestorBlock)
return 0;
if (commonAncestorBlock->hasTagName(tbodyTag) ||
isHTMLTableRowElement(*commonAncestorBlock))
return Traversal<HTMLTableElement>::firstAncestor(*commonAncestorBlock);
if (isNonTableCellHTMLBlockElement(commonAncestorBlock))
return toHTMLElement(commonAncestorBlock);
return 0;
}
void HTMLElement::adjustDirectionalityIfNeededAfterChildrenChanged(const ChildrenChange& change)
{
if (!selfOrAncestorHasDirAutoAttribute())
return;
updateDistribution();
for (Element* elementToAdjust = this; elementToAdjust; elementToAdjust = ComposedTreeTraversal::parentElement(*elementToAdjust)) {
if (elementAffectsDirectionality(elementToAdjust)) {
toHTMLElement(elementToAdjust)->calculateAndAdjustDirectionality();
return;
}
}
}
bool HTMLElement::translate() const
{
for (const Node* n = this; n; n = n->parentNode()) {
if (n->isHTMLElement()) {
TranslateAttributeMode mode = toHTMLElement(n)->translateAttributeMode();
if (mode != TranslateAttributeInherit) {
ASSERT(mode == TranslateAttributeYes || mode == TranslateAttributeNo);
return mode == TranslateAttributeYes;
}
}
}
// Default on the root element is translate=yes.
return true;
}
void BaseChooserOnlyDateAndTimeInputType::updateView()
{
Node* node = element().userAgentShadowRoot()->firstChild();
if (!node || !node->isHTMLElement())
return;
String displayValue;
if (!element().suggestedValue().isNull())
displayValue = element().suggestedValue();
else
displayValue = visibleValue();
if (displayValue.isEmpty()) {
// Need to put something to keep text baseline.
displayValue = " ";
}
toHTMLElement(node)->setInnerText(displayValue, ASSERT_NO_EXCEPTION);
}
v8::Handle<v8::Object> CustomElementHelpers::createUpgradeCandidateWrapper(PassRefPtr<Element> element, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate, const CreateWrapperFunction& createTypeExtensionUpgradeCandidateWrapper)
{
if (CustomElementRegistry::isCustomTagName(element->localName())) {
if (element->isHTMLElement())
return createV8HTMLDirectWrapper(toHTMLElement(element.get()), creationContext, isolate);
else if (element->isSVGElement())
return createV8SVGDirectWrapper(toSVGElement(element.get()), creationContext, isolate);
else {
ASSERT(0);
return v8::Handle<v8::Object>();
}
} else {
// It's a type extension
return createTypeExtensionUpgradeCandidateWrapper.invoke(element.get(), creationContext, isolate);
}
}
void ElementRuleCollector::matchAllRules(bool matchAuthorAndUserStyles, bool includeSMILProperties)
{
matchUARules();
// Now we check user sheet rules.
if (matchAuthorAndUserStyles)
matchUserRules(false);
// Now check author rules, beginning first with presentational attributes mapped from HTML.
if (m_state.styledElement()) {
addElementStyleProperties(m_state.styledElement()->presentationAttributeStyle());
// Now we check additional mapped declarations.
// Tables and table cells share an additional mapped rule that must be applied
// after all attributes, since their mapped style depends on the values of multiple attributes.
addElementStyleProperties(m_state.styledElement()->additionalPresentationAttributeStyle());
if (m_state.styledElement()->isHTMLElement()) {
bool isAuto;
TextDirection textDirection = toHTMLElement(m_state.styledElement())->directionalityIfhasDirAutoAttribute(isAuto);
if (isAuto)
m_result.addMatchedProperties(textDirection == LTR ? leftToRightDeclaration() : rightToLeftDeclaration());
}
}
// Check the rules in author sheets next.
if (matchAuthorAndUserStyles)
matchAuthorRules(false);
// Now check our inline style attribute.
if (matchAuthorAndUserStyles && m_state.styledElement() && m_state.styledElement()->inlineStyle()) {
// Inline style is immutable as long as there is no CSSOM wrapper.
// FIXME: Media control shadow trees seem to have problems with caching.
bool isInlineStyleCacheable = !m_state.styledElement()->inlineStyle()->isMutable() && !m_state.styledElement()->isInShadowTree();
// FIXME: Constify.
addElementStyleProperties(m_state.styledElement()->inlineStyle(), isInlineStyleCacheable);
}
#if ENABLE(SVG)
// Now check SMIL animation override style.
if (includeSMILProperties && matchAuthorAndUserStyles && m_state.styledElement() && m_state.styledElement()->isSVGElement())
addElementStyleProperties(toSVGElement(m_state.styledElement())->animatedSMILStyleProperties(), false /* isCacheable */);
#else
UNUSED_PARAM(includeSMILProperties);
#endif
}
static HTMLElement* highestAncestorToWrapMarkup(const Range* range, EAnnotateForInterchange shouldAnnotate, Node* constrainingAncestor)
{
Node* commonAncestor = range->commonAncestorContainer();
ASSERT(commonAncestor);
HTMLElement* specialCommonAncestor = 0;
Node* checkAncestor = specialCommonAncestor ? specialCommonAncestor : commonAncestor;
if (checkAncestor->renderer()) {
HTMLElement* newSpecialCommonAncestor = toHTMLElement(highestEnclosingNodeOfType(firstPositionInNode(checkAncestor), &isPresentationalHTMLElement, CanCrossEditingBoundary, constrainingAncestor));
if (newSpecialCommonAncestor)
specialCommonAncestor = newSpecialCommonAncestor;
}
if (HTMLAnchorElement* enclosingAnchor = toHTMLAnchorElement(enclosingElementWithTag(firstPositionInNode(specialCommonAncestor ? specialCommonAncestor : commonAncestor), HTMLNames::aTag)))
specialCommonAncestor = enclosingAnchor;
return specialCommonAncestor;
}
HTMLElement* CustomElement::createUndefinedElement(Document& document, const QualifiedName& tagName)
{
DCHECK(shouldCreateCustomElement(document, tagName));
HTMLElement* element;
if (V0CustomElement::isValidName(tagName.localName()) && document.registrationContext()) {
Element* v0element = document.registrationContext()->createCustomTagElement(document, tagName);
SECURITY_DCHECK(v0element->isHTMLElement());
element = toHTMLElement(v0element);
} else {
element = HTMLElement::create(tagName, document);
}
element->setCustomElementState(CustomElementState::Undefined);
return element;
}
static bool isCharsetSpecifyingNode(const Node& node)
{
if (!node.isHTMLElement())
return false;
const HTMLElement& element = toHTMLElement(node);
if (!element.hasTagName(HTMLNames::metaTag))
return false;
HTMLMetaCharsetParser::AttributeList attributes;
if (element.hasAttributes()) {
for (const Attribute& attribute : element.attributesIterator()) {
// FIXME: We should deal appropriately with the attribute if they have a namespace.
attributes.append(std::make_pair(attribute.name().toString(), attribute.value().string()));
}
}
TextEncoding textEncoding = HTMLMetaCharsetParser::encodingFromMetaAttributes(attributes);
return textEncoding.isValid();
}
static bool isCharsetSpecifyingNode(Node* node)
{
if (!node->isHTMLElement())
return false;
HTMLElement* element = toHTMLElement(node);
if (!element->hasTagName(HTMLNames::metaTag))
return false;
HTMLMetaCharsetParser::AttributeList attributes;
const NamedNodeMap* attributesMap = element->attributes(true);
for (unsigned i = 0; i < attributesMap->length(); ++i) {
Attribute* item = attributesMap->attributeItem(i);
// FIXME: We should deal appropriately with the attribute if they have a namespace.
attributes.append(make_pair(item->name().toString(), item->value().string()));
}
TextEncoding textEncoding = HTMLMetaCharsetParser::encodingFromMetaAttributes(attributes);
return textEncoding.isValid();
}
static bool isCharsetSpecifyingNode(Node* node)
{
if (!node->isHTMLElement())
return false;
HTMLElement* element = toHTMLElement(node);
if (!element->hasTagName(HTMLNames::metaTag))
return false;
HTMLMetaCharsetParser::AttributeList attributes;
if (element->hasAttributes()) {
for (unsigned i = 0; i < element->attributeCount(); ++i) {
const Attribute* attribute = element->attributeItem(i);
// FIXME: We should deal appropriately with the attribute if they have a namespace.
attributes.append(std::make_pair(attribute->name().toString(), attribute->value().string()));
}
}
WTF::TextEncoding textEncoding = HTMLMetaCharsetParser::encodingFromMetaAttributes(attributes);
return textEncoding.isValid();
}
bool HTMLCollection::checkForNameMatch(Element* element, bool checkName, const AtomicString& name) const
{
if (!element->isHTMLElement())
return false;
HTMLElement* e = toHTMLElement(element);
if (!checkName)
return e->getIdAttribute() == name;
// document.all returns only images, forms, applets, objects and embeds
// by name (though everything by id)
if (m_type == DocAll &&
!(e->hasLocalName(imgTag) || e->hasLocalName(formTag) ||
e->hasLocalName(appletTag) || e->hasLocalName(objectTag) ||
e->hasLocalName(embedTag) || e->hasLocalName(inputTag) ||
e->hasLocalName(selectTag)))
return false;
return e->getAttribute(nameAttr) == name && e->getIdAttribute() != name;
}
void FormAssociatedElement::resetFormOwner()
{
m_formWasSetByParser = false;
HTMLElement* element = toHTMLElement(this);
const AtomicString& formId(element->fastGetAttribute(formAttr));
HTMLFormElement* nearestForm = element->findFormAncestor();
// 1. If the element's form owner is not null, and either the element is not
// reassociateable or its form content attribute is not present, and the
// element's form owner is its nearest form element ancestor after the
// change to the ancestor chain, then do nothing, and abort these steps.
if (m_form && formId.isNull() && m_form.get() == nearestForm)
return;
HTMLFormElement* originalForm = m_form.get();
setForm(findAssociatedForm(element));
// FIXME: Move didAssociateFormControl call to didChangeForm or
// HTMLFormElement::associate.
if (m_form && m_form.get() != originalForm && m_form->inDocument())
element->document().didAssociateFormControl(element);
}
// These functions are custom to prevent a wrapper lookup of the return value which is always
// part of the arguments.
v8::Handle<v8::Object> wrap(Node* impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
{
ASSERT(impl);
switch (impl->nodeType()) {
case Node::ELEMENT_NODE:
// For performance reasons, this is inlined from V8Element::wrap and must remain in sync.
if (impl->isHTMLElement())
return wrap(toHTMLElement(impl), creationContext, isolate);
return V8Element::createWrapper(toElement(impl), creationContext, isolate);
case Node::TEXT_NODE:
return wrap(toText(impl), creationContext, isolate);
case Node::DOCUMENT_NODE:
return wrap(toDocument(impl), creationContext, isolate);
case Node::DOCUMENT_FRAGMENT_NODE:
if (impl->isShadowRoot())
return wrap(toShadowRoot(impl), creationContext, isolate);
return wrap(toDocumentFragment(impl), creationContext, isolate);
}
ASSERT_NOT_REACHED();
return V8Node::createWrapper(impl, creationContext, isolate);
}
void HTMLElement::getItemRefElements(Vector<HTMLElement*>& itemRefElements)
{
if (!fastHasAttribute(itemscopeAttr))
return;
if (!fastHasAttribute(itemrefAttr) || !itemRef()->length()) {
itemRefElements.append(this);
return;
}
DOMSettableTokenList* itemRefs = itemRef();
RefPtr<DOMSettableTokenList> processedItemRef = DOMSettableTokenList::create();
Node* rootNode;
if (inDocument())
rootNode = document();
else {
rootNode = this;
while (Node* parent = rootNode->parentNode())
rootNode = parent;
}
for (Node* current = rootNode; current; current = NodeTraversal::next(current, rootNode)) {
if (!current->isHTMLElement())
continue;
HTMLElement* element = toHTMLElement(current);
if (element == this) {
itemRefElements.append(element);
continue;
}
const AtomicString& id = element->getIdAttribute();
if (!processedItemRef->tokens().contains(id) && itemRefs->tokens().contains(id)) {
processedItemRef->setValue(id);
if (!element->isDescendantOf(this))
itemRefElements.append(element);
}
}
}
v8::Handle<v8::Object> wrap(Node* impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
{
ASSERT(impl);
switch (impl->nodeType()) {
case Node::ELEMENT_NODE:
// For performance reasons, this is inlined from V8Element::wrap and must remain in sync.
if (impl->isHTMLElement())
return wrap(toHTMLElement(impl), creationContext, isolate);
#if ENABLE(SVG)
if (impl->isSVGElement())
return wrap(toSVGElement(impl), creationContext, isolate);
#endif
return V8Element::createWrapper(toElement(impl), creationContext, isolate);
case Node::ATTRIBUTE_NODE:
return wrap(static_cast<Attr*>(impl), creationContext, isolate);
case Node::TEXT_NODE:
return wrap(toText(impl), creationContext, isolate);
case Node::CDATA_SECTION_NODE:
return wrap(static_cast<CDATASection*>(impl), creationContext, isolate);
case Node::ENTITY_REFERENCE_NODE:
return wrap(static_cast<EntityReference*>(impl), creationContext, isolate);
case Node::ENTITY_NODE:
return wrap(static_cast<Entity*>(impl), creationContext, isolate);
case Node::PROCESSING_INSTRUCTION_NODE:
return wrap(static_cast<ProcessingInstruction*>(impl), creationContext, isolate);
case Node::COMMENT_NODE:
return wrap(static_cast<Comment*>(impl), creationContext, isolate);
case Node::DOCUMENT_NODE:
return wrap(toDocument(impl), creationContext, isolate);
case Node::DOCUMENT_TYPE_NODE:
return wrap(static_cast<DocumentType*>(impl), creationContext, isolate);
case Node::DOCUMENT_FRAGMENT_NODE:
return wrap(static_cast<DocumentFragment*>(impl), creationContext, isolate);
case Node::NOTATION_NODE:
return wrap(static_cast<Notation*>(impl), creationContext, isolate);
default:
break; // XPATH_NAMESPACE_NODE
}
return V8Node::createWrapper(impl, creationContext, isolate);
}
v8::Handle<v8::Object> V8CustomElement::createWrapper(PassRefPtr<Element> impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
{
ASSERT(impl);
RefPtr<CustomElementConstructor> constructor = CustomElementRegistry::constructorOf(impl.get());
if (!constructor) {
v8::Handle<v8::Value> wrapperValue = WebCore::toV8(toHTMLUnknownElement(toHTMLElement(impl.get())), creationContext, isolate);
if (!wrapperValue.IsEmpty() && wrapperValue->IsObject())
return v8::Handle<v8::Object>::Cast(wrapperValue);
return v8::Handle<v8::Object>();
}
// The constructor and registered lifecycle callbacks should be visible only from main world.
// FIXME: This shouldn't be needed once each custom element has its own FunctionTemplate
// https://bugs.webkit.org/show_bug.cgi?id=108138
if (!CustomElementHelpers::isFeatureAllowed(creationContext->CreationContext())) {
v8::Handle<v8::Object> wrapper = V8DOMWrapper::createWrapper(creationContext, &V8HTMLElement::info, impl.get(), isolate);
if (!wrapper.IsEmpty())
V8DOMWrapper::associateObjectWithWrapper(impl, &V8HTMLElement::info, wrapper, isolate, WrapperConfiguration::Dependent);
return wrapper;
}
v8::Handle<v8::Value> constructorValue = WebCore::toV8(constructor.get(), creationContext, isolate);
if (constructorValue.IsEmpty() || !constructorValue->IsObject())
return v8::Handle<v8::Object>();
v8::Handle<v8::Object> constructorWapper = v8::Handle<v8::Object>::Cast(constructorValue);
v8::Handle<v8::Object> prototype = v8::Handle<v8::Object>::Cast(constructorWapper->Get(v8::String::NewSymbol("prototype")));
WrapperTypeInfo* typeInfo = findWrapperTypeOf(prototype);
if (!typeInfo)
return v8::Handle<v8::Object>();
v8::Handle<v8::Object> wrapper = V8DOMWrapper::createWrapper(creationContext, typeInfo, impl.get(), isolate);
if (wrapper.IsEmpty())
return v8::Handle<v8::Object>();
wrapper->SetPrototype(prototype);
V8DOMWrapper::associateObjectWithWrapper(impl, typeInfo, wrapper, isolate, WrapperConfiguration::Dependent);
return wrapper;
}
void HTMLCollection::updateNameCache() const
{
if (m_info->hasNameCache)
return;
for (Element* element = itemAfter(0); element; element = itemAfter(element)) {
if (!element->isHTMLElement())
continue;
HTMLElement* e = toHTMLElement(element);
const AtomicString& idAttrVal = e->getIdAttribute();
const AtomicString& nameAttrVal = e->getAttribute(nameAttr);
if (!idAttrVal.isEmpty()) {
// add to id cache
Vector<Element*>* idVector = m_info->idCache.get(idAttrVal.impl());
if (!idVector) {
idVector = new Vector<Element*>;
m_info->idCache.add(idAttrVal.impl(), idVector);
}
idVector->append(e);
}
if (!nameAttrVal.isEmpty() && idAttrVal != nameAttrVal
&& (m_type != DocAll ||
(e->hasLocalName(imgTag) || e->hasLocalName(formTag) ||
e->hasLocalName(appletTag) || e->hasLocalName(objectTag) ||
e->hasLocalName(embedTag) || e->hasLocalName(inputTag) ||
e->hasLocalName(selectTag)))) {
// add to name cache
Vector<Element*>* nameVector = m_info->nameCache.get(nameAttrVal.impl());
if (!nameVector) {
nameVector = new Vector<Element*>;
m_info->nameCache.add(nameAttrVal.impl(), nameVector);
}
nameVector->append(e);
}
}
m_info->hasNameCache = true;
}
void HTMLElement::setOuterHTML(const String& html, ExceptionState& es)
{
Node* p = parentNode();
if (!p || !p->isHTMLElement()) {
es.throwDOMException(NoModificationAllowedError);
return;
}
RefPtr<HTMLElement> parent = toHTMLElement(p);
RefPtr<Node> prev = previousSibling();
RefPtr<Node> next = nextSibling();
RefPtr<DocumentFragment> fragment = createFragmentForInnerOuterHTML(html, parent.get(), AllowScriptingContent, es);
if (es.hadException())
return;
parent->replaceChild(fragment.release(), this, es);
RefPtr<Node> node = next ? next->previousSibling() : 0;
if (!es.hadException() && node && node->isTextNode())
mergeWithNextTextNode(node.release(), es);
if (!es.hadException() && prev && prev->isTextNode())
mergeWithNextTextNode(prev.release(), es);
}
void HTMLElement::setOuterHTML(const String& html, ExceptionCode& ec)
{
Node* p = parentNode();
if (!p || !p->isHTMLElement()) {
ec = NO_MODIFICATION_ALLOWED_ERR;
return;
}
RefPtr<HTMLElement> parent = toHTMLElement(p);
RefPtr<Node> prev = previousSibling();
RefPtr<Node> next = nextSibling();
RefPtr<DocumentFragment> fragment = createFragmentForInnerOuterHTML(html, parent.get(), AllowScriptingContent, ec);
if (ec)
return;
parent->replaceChild(fragment.release(), this, ec);
RefPtr<Node> node = next ? next->previousSibling() : 0;
if (!ec && node && node->isTextNode())
mergeWithNextTextNode(node.release(), ec);
if (!ec && prev && prev->isTextNode())
mergeWithNextTextNode(prev.release(), ec);
}
// Serialize end tag of an specified element.
void WebFrameSerializerImpl::endTagToString(
Element* element,
SerializeDomParam* param)
{
bool needSkip;
StringBuilder result;
// Do pre action for end tag.
result.append(preActionBeforeSerializeEndTag(element, param, &needSkip));
if (needSkip)
return;
// Write end tag when element has child/children.
if (element->hasChildren() || param->haveAddedContentsBeforeEnd) {
result.appendLiteral("</");
result.append(element->nodeName().lower());
result.append('>');
} else {
// Check whether we have to write end tag for empty element.
if (param->isHTMLDocument) {
result.append('>');
// FIXME: This code is horribly wrong. WebFrameSerializerImpl must die.
if (!element->isHTMLElement() || !toHTMLElement(element)->ieForbidsInsertHTML()) {
// We need to write end tag when it is required.
result.appendLiteral("</");
result.append(element->nodeName().lower());
result.append('>');
}
} else {
// For xml base document.
result.appendLiteral(" />");
}
}
// Do post action for end tag.
result.append(postActionAfterSerializeEndTag(element, param));
// Save the result to data buffer.
saveHTMLContentToBuffer(result.toString(), param);
}
HTMLElement* ScriptCustomElementDefinition::createElementSync(
Document& document,
const QualifiedName& tagName,
ExceptionState& exceptionState) {
DCHECK(ScriptState::current(m_scriptState->isolate()) == m_scriptState);
// Create an element
// https://dom.spec.whatwg.org/#concept-create-element
// 6. If definition is non-null
// 6.1. If the synchronous custom elements flag is set:
// 6.1.2. Set result to Construct(C). Rethrow any exceptions.
// Create an element and push to the construction stack.
// V8HTMLElement::constructorCustom() can only refer to
// window.document(), but it is different from the document here
// when it is an import document. This is not exactly what the
// spec defines, but the public behavior matches to the spec.
Element* element = createElementForConstructor(document);
{
ConstructionStackScope constructionStackScope(this, element);
v8::TryCatch tryCatch(m_scriptState->isolate());
element = runConstructor();
if (tryCatch.HasCaught()) {
exceptionState.rethrowV8Exception(tryCatch.Exception());
return nullptr;
}
}
// 6.1.3. through 6.1.9.
checkConstructorResult(element, document, tagName, exceptionState);
if (exceptionState.hadException())
return nullptr;
DCHECK_EQ(element->getCustomElementState(), CustomElementState::Custom);
return toHTMLElement(element);
}
DocumentFragment* createContextualFragment(
const String& markup,
Element* element,
ParserContentPolicy parserContentPolicy,
ExceptionState& exceptionState) {
DCHECK(element);
if (!isSupportedContainer(element)) {
exceptionState.throwDOMException(
NotSupportedError, "The range's container is '" + element->localName() +
"', which is not supported.");
return nullptr;
}
DocumentFragment* fragment = createFragmentForInnerOuterHTML(
markup, element, parserContentPolicy, "createContextualFragment",
exceptionState);
if (!fragment)
return nullptr;
// We need to pop <html> and <body> elements and remove <head> to
// accommodate folks passing complete HTML documents to make the
// child of an element.
Node* nextNode = nullptr;
for (Node* node = fragment->firstChild(); node; node = nextNode) {
nextNode = node->nextSibling();
if (isHTMLHtmlElement(*node) || isHTMLHeadElement(*node) ||
isHTMLBodyElement(*node)) {
HTMLElement* element = toHTMLElement(node);
if (Node* firstChild = element->firstChild())
nextNode = firstChild;
removeElementPreservingChildren(fragment, element);
}
}
return fragment;
}
HTMLElement* HTMLTextAreaElement::innerTextElement() const
{
Node* node = shadow()->oldestShadowRoot()->firstChild();
ASSERT(!node || node->hasTagName(divTag));
return toHTMLElement(node);
}
FormAttributeTargetObserver::FormAttributeTargetObserver(const AtomicString& id, FormAssociatedElement* element)
: IdTargetObserver(toHTMLElement(element)->treeScope().idTargetObserverRegistry(), id)
, m_element(element)
{
}
HTMLElement* toHTMLElement(FormAssociatedElement* associatedElement)
{
return const_cast<HTMLElement*>(toHTMLElement(static_cast<const FormAssociatedElement*>(associatedElement)));
}
const AtomicString& FormAssociatedElement::name() const
{
const AtomicString& name = toHTMLElement(this)->getNameAttribute();
return name.isNull() ? emptyAtom : name;
}
void FormAssociatedElement::resetFormAttributeTargetObserver()
{
ASSERT(toHTMLElement(this)->inDocument());
m_formAttributeTargetObserver = FormAttributeTargetObserver::create(toHTMLElement(this)->fastGetAttribute(formAttr), this);
}
bool FormAssociatedElement::customError() const
{
const HTMLElement* element = toHTMLElement(this);
return element->willValidate() && !m_customValidationMessage.isEmpty();
}
