自学教程：C++ toHTMLElement函数代码示例

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);}

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);    }}

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(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);}

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 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);}

// 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);}

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)));}

void FormAssociatedElement::resetFormAttributeTargetObserver(){    ASSERT(toHTMLElement(this)->inDocument());    m_formAttributeTargetObserver = FormAttributeTargetObserver::create(toHTMLElement(this)->fastGetAttribute(formAttr), this);}