summaryrefslogtreecommitdiffstats
path: root/dom/html/nsGenericHTMLElement.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'dom/html/nsGenericHTMLElement.cpp')
-rw-r--r--dom/html/nsGenericHTMLElement.cpp3623
1 files changed, 3623 insertions, 0 deletions
diff --git a/dom/html/nsGenericHTMLElement.cpp b/dom/html/nsGenericHTMLElement.cpp
new file mode 100644
index 0000000000..de29276fdc
--- /dev/null
+++ b/dom/html/nsGenericHTMLElement.cpp
@@ -0,0 +1,3623 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/EditorBase.h"
+#include "mozilla/EventDispatcher.h"
+#include "mozilla/EventListenerManager.h"
+#include "mozilla/EventStateManager.h"
+#include "mozilla/HTMLEditor.h"
+#include "mozilla/IMEContentObserver.h"
+#include "mozilla/IMEStateManager.h"
+#include "mozilla/MappedDeclarationsBuilder.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/MouseEvents.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/StaticPrefs_dom.h"
+#include "mozilla/TextEditor.h"
+#include "mozilla/TextEvents.h"
+#include "mozilla/StaticPrefs_html5.h"
+#include "mozilla/StaticPrefs_accessibility.h"
+#include "mozilla/dom/FetchPriority.h"
+#include "mozilla/dom/FormData.h"
+#include "nscore.h"
+#include "nsGenericHTMLElement.h"
+#include "nsCOMPtr.h"
+#include "nsAtom.h"
+#include "nsQueryObject.h"
+#include "mozilla/dom/BindContext.h"
+#include "mozilla/dom/Document.h"
+#include "nsPIDOMWindow.h"
+#include "nsIFrameInlines.h"
+#include "nsIScrollableFrame.h"
+#include "nsView.h"
+#include "nsViewManager.h"
+#include "nsIWidget.h"
+#include "nsRange.h"
+#include "nsPresContext.h"
+#include "nsError.h"
+#include "nsIPrincipal.h"
+#include "nsContainerFrame.h"
+#include "nsStyleUtil.h"
+#include "ReferrerInfo.h"
+
+#include "mozilla/PresState.h"
+#include "nsILayoutHistoryState.h"
+
+#include "nsHTMLParts.h"
+#include "nsContentUtils.h"
+#include "mozilla/dom/DirectionalityUtils.h"
+#include "mozilla/dom/DocumentOrShadowRoot.h"
+#include "nsString.h"
+#include "nsGkAtoms.h"
+#include "nsDOMCSSDeclaration.h"
+#include "nsITextControlFrame.h"
+#include "nsIFormControl.h"
+#include "mozilla/dom/HTMLFormElement.h"
+#include "nsFocusManager.h"
+
+#include "nsDOMStringMap.h"
+#include "nsDOMString.h"
+
+#include "nsLayoutUtils.h"
+#include "mozilla/dom/DocumentInlines.h"
+#include "HTMLFieldSetElement.h"
+#include "nsTextNode.h"
+#include "HTMLBRElement.h"
+#include "nsDOMMutationObserver.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/dom/FromParser.h"
+#include "mozilla/dom/Link.h"
+#include "mozilla/dom/ScriptLoader.h"
+
+#include "nsDOMTokenList.h"
+#include "nsThreadUtils.h"
+#include "mozilla/dom/BindingUtils.h"
+#include "mozilla/dom/MouseEventBinding.h"
+#include "mozilla/dom/ToggleEvent.h"
+#include "mozilla/dom/TouchEvent.h"
+#include "mozilla/dom/InputEvent.h"
+#include "mozilla/dom/InvokeEvent.h"
+#include "mozilla/ErrorResult.h"
+#include "nsHTMLDocument.h"
+#include "nsGlobalWindowInner.h"
+#include "mozilla/dom/HTMLBodyElement.h"
+#include "imgIContainer.h"
+#include "nsComputedDOMStyle.h"
+#include "mozilla/dom/HTMLDialogElement.h"
+#include "mozilla/dom/HTMLLabelElement.h"
+#include "mozilla/dom/HTMLInputElement.h"
+#include "mozilla/dom/CustomElementRegistry.h"
+#include "mozilla/dom/ElementBinding.h"
+#include "mozilla/dom/ElementInternals.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+static const uint8_t NS_INPUTMODE_NONE = 1;
+static const uint8_t NS_INPUTMODE_TEXT = 2;
+static const uint8_t NS_INPUTMODE_TEL = 3;
+static const uint8_t NS_INPUTMODE_URL = 4;
+static const uint8_t NS_INPUTMODE_EMAIL = 5;
+static const uint8_t NS_INPUTMODE_NUMERIC = 6;
+static const uint8_t NS_INPUTMODE_DECIMAL = 7;
+static const uint8_t NS_INPUTMODE_SEARCH = 8;
+
+static const nsAttrValue::EnumTable kInputmodeTable[] = {
+ {"none", NS_INPUTMODE_NONE},
+ {"text", NS_INPUTMODE_TEXT},
+ {"tel", NS_INPUTMODE_TEL},
+ {"url", NS_INPUTMODE_URL},
+ {"email", NS_INPUTMODE_EMAIL},
+ {"numeric", NS_INPUTMODE_NUMERIC},
+ {"decimal", NS_INPUTMODE_DECIMAL},
+ {"search", NS_INPUTMODE_SEARCH},
+ {nullptr, 0}};
+
+static const uint8_t NS_ENTERKEYHINT_ENTER = 1;
+static const uint8_t NS_ENTERKEYHINT_DONE = 2;
+static const uint8_t NS_ENTERKEYHINT_GO = 3;
+static const uint8_t NS_ENTERKEYHINT_NEXT = 4;
+static const uint8_t NS_ENTERKEYHINT_PREVIOUS = 5;
+static const uint8_t NS_ENTERKEYHINT_SEARCH = 6;
+static const uint8_t NS_ENTERKEYHINT_SEND = 7;
+
+static const nsAttrValue::EnumTable kEnterKeyHintTable[] = {
+ {"enter", NS_ENTERKEYHINT_ENTER},
+ {"done", NS_ENTERKEYHINT_DONE},
+ {"go", NS_ENTERKEYHINT_GO},
+ {"next", NS_ENTERKEYHINT_NEXT},
+ {"previous", NS_ENTERKEYHINT_PREVIOUS},
+ {"search", NS_ENTERKEYHINT_SEARCH},
+ {"send", NS_ENTERKEYHINT_SEND},
+ {nullptr, 0}};
+
+static const uint8_t NS_AUTOCAPITALIZE_NONE = 1;
+static const uint8_t NS_AUTOCAPITALIZE_SENTENCES = 2;
+static const uint8_t NS_AUTOCAPITALIZE_WORDS = 3;
+static const uint8_t NS_AUTOCAPITALIZE_CHARACTERS = 4;
+
+static const nsAttrValue::EnumTable kAutocapitalizeTable[] = {
+ {"none", NS_AUTOCAPITALIZE_NONE},
+ {"sentences", NS_AUTOCAPITALIZE_SENTENCES},
+ {"words", NS_AUTOCAPITALIZE_WORDS},
+ {"characters", NS_AUTOCAPITALIZE_CHARACTERS},
+ {"off", NS_AUTOCAPITALIZE_NONE},
+ {"on", NS_AUTOCAPITALIZE_SENTENCES},
+ {"", 0},
+ {nullptr, 0}};
+
+static const nsAttrValue::EnumTable* kDefaultAutocapitalize =
+ &kAutocapitalizeTable[1];
+
+nsresult nsGenericHTMLElement::CopyInnerTo(Element* aDst) {
+ MOZ_ASSERT(!aDst->GetUncomposedDoc(),
+ "Should not CopyInnerTo an Element in a document");
+
+ auto reparse = aDst->OwnerDoc() == OwnerDoc() ? ReparseAttributes::No
+ : ReparseAttributes::Yes;
+ nsresult rv = Element::CopyInnerTo(aDst, reparse);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // cloning a node must retain its internal nonce slot
+ nsString* nonce = static_cast<nsString*>(GetProperty(nsGkAtoms::nonce));
+ if (nonce) {
+ static_cast<nsGenericHTMLElement*>(aDst)->SetNonce(*nonce);
+ }
+ return NS_OK;
+}
+
+static const nsAttrValue::EnumTable kDirTable[] = {
+ {"ltr", Directionality::Ltr},
+ {"rtl", Directionality::Rtl},
+ {"auto", Directionality::Auto},
+ {nullptr, 0},
+};
+
+namespace {
+// See <https://html.spec.whatwg.org/#the-popover-attribute>.
+enum class PopoverAttributeKeyword : uint8_t { Auto, EmptyString, Manual };
+
+static const char* kPopoverAttributeValueAuto = "auto";
+static const char* kPopoverAttributeValueEmptyString = "";
+static const char* kPopoverAttributeValueManual = "manual";
+
+static const nsAttrValue::EnumTable kPopoverTable[] = {
+ {kPopoverAttributeValueAuto, PopoverAttributeKeyword::Auto},
+ {kPopoverAttributeValueEmptyString, PopoverAttributeKeyword::EmptyString},
+ {kPopoverAttributeValueManual, PopoverAttributeKeyword::Manual},
+ {nullptr, 0}};
+
+// See <https://html.spec.whatwg.org/#the-popover-attribute>.
+static const nsAttrValue::EnumTable* kPopoverTableInvalidValueDefault =
+ &kPopoverTable[2];
+} // namespace
+
+void nsGenericHTMLElement::GetFetchPriority(nsAString& aFetchPriority) const {
+ // <https://html.spec.whatwg.org/multipage/urls-and-fetching.html#fetch-priority-attributes>.
+ GetEnumAttr(nsGkAtoms::fetchpriority, kFetchPriorityAttributeValueAuto,
+ aFetchPriority);
+}
+
+/* static */
+FetchPriority nsGenericHTMLElement::ToFetchPriority(const nsAString& aValue) {
+ nsAttrValue attrValue;
+ ParseFetchPriority(aValue, attrValue);
+ MOZ_ASSERT(attrValue.Type() == nsAttrValue::eEnum);
+ return FetchPriority(attrValue.GetEnumValue());
+}
+
+namespace {
+// <https://html.spec.whatwg.org/multipage/urls-and-fetching.html#fetch-priority-attributes>.
+static const nsAttrValue::EnumTable kFetchPriorityEnumTable[] = {
+ {kFetchPriorityAttributeValueHigh, FetchPriority::High},
+ {kFetchPriorityAttributeValueLow, FetchPriority::Low},
+ {kFetchPriorityAttributeValueAuto, FetchPriority::Auto},
+ {nullptr, 0}};
+
+// <https://html.spec.whatwg.org/multipage/urls-and-fetching.html#fetch-priority-attributes>.
+static const nsAttrValue::EnumTable*
+ kFetchPriorityEnumTableInvalidValueDefault = &kFetchPriorityEnumTable[2];
+} // namespace
+
+FetchPriority nsGenericHTMLElement::GetFetchPriority() const {
+ const nsAttrValue* fetchpriorityAttribute =
+ GetParsedAttr(nsGkAtoms::fetchpriority);
+ if (fetchpriorityAttribute) {
+ MOZ_ASSERT(fetchpriorityAttribute->Type() == nsAttrValue::eEnum);
+ return FetchPriority(fetchpriorityAttribute->GetEnumValue());
+ }
+
+ return FetchPriority::Auto;
+}
+
+/* static */
+void nsGenericHTMLElement::ParseFetchPriority(const nsAString& aValue,
+ nsAttrValue& aResult) {
+ aResult.ParseEnumValue(aValue, kFetchPriorityEnumTable,
+ false /* aCaseSensitive */,
+ kFetchPriorityEnumTableInvalidValueDefault);
+}
+
+void nsGenericHTMLElement::AddToNameTable(nsAtom* aName) {
+ MOZ_ASSERT(HasName(), "Node doesn't have name?");
+ Document* doc = GetUncomposedDoc();
+ if (doc && !IsInNativeAnonymousSubtree()) {
+ doc->AddToNameTable(this, aName);
+ }
+}
+
+void nsGenericHTMLElement::RemoveFromNameTable() {
+ if (HasName() && CanHaveName(NodeInfo()->NameAtom())) {
+ if (Document* doc = GetUncomposedDoc()) {
+ doc->RemoveFromNameTable(this,
+ GetParsedAttr(nsGkAtoms::name)->GetAtomValue());
+ }
+ }
+}
+
+void nsGenericHTMLElement::GetAccessKeyLabel(nsString& aLabel) {
+ nsAutoString suffix;
+ GetAccessKey(suffix);
+ if (!suffix.IsEmpty()) {
+ EventStateManager::GetAccessKeyLabelPrefix(this, aLabel);
+ aLabel.Append(suffix);
+ }
+}
+
+static bool IsOffsetParent(nsIFrame* aFrame) {
+ LayoutFrameType frameType = aFrame->Type();
+
+ if (frameType == LayoutFrameType::TableCell ||
+ frameType == LayoutFrameType::TableWrapper) {
+ // Per the IDL for Element, only td, th, and table are acceptable
+ // offsetParents apart from body or positioned elements; we need to check
+ // the content type as well as the frame type so we ignore anonymous tables
+ // created by an element with display: table-cell with no actual table
+ nsIContent* content = aFrame->GetContent();
+
+ return content->IsAnyOfHTMLElements(nsGkAtoms::table, nsGkAtoms::td,
+ nsGkAtoms::th);
+ }
+ return false;
+}
+
+struct OffsetResult {
+ Element* mParent = nullptr;
+ CSSIntRect mRect;
+};
+
+static OffsetResult GetUnretargetedOffsetsFor(const Element& aElement) {
+ nsIFrame* frame = aElement.GetPrimaryFrame();
+ if (!frame) {
+ return {};
+ }
+
+ nsIFrame* styleFrame = nsLayoutUtils::GetStyleFrame(frame);
+
+ nsIFrame* parent = frame->GetParent();
+ nsPoint origin(0, 0);
+
+ nsIContent* offsetParent = nullptr;
+ Element* docElement = aElement.GetComposedDoc()->GetRootElement();
+ nsIContent* content = frame->GetContent();
+
+ if (content &&
+ (content->IsHTMLElement(nsGkAtoms::body) || content == docElement)) {
+ parent = frame;
+ } else {
+ const bool isPositioned = styleFrame->IsAbsPosContainingBlock();
+ const bool isAbsolutelyPositioned = frame->IsAbsolutelyPositioned();
+ origin += frame->GetPositionIgnoringScrolling();
+
+ for (; parent; parent = parent->GetParent()) {
+ content = parent->GetContent();
+
+ // Stop at the first ancestor that is positioned.
+ if (parent->IsAbsPosContainingBlock()) {
+ offsetParent = content;
+ break;
+ }
+
+ // Add the parent's origin to our own to get to the
+ // right coordinate system.
+ const bool isOffsetParent = !isPositioned && IsOffsetParent(parent);
+ if (!isOffsetParent) {
+ origin += parent->GetPositionIgnoringScrolling();
+ }
+
+ if (content) {
+ // If we've hit the document element, break here.
+ if (content == docElement) {
+ break;
+ }
+
+ // Break if the ancestor frame type makes it suitable as offset parent
+ // and this element is *not* positioned or if we found the body element.
+ if (isOffsetParent || content->IsHTMLElement(nsGkAtoms::body)) {
+ offsetParent = content;
+ break;
+ }
+ }
+ }
+
+ if (isAbsolutelyPositioned && !offsetParent) {
+ // If this element is absolutely positioned, but we don't have
+ // an offset parent it means this element is an absolutely
+ // positioned child that's not nested inside another positioned
+ // element, in this case the element's frame's parent is the
+ // frame for the HTML element so we fail to find the body in the
+ // parent chain. We want the offset parent in this case to be
+ // the body, so we just get the body element from the document.
+ //
+ // We use GetBodyElement() here, not GetBody(), because we don't want to
+ // end up with framesets here.
+ offsetParent = aElement.GetComposedDoc()->GetBodyElement();
+ }
+ }
+
+ // Make the position relative to the padding edge.
+ if (parent) {
+ const nsStyleBorder* border = parent->StyleBorder();
+ origin.x -= border->GetComputedBorderWidth(eSideLeft);
+ origin.y -= border->GetComputedBorderWidth(eSideTop);
+ }
+
+ // Get the union of all rectangles in this and continuation frames.
+ // It doesn't really matter what we use as aRelativeTo here, since
+ // we only care about the size. We just have to use something non-null.
+ nsRect rcFrame = nsLayoutUtils::GetAllInFlowRectsUnion(frame, frame);
+ rcFrame.MoveTo(origin);
+ return {Element::FromNodeOrNull(offsetParent),
+ CSSIntRect::FromAppUnitsRounded(rcFrame)};
+}
+
+static bool ShouldBeRetargeted(const Element& aReferenceElement,
+ const Element& aElementToMaybeRetarget) {
+ ShadowRoot* shadow = aElementToMaybeRetarget.GetContainingShadow();
+ if (!shadow) {
+ return false;
+ }
+ for (ShadowRoot* scope = aReferenceElement.GetContainingShadow(); scope;
+ scope = scope->Host()->GetContainingShadow()) {
+ if (scope == shadow) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+Element* nsGenericHTMLElement::GetOffsetRect(CSSIntRect& aRect) {
+ aRect = CSSIntRect();
+
+ if (!GetPrimaryFrame(FlushType::Layout)) {
+ return nullptr;
+ }
+
+ OffsetResult thisResult = GetUnretargetedOffsetsFor(*this);
+ aRect = thisResult.mRect;
+
+ Element* parent = thisResult.mParent;
+ while (parent && ShouldBeRetargeted(*this, *parent)) {
+ OffsetResult result = GetUnretargetedOffsetsFor(*parent);
+ aRect += result.mRect.TopLeft();
+ parent = result.mParent;
+ }
+
+ return parent;
+}
+
+bool nsGenericHTMLElement::Spellcheck() {
+ // Has the state has been explicitly set?
+ nsIContent* node;
+ for (node = this; node; node = node->GetParent()) {
+ if (node->IsHTMLElement()) {
+ static Element::AttrValuesArray strings[] = {nsGkAtoms::_true,
+ nsGkAtoms::_false, nullptr};
+ switch (node->AsElement()->FindAttrValueIn(
+ kNameSpaceID_None, nsGkAtoms::spellcheck, strings, eCaseMatters)) {
+ case 0: // spellcheck = "true"
+ return true;
+ case 1: // spellcheck = "false"
+ return false;
+ }
+ }
+ }
+
+ // contenteditable/designMode are spellchecked by default
+ if (IsEditable()) {
+ return true;
+ }
+
+ // Is this a chrome element?
+ if (nsContentUtils::IsChromeDoc(OwnerDoc())) {
+ return false; // Not spellchecked by default
+ }
+
+ // Anything else that's not a form control is not spellchecked by default
+ nsCOMPtr<nsIFormControl> formControl = do_QueryObject(this);
+ if (!formControl) {
+ return false; // Not spellchecked by default
+ }
+
+ // Is this a multiline plaintext input?
+ auto controlType = formControl->ControlType();
+ if (controlType == FormControlType::Textarea) {
+ return true; // Spellchecked by default
+ }
+
+ // Is this anything other than an input text?
+ // Other inputs are not spellchecked.
+ if (controlType != FormControlType::InputText) {
+ return false; // Not spellchecked by default
+ }
+
+ // Does the user want input text spellchecked by default?
+ // NOTE: Do not reflect a pref value of 0 back to the DOM getter.
+ // The web page should not know if the user has disabled spellchecking.
+ // We'll catch this in the editor itself.
+ int32_t spellcheckLevel = Preferences::GetInt("layout.spellcheckDefault", 1);
+ return spellcheckLevel == 2; // "Spellcheck multi- and single-line"
+}
+
+bool nsGenericHTMLElement::InNavQuirksMode(Document* aDoc) {
+ return aDoc && aDoc->GetCompatibilityMode() == eCompatibility_NavQuirks;
+}
+
+void nsGenericHTMLElement::UpdateEditableState(bool aNotify) {
+ // XXX Should we do this only when in a document?
+ ContentEditableTristate value = GetContentEditableValue();
+ if (value != eInherit) {
+ SetEditableFlag(!!value);
+ UpdateReadOnlyState(aNotify);
+ return;
+ }
+ nsStyledElement::UpdateEditableState(aNotify);
+}
+
+nsresult nsGenericHTMLElement::BindToTree(BindContext& aContext,
+ nsINode& aParent) {
+ nsresult rv = nsGenericHTMLElementBase::BindToTree(aContext, aParent);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (IsInComposedDoc()) {
+ RegUnRegAccessKey(true);
+ }
+
+ if (IsInUncomposedDoc()) {
+ if (HasName() && CanHaveName(NodeInfo()->NameAtom())) {
+ aContext.OwnerDoc().AddToNameTable(
+ this, GetParsedAttr(nsGkAtoms::name)->GetAtomValue());
+ }
+ }
+
+ if (HasFlag(NODE_IS_EDITABLE) && GetContentEditableValue() == eTrue &&
+ IsInComposedDoc()) {
+ aContext.OwnerDoc().ChangeContentEditableCount(this, +1);
+ }
+
+ // Hide any nonce from the DOM, but keep the internal value of the
+ // nonce by copying and resetting the internal nonce value.
+ if (HasFlag(NODE_HAS_NONCE_AND_HEADER_CSP) && IsInComposedDoc() &&
+ OwnerDoc()->GetBrowsingContext()) {
+ nsContentUtils::AddScriptRunner(NS_NewRunnableFunction(
+ "nsGenericHTMLElement::ResetNonce::Runnable",
+ [self = RefPtr<nsGenericHTMLElement>(this)]() {
+ nsAutoString nonce;
+ self->GetNonce(nonce);
+ self->SetAttr(kNameSpaceID_None, nsGkAtoms::nonce, u""_ns, true);
+ self->SetNonce(nonce);
+ }));
+ }
+
+ // We need to consider a labels element is moved to another subtree
+ // with different root, it needs to update labels list and its root
+ // as well.
+ nsExtendedDOMSlots* slots = GetExistingExtendedDOMSlots();
+ if (slots && slots->mLabelsList) {
+ slots->mLabelsList->MaybeResetRoot(SubtreeRoot());
+ }
+
+ return rv;
+}
+
+void nsGenericHTMLElement::UnbindFromTree(bool aNullParent) {
+ if (IsInComposedDoc()) {
+ // https://html.spec.whatwg.org/#dom-trees:hide-popover-algorithm
+ // If removedNode's popover attribute is not in the no popover state, then
+ // run the hide popover algorithm given removedNode, false, false, and
+ // false.
+ if (GetPopoverData()) {
+ HidePopoverWithoutRunningScript();
+ }
+ RegUnRegAccessKey(false);
+ }
+
+ RemoveFromNameTable();
+
+ if (GetContentEditableValue() == eTrue) {
+ if (Document* doc = GetComposedDoc()) {
+ doc->ChangeContentEditableCount(this, -1);
+ }
+ }
+
+ nsStyledElement::UnbindFromTree(aNullParent);
+
+ // Invalidate .labels list. It will be repopulated when used the next time.
+ nsExtendedDOMSlots* slots = GetExistingExtendedDOMSlots();
+ if (slots && slots->mLabelsList) {
+ slots->mLabelsList->MaybeResetRoot(SubtreeRoot());
+ }
+}
+
+HTMLFormElement* nsGenericHTMLElement::FindAncestorForm(
+ HTMLFormElement* aCurrentForm) {
+ NS_ASSERTION(!HasAttr(nsGkAtoms::form) || IsHTMLElement(nsGkAtoms::img),
+ "FindAncestorForm should not be called if @form is set!");
+ if (IsInNativeAnonymousSubtree()) {
+ return nullptr;
+ }
+
+ nsIContent* content = this;
+ while (content) {
+ // If the current ancestor is a form, return it as our form
+ if (content->IsHTMLElement(nsGkAtoms::form)) {
+#ifdef DEBUG
+ if (!nsContentUtils::IsInSameAnonymousTree(this, content)) {
+ // It's possible that we started unbinding at |content| or
+ // some ancestor of it, and |content| and |this| used to all be
+ // anonymous. Check for this the hard way.
+ for (nsIContent* child = this; child != content;
+ child = child->GetParent()) {
+ NS_ASSERTION(child->ComputeIndexInParentContent().isSome(),
+ "Walked too far?");
+ }
+ }
+#endif
+ return static_cast<HTMLFormElement*>(content);
+ }
+
+ nsIContent* prevContent = content;
+ content = prevContent->GetParent();
+
+ if (!content && aCurrentForm) {
+ // We got to the root of the subtree we're in, and we're being removed
+ // from the DOM (the only time we get into this method with a non-null
+ // aCurrentForm). Check whether aCurrentForm is in the same subtree. If
+ // it is, we want to return aCurrentForm, since this case means that
+ // we're one of those inputs-in-a-table that have a hacked mForm pointer
+ // and a subtree containing both us and the form got removed from the
+ // DOM.
+ if (aCurrentForm->IsInclusiveDescendantOf(prevContent)) {
+ return aCurrentForm;
+ }
+ }
+ }
+
+ return nullptr;
+}
+
+bool nsGenericHTMLElement::CheckHandleEventForAnchorsPreconditions(
+ EventChainVisitor& aVisitor) {
+ MOZ_ASSERT(nsCOMPtr<Link>(do_QueryObject(this)),
+ "should be called only when |this| implements |Link|");
+ // When disconnected, only <a> should navigate away per
+ // https://html.spec.whatwg.org/#cannot-navigate
+ return IsInComposedDoc() || IsHTMLElement(nsGkAtoms::a);
+}
+
+void nsGenericHTMLElement::GetEventTargetParentForAnchors(
+ EventChainPreVisitor& aVisitor) {
+ nsGenericHTMLElementBase::GetEventTargetParent(aVisitor);
+
+ if (!CheckHandleEventForAnchorsPreconditions(aVisitor)) {
+ return;
+ }
+
+ GetEventTargetParentForLinks(aVisitor);
+}
+
+nsresult nsGenericHTMLElement::PostHandleEventForAnchors(
+ EventChainPostVisitor& aVisitor) {
+ if (!CheckHandleEventForAnchorsPreconditions(aVisitor)) {
+ return NS_OK;
+ }
+
+ return PostHandleEventForLinks(aVisitor);
+}
+
+bool nsGenericHTMLElement::IsHTMLLink(nsIURI** aURI) const {
+ MOZ_ASSERT(aURI, "Must provide aURI out param");
+
+ *aURI = GetHrefURIForAnchors().take();
+ // We promise out param is non-null if we return true, so base rv on it
+ return *aURI != nullptr;
+}
+
+already_AddRefed<nsIURI> nsGenericHTMLElement::GetHrefURIForAnchors() const {
+ // This is used by the three Link implementations and
+ // nsHTMLStyleElement.
+
+ // Get href= attribute (relative URI).
+
+ // We use the nsAttrValue's copy of the URI string to avoid copying.
+ nsCOMPtr<nsIURI> uri;
+ GetURIAttr(nsGkAtoms::href, nullptr, getter_AddRefs(uri));
+
+ return uri.forget();
+}
+
+void nsGenericHTMLElement::BeforeSetAttr(int32_t aNamespaceID, nsAtom* aName,
+ const nsAttrValue* aValue,
+ bool aNotify) {
+ if (aNamespaceID == kNameSpaceID_None) {
+ if (aName == nsGkAtoms::accesskey) {
+ // Have to unregister before clearing flag. See UnregAccessKey
+ RegUnRegAccessKey(false);
+ if (!aValue) {
+ UnsetFlags(NODE_HAS_ACCESSKEY);
+ }
+ } else if (aName == nsGkAtoms::name) {
+ // Have to do this before clearing flag. See RemoveFromNameTable
+ RemoveFromNameTable();
+ if (!aValue || aValue->IsEmptyString()) {
+ ClearHasName();
+ }
+ } else if (aName == nsGkAtoms::contenteditable) {
+ if (aValue) {
+ // Set this before the attribute is set so that any subclass code that
+ // runs before the attribute is set won't think we're missing a
+ // contenteditable attr when we actually have one.
+ SetMayHaveContentEditableAttr();
+ }
+ }
+ if (!aValue && IsEventAttributeName(aName)) {
+ if (EventListenerManager* manager = GetExistingListenerManager()) {
+ manager->RemoveEventHandler(GetEventNameForAttr(aName));
+ }
+ }
+ }
+
+ return nsGenericHTMLElementBase::BeforeSetAttr(aNamespaceID, aName, aValue,
+ aNotify);
+}
+
+namespace {
+constexpr PopoverAttributeState ToPopoverAttributeState(
+ PopoverAttributeKeyword aPopoverAttributeKeyword) {
+ // See <https://html.spec.whatwg.org/#the-popover-attribute>.
+ switch (aPopoverAttributeKeyword) {
+ case PopoverAttributeKeyword::Auto:
+ return PopoverAttributeState::Auto;
+ case PopoverAttributeKeyword::EmptyString:
+ return PopoverAttributeState::Auto;
+ case PopoverAttributeKeyword::Manual:
+ return PopoverAttributeState::Manual;
+ default: {
+ MOZ_ASSERT_UNREACHABLE();
+ return PopoverAttributeState::None;
+ }
+ }
+}
+} // namespace
+
+void nsGenericHTMLElement::AfterSetPopoverAttr() {
+ auto mapPopoverState = [](const nsAttrValue* value) -> PopoverAttributeState {
+ if (value) {
+ MOZ_ASSERT(value->Type() == nsAttrValue::eEnum);
+ const auto popoverAttributeKeyword =
+ static_cast<PopoverAttributeKeyword>(value->GetEnumValue());
+ return ToPopoverAttributeState(popoverAttributeKeyword);
+ }
+
+ // The missing value default is the no popover state, see
+ // <https://html.spec.whatwg.org/multipage/popover.html#attr-popover>.
+ return PopoverAttributeState::None;
+ };
+
+ PopoverAttributeState newState =
+ mapPopoverState(GetParsedAttr(nsGkAtoms::popover));
+
+ const PopoverAttributeState oldState = GetPopoverAttributeState();
+
+ if (newState != oldState) {
+ PopoverPseudoStateUpdate(false, true);
+
+ if (IsPopoverOpen()) {
+ HidePopoverInternal(/* aFocusPreviousElement = */ true,
+ /* aFireEvents = */ true, IgnoreErrors());
+ // Event handlers could have removed the popover attribute, or changed
+ // its value.
+ // https://github.com/whatwg/html/issues/9034
+ newState = mapPopoverState(GetParsedAttr(nsGkAtoms::popover));
+ }
+
+ if (newState == PopoverAttributeState::None) {
+ ClearPopoverData();
+ RemoveStates(ElementState::POPOVER_OPEN);
+ } else {
+ // TODO: what if `HidePopoverInternal` called `ShowPopup()`?
+ EnsurePopoverData().SetPopoverAttributeState(newState);
+ }
+ }
+}
+
+void nsGenericHTMLElement::AfterSetAttr(int32_t aNamespaceID, nsAtom* aName,
+ const nsAttrValue* aValue,
+ const nsAttrValue* aOldValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
+ bool aNotify) {
+ if (aNamespaceID == kNameSpaceID_None) {
+ if (IsEventAttributeName(aName) && aValue) {
+ MOZ_ASSERT(aValue->Type() == nsAttrValue::eString,
+ "Expected string value for script body");
+ SetEventHandler(GetEventNameForAttr(aName), aValue->GetStringValue());
+ } else if (aNotify && aName == nsGkAtoms::spellcheck) {
+ SyncEditorsOnSubtree(this);
+ } else if (aName == nsGkAtoms::popover &&
+ StaticPrefs::dom_element_popover_enabled()) {
+ nsContentUtils::AddScriptRunner(
+ NewRunnableMethod("nsGenericHTMLElement::AfterSetPopoverAttr", this,
+ &nsGenericHTMLElement::AfterSetPopoverAttr));
+ } else if (aName == nsGkAtoms::popovertarget) {
+ ClearExplicitlySetAttrElement(nsGkAtoms::popovertarget);
+ } else if (aName == nsGkAtoms::dir) {
+ auto dir = Directionality::Ltr;
+ // A boolean tracking whether we need to recompute our directionality.
+ // This needs to happen after we update our internal "dir" attribute
+ // state but before we call SetDirectionalityOnDescendants.
+ bool recomputeDirectionality = false;
+ ElementState dirStates;
+ if (aValue && aValue->Type() == nsAttrValue::eEnum) {
+ SetHasValidDir();
+ dirStates |= ElementState::HAS_DIR_ATTR;
+ auto dirValue = Directionality(aValue->GetEnumValue());
+ if (dirValue == Directionality::Auto) {
+ dirStates |= ElementState::HAS_DIR_ATTR_LIKE_AUTO;
+ } else {
+ dir = dirValue;
+ SetDirectionality(dir, aNotify);
+ if (dirValue == Directionality::Ltr) {
+ dirStates |= ElementState::HAS_DIR_ATTR_LTR;
+ } else {
+ MOZ_ASSERT(dirValue == Directionality::Rtl);
+ dirStates |= ElementState::HAS_DIR_ATTR_RTL;
+ }
+ }
+ } else {
+ if (aValue) {
+ // We have a value, just not a valid one.
+ dirStates |= ElementState::HAS_DIR_ATTR;
+ }
+ ClearHasValidDir();
+ if (NodeInfo()->Equals(nsGkAtoms::bdi)) {
+ dirStates |= ElementState::HAS_DIR_ATTR_LIKE_AUTO;
+ } else {
+ recomputeDirectionality = true;
+ }
+ }
+ // Now figure out what's changed about our dir states.
+ ElementState oldDirStates = State() & ElementState::DIR_ATTR_STATES;
+ ElementState changedStates = dirStates ^ oldDirStates;
+ if (!changedStates.IsEmpty()) {
+ ToggleStates(changedStates, aNotify);
+ }
+ if (recomputeDirectionality) {
+ dir = RecomputeDirectionality(this, aNotify);
+ }
+ SetDirectionalityOnDescendants(this, dir, aNotify);
+ } else if (aName == nsGkAtoms::contenteditable) {
+ int32_t editableCountDelta = 0;
+ if (aOldValue && (aOldValue->Equals(u"true"_ns, eIgnoreCase) ||
+ aOldValue->Equals(u""_ns, eIgnoreCase))) {
+ editableCountDelta = -1;
+ }
+ if (aValue && (aValue->Equals(u"true"_ns, eIgnoreCase) ||
+ aValue->Equals(u""_ns, eIgnoreCase))) {
+ ++editableCountDelta;
+ }
+ ChangeEditableState(editableCountDelta);
+ } else if (aName == nsGkAtoms::accesskey) {
+ if (aValue && !aValue->Equals(u""_ns, eIgnoreCase)) {
+ SetFlags(NODE_HAS_ACCESSKEY);
+ RegUnRegAccessKey(true);
+ }
+ } else if (aName == nsGkAtoms::inert) {
+ if (aValue) {
+ AddStates(ElementState::INERT);
+ } else {
+ RemoveStates(ElementState::INERT);
+ }
+ } else if (aName == nsGkAtoms::name) {
+ if (aValue && !aValue->Equals(u""_ns, eIgnoreCase)) {
+ // This may not be quite right because we can have subclass code run
+ // before here. But in practice subclasses don't care about this flag,
+ // and in particular selector matching does not care. Otherwise we'd
+ // want to handle it like we handle id attributes (in PreIdMaybeChange
+ // and PostIdMaybeChange).
+ SetHasName();
+ if (CanHaveName(NodeInfo()->NameAtom())) {
+ AddToNameTable(aValue->GetAtomValue());
+ }
+ }
+ } else if (aName == nsGkAtoms::inputmode ||
+ aName == nsGkAtoms::enterkeyhint) {
+ if (nsFocusManager::GetFocusedElementStatic() == this) {
+ if (const nsPresContext* presContext =
+ GetPresContext(eForComposedDoc)) {
+ IMEContentObserver* observer =
+ IMEStateManager::GetActiveContentObserver();
+ if (observer && observer->IsObserving(*presContext, this)) {
+ if (RefPtr<EditorBase> editorBase = GetEditorWithoutCreation()) {
+ IMEState newState;
+ editorBase->GetPreferredIMEState(&newState);
+ OwningNonNull<nsGenericHTMLElement> kungFuDeathGrip(*this);
+ IMEStateManager::UpdateIMEState(
+ newState, kungFuDeathGrip, *editorBase,
+ {IMEStateManager::UpdateIMEStateOption::ForceUpdate,
+ IMEStateManager::UpdateIMEStateOption::
+ DontCommitComposition});
+ }
+ }
+ }
+ }
+ }
+
+ // The nonce will be copied over to an internal slot and cleared from the
+ // Element within BindToTree to avoid CSS Selector nonce exfiltration if
+ // the CSP list contains a header-delivered CSP.
+ if (nsGkAtoms::nonce == aName) {
+ if (aValue) {
+ SetNonce(aValue->GetStringValue());
+ if (OwnerDoc()->GetHasCSPDeliveredThroughHeader()) {
+ SetFlags(NODE_HAS_NONCE_AND_HEADER_CSP);
+ }
+ } else {
+ RemoveNonce();
+ }
+ }
+ }
+
+ return nsGenericHTMLElementBase::AfterSetAttr(
+ aNamespaceID, aName, aValue, aOldValue, aMaybeScriptedPrincipal, aNotify);
+}
+
+EventListenerManager* nsGenericHTMLElement::GetEventListenerManagerForAttr(
+ nsAtom* aAttrName, bool* aDefer) {
+ // Attributes on the body and frameset tags get set on the global object
+ if ((mNodeInfo->Equals(nsGkAtoms::body) ||
+ mNodeInfo->Equals(nsGkAtoms::frameset)) &&
+ // We only forward some event attributes from body/frameset to window
+ (0
+#define EVENT(name_, id_, type_, struct_) /* nothing */
+#define FORWARDED_EVENT(name_, id_, type_, struct_) \
+ || nsGkAtoms::on##name_ == aAttrName
+#define WINDOW_EVENT FORWARDED_EVENT
+#include "mozilla/EventNameList.h" // IWYU pragma: keep
+#undef WINDOW_EVENT
+#undef FORWARDED_EVENT
+#undef EVENT
+ )) {
+ nsPIDOMWindowInner* win;
+
+ // If we have a document, and it has a window, add the event
+ // listener on the window (the inner window). If not, proceed as
+ // normal.
+ // XXXbz sXBL/XBL2 issue: should we instead use GetComposedDoc() here,
+ // override BindToTree for those classes and munge event listeners there?
+ Document* document = OwnerDoc();
+
+ *aDefer = false;
+ if ((win = document->GetInnerWindow())) {
+ nsCOMPtr<EventTarget> piTarget(do_QueryInterface(win));
+
+ return piTarget->GetOrCreateListenerManager();
+ }
+
+ return nullptr;
+ }
+
+ return nsGenericHTMLElementBase::GetEventListenerManagerForAttr(aAttrName,
+ aDefer);
+}
+
+#define EVENT(name_, id_, type_, struct_) /* nothing; handled by nsINode */
+#define FORWARDED_EVENT(name_, id_, type_, struct_) \
+ EventHandlerNonNull* nsGenericHTMLElement::GetOn##name_() { \
+ if (IsAnyOfHTMLElements(nsGkAtoms::body, nsGkAtoms::frameset)) { \
+ /* XXXbz note to self: add tests for this! */ \
+ if (nsPIDOMWindowInner* win = OwnerDoc()->GetInnerWindow()) { \
+ nsGlobalWindowInner* globalWin = nsGlobalWindowInner::Cast(win); \
+ return globalWin->GetOn##name_(); \
+ } \
+ return nullptr; \
+ } \
+ \
+ return nsINode::GetOn##name_(); \
+ } \
+ void nsGenericHTMLElement::SetOn##name_(EventHandlerNonNull* handler) { \
+ if (IsAnyOfHTMLElements(nsGkAtoms::body, nsGkAtoms::frameset)) { \
+ nsPIDOMWindowInner* win = OwnerDoc()->GetInnerWindow(); \
+ if (!win) { \
+ return; \
+ } \
+ \
+ nsGlobalWindowInner* globalWin = nsGlobalWindowInner::Cast(win); \
+ return globalWin->SetOn##name_(handler); \
+ } \
+ \
+ return nsINode::SetOn##name_(handler); \
+ }
+#define ERROR_EVENT(name_, id_, type_, struct_) \
+ already_AddRefed<EventHandlerNonNull> nsGenericHTMLElement::GetOn##name_() { \
+ if (IsAnyOfHTMLElements(nsGkAtoms::body, nsGkAtoms::frameset)) { \
+ /* XXXbz note to self: add tests for this! */ \
+ if (nsPIDOMWindowInner* win = OwnerDoc()->GetInnerWindow()) { \
+ nsGlobalWindowInner* globalWin = nsGlobalWindowInner::Cast(win); \
+ OnErrorEventHandlerNonNull* errorHandler = globalWin->GetOn##name_(); \
+ if (errorHandler) { \
+ RefPtr<EventHandlerNonNull> handler = \
+ new EventHandlerNonNull(errorHandler); \
+ return handler.forget(); \
+ } \
+ } \
+ return nullptr; \
+ } \
+ \
+ RefPtr<EventHandlerNonNull> handler = nsINode::GetOn##name_(); \
+ return handler.forget(); \
+ } \
+ void nsGenericHTMLElement::SetOn##name_(EventHandlerNonNull* handler) { \
+ if (IsAnyOfHTMLElements(nsGkAtoms::body, nsGkAtoms::frameset)) { \
+ nsPIDOMWindowInner* win = OwnerDoc()->GetInnerWindow(); \
+ if (!win) { \
+ return; \
+ } \
+ \
+ nsGlobalWindowInner* globalWin = nsGlobalWindowInner::Cast(win); \
+ RefPtr<OnErrorEventHandlerNonNull> errorHandler; \
+ if (handler) { \
+ errorHandler = new OnErrorEventHandlerNonNull(handler); \
+ } \
+ return globalWin->SetOn##name_(errorHandler); \
+ } \
+ \
+ return nsINode::SetOn##name_(handler); \
+ }
+#include "mozilla/EventNameList.h" // IWYU pragma: keep
+#undef ERROR_EVENT
+#undef FORWARDED_EVENT
+#undef EVENT
+
+void nsGenericHTMLElement::GetBaseTarget(nsAString& aBaseTarget) const {
+ OwnerDoc()->GetBaseTarget(aBaseTarget);
+}
+
+//----------------------------------------------------------------------
+
+bool nsGenericHTMLElement::ParseAttribute(int32_t aNamespaceID,
+ nsAtom* aAttribute,
+ const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
+ nsAttrValue& aResult) {
+ if (aNamespaceID == kNameSpaceID_None) {
+ if (aAttribute == nsGkAtoms::dir) {
+ return aResult.ParseEnumValue(aValue, kDirTable, false);
+ }
+
+ if (aAttribute == nsGkAtoms::popover &&
+ StaticPrefs::dom_element_popover_enabled()) {
+ return aResult.ParseEnumValue(aValue, kPopoverTable, false,
+ kPopoverTableInvalidValueDefault);
+ }
+
+ if (aAttribute == nsGkAtoms::tabindex) {
+ return aResult.ParseIntValue(aValue);
+ }
+
+ if (aAttribute == nsGkAtoms::referrerpolicy) {
+ return ParseReferrerAttribute(aValue, aResult);
+ }
+
+ if (aAttribute == nsGkAtoms::name) {
+ // Store name as an atom. name="" means that the element has no name,
+ // not that it has an empty string as the name.
+ if (aValue.IsEmpty()) {
+ return false;
+ }
+ aResult.ParseAtom(aValue);
+ return true;
+ }
+
+ if (aAttribute == nsGkAtoms::contenteditable ||
+ aAttribute == nsGkAtoms::translate) {
+ aResult.ParseAtom(aValue);
+ return true;
+ }
+
+ if (aAttribute == nsGkAtoms::rel) {
+ aResult.ParseAtomArray(aValue);
+ return true;
+ }
+
+ if (aAttribute == nsGkAtoms::inputmode) {
+ return aResult.ParseEnumValue(aValue, kInputmodeTable, false);
+ }
+
+ if (aAttribute == nsGkAtoms::enterkeyhint) {
+ return aResult.ParseEnumValue(aValue, kEnterKeyHintTable, false);
+ }
+
+ if (aAttribute == nsGkAtoms::autocapitalize) {
+ return aResult.ParseEnumValue(aValue, kAutocapitalizeTable, false);
+ }
+ }
+
+ return nsGenericHTMLElementBase::ParseAttribute(
+ aNamespaceID, aAttribute, aValue, aMaybeScriptedPrincipal, aResult);
+}
+
+bool nsGenericHTMLElement::ParseBackgroundAttribute(int32_t aNamespaceID,
+ nsAtom* aAttribute,
+ const nsAString& aValue,
+ nsAttrValue& aResult) {
+ if (aNamespaceID == kNameSpaceID_None &&
+ aAttribute == nsGkAtoms::background && !aValue.IsEmpty()) {
+ // Resolve url to an absolute url
+ Document* doc = OwnerDoc();
+ nsCOMPtr<nsIURI> uri;
+ nsresult rv = nsContentUtils::NewURIWithDocumentCharset(
+ getter_AddRefs(uri), aValue, doc, GetBaseURI());
+ if (NS_FAILED(rv)) {
+ return false;
+ }
+ aResult.SetTo(uri, &aValue);
+ return true;
+ }
+
+ return false;
+}
+
+bool nsGenericHTMLElement::IsAttributeMapped(const nsAtom* aAttribute) const {
+ static const MappedAttributeEntry* const map[] = {sCommonAttributeMap};
+
+ return FindAttributeDependence(aAttribute, map);
+}
+
+nsMapRuleToAttributesFunc nsGenericHTMLElement::GetAttributeMappingFunction()
+ const {
+ return &MapCommonAttributesInto;
+}
+
+nsIFormControlFrame* nsGenericHTMLElement::GetFormControlFrame(
+ bool aFlushFrames) {
+ auto flushType = aFlushFrames ? FlushType::Frames : FlushType::None;
+ nsIFrame* frame = GetPrimaryFrame(flushType);
+ if (!frame) {
+ return nullptr;
+ }
+
+ if (nsIFormControlFrame* f = do_QueryFrame(frame)) {
+ return f;
+ }
+
+ // If we have generated content, the primary frame will be a wrapper frame...
+ // Our real frame will be in its child list.
+ //
+ // FIXME(emilio): I don't think that's true... See bug 155957 for test-cases
+ // though, we should figure out whether this is still needed.
+ for (nsIFrame* kid : frame->PrincipalChildList()) {
+ if (nsIFormControlFrame* f = do_QueryFrame(kid)) {
+ return f;
+ }
+ }
+
+ return nullptr;
+}
+
+static const nsAttrValue::EnumTable kDivAlignTable[] = {
+ {"left", StyleTextAlign::MozLeft},
+ {"right", StyleTextAlign::MozRight},
+ {"center", StyleTextAlign::MozCenter},
+ {"middle", StyleTextAlign::MozCenter},
+ {"justify", StyleTextAlign::Justify},
+ {nullptr, 0}};
+
+static const nsAttrValue::EnumTable kFrameborderTable[] = {
+ {"yes", FrameBorderProperty::Yes},
+ {"no", FrameBorderProperty::No},
+ {"1", FrameBorderProperty::One},
+ {"0", FrameBorderProperty::Zero},
+ {nullptr, 0}};
+
+// TODO(emilio): Nobody uses the parsed attribute here.
+static const nsAttrValue::EnumTable kScrollingTable[] = {
+ {"yes", ScrollingAttribute::Yes},
+ {"no", ScrollingAttribute::No},
+ {"on", ScrollingAttribute::On},
+ {"off", ScrollingAttribute::Off},
+ {"scroll", ScrollingAttribute::Scroll},
+ {"noscroll", ScrollingAttribute::Noscroll},
+ {"auto", ScrollingAttribute::Auto},
+ {nullptr, 0}};
+
+static const nsAttrValue::EnumTable kTableVAlignTable[] = {
+ {"top", StyleVerticalAlignKeyword::Top},
+ {"middle", StyleVerticalAlignKeyword::Middle},
+ {"bottom", StyleVerticalAlignKeyword::Bottom},
+ {"baseline", StyleVerticalAlignKeyword::Baseline},
+ {nullptr, 0}};
+
+bool nsGenericHTMLElement::ParseAlignValue(const nsAString& aString,
+ nsAttrValue& aResult) {
+ static const nsAttrValue::EnumTable kAlignTable[] = {
+ {"left", StyleTextAlign::Left},
+ {"right", StyleTextAlign::Right},
+
+ {"top", StyleVerticalAlignKeyword::Top},
+ {"middle", StyleVerticalAlignKeyword::MozMiddleWithBaseline},
+
+ // Intentionally not bottom.
+ {"bottom", StyleVerticalAlignKeyword::Baseline},
+
+ {"center", StyleVerticalAlignKeyword::MozMiddleWithBaseline},
+ {"baseline", StyleVerticalAlignKeyword::Baseline},
+
+ {"texttop", StyleVerticalAlignKeyword::TextTop},
+ {"absmiddle", StyleVerticalAlignKeyword::Middle},
+ {"abscenter", StyleVerticalAlignKeyword::Middle},
+ {"absbottom", StyleVerticalAlignKeyword::Bottom},
+ {nullptr, 0}};
+
+ static_assert(uint8_t(StyleTextAlign::Left) !=
+ uint8_t(StyleVerticalAlignKeyword::Top) &&
+ uint8_t(StyleTextAlign::Left) !=
+ uint8_t(StyleVerticalAlignKeyword::MozMiddleWithBaseline) &&
+ uint8_t(StyleTextAlign::Left) !=
+ uint8_t(StyleVerticalAlignKeyword::Baseline) &&
+ uint8_t(StyleTextAlign::Left) !=
+ uint8_t(StyleVerticalAlignKeyword::TextTop) &&
+ uint8_t(StyleTextAlign::Left) !=
+ uint8_t(StyleVerticalAlignKeyword::Middle) &&
+ uint8_t(StyleTextAlign::Left) !=
+ uint8_t(StyleVerticalAlignKeyword::Bottom));
+
+ static_assert(uint8_t(StyleTextAlign::Right) !=
+ uint8_t(StyleVerticalAlignKeyword::Top) &&
+ uint8_t(StyleTextAlign::Right) !=
+ uint8_t(StyleVerticalAlignKeyword::MozMiddleWithBaseline) &&
+ uint8_t(StyleTextAlign::Right) !=
+ uint8_t(StyleVerticalAlignKeyword::Baseline) &&
+ uint8_t(StyleTextAlign::Right) !=
+ uint8_t(StyleVerticalAlignKeyword::TextTop) &&
+ uint8_t(StyleTextAlign::Right) !=
+ uint8_t(StyleVerticalAlignKeyword::Middle) &&
+ uint8_t(StyleTextAlign::Right) !=
+ uint8_t(StyleVerticalAlignKeyword::Bottom));
+
+ return aResult.ParseEnumValue(aString, kAlignTable, false);
+}
+
+//----------------------------------------
+
+static const nsAttrValue::EnumTable kTableHAlignTable[] = {
+ {"left", StyleTextAlign::Left}, {"right", StyleTextAlign::Right},
+ {"center", StyleTextAlign::Center}, {"char", StyleTextAlign::Char},
+ {"justify", StyleTextAlign::Justify}, {nullptr, 0}};
+
+bool nsGenericHTMLElement::ParseTableHAlignValue(const nsAString& aString,
+ nsAttrValue& aResult) {
+ return aResult.ParseEnumValue(aString, kTableHAlignTable, false);
+}
+
+//----------------------------------------
+
+// This table is used for td, th, tr, col, thead, tbody and tfoot.
+static const nsAttrValue::EnumTable kTableCellHAlignTable[] = {
+ {"left", StyleTextAlign::MozLeft},
+ {"right", StyleTextAlign::MozRight},
+ {"center", StyleTextAlign::MozCenter},
+ {"char", StyleTextAlign::Char},
+ {"justify", StyleTextAlign::Justify},
+ {"middle", StyleTextAlign::MozCenter},
+ {"absmiddle", StyleTextAlign::Center},
+ {nullptr, 0}};
+
+bool nsGenericHTMLElement::ParseTableCellHAlignValue(const nsAString& aString,
+ nsAttrValue& aResult) {
+ return aResult.ParseEnumValue(aString, kTableCellHAlignTable, false);
+}
+
+//----------------------------------------
+
+bool nsGenericHTMLElement::ParseTableVAlignValue(const nsAString& aString,
+ nsAttrValue& aResult) {
+ return aResult.ParseEnumValue(aString, kTableVAlignTable, false);
+}
+
+bool nsGenericHTMLElement::ParseDivAlignValue(const nsAString& aString,
+ nsAttrValue& aResult) {
+ return aResult.ParseEnumValue(aString, kDivAlignTable, false);
+}
+
+bool nsGenericHTMLElement::ParseImageAttribute(nsAtom* aAttribute,
+ const nsAString& aString,
+ nsAttrValue& aResult) {
+ if (aAttribute == nsGkAtoms::width || aAttribute == nsGkAtoms::height ||
+ aAttribute == nsGkAtoms::hspace || aAttribute == nsGkAtoms::vspace) {
+ return aResult.ParseHTMLDimension(aString);
+ }
+ if (aAttribute == nsGkAtoms::border) {
+ return aResult.ParseNonNegativeIntValue(aString);
+ }
+ return false;
+}
+
+bool nsGenericHTMLElement::ParseReferrerAttribute(const nsAString& aString,
+ nsAttrValue& aResult) {
+ using mozilla::dom::ReferrerInfo;
+ static const nsAttrValue::EnumTable kReferrerPolicyTable[] = {
+ {ReferrerInfo::ReferrerPolicyToString(ReferrerPolicy::No_referrer),
+ static_cast<int16_t>(ReferrerPolicy::No_referrer)},
+ {ReferrerInfo::ReferrerPolicyToString(ReferrerPolicy::Origin),
+ static_cast<int16_t>(ReferrerPolicy::Origin)},
+ {ReferrerInfo::ReferrerPolicyToString(
+ ReferrerPolicy::Origin_when_cross_origin),
+ static_cast<int16_t>(ReferrerPolicy::Origin_when_cross_origin)},
+ {ReferrerInfo::ReferrerPolicyToString(
+ ReferrerPolicy::No_referrer_when_downgrade),
+ static_cast<int16_t>(ReferrerPolicy::No_referrer_when_downgrade)},
+ {ReferrerInfo::ReferrerPolicyToString(ReferrerPolicy::Unsafe_url),
+ static_cast<int16_t>(ReferrerPolicy::Unsafe_url)},
+ {ReferrerInfo::ReferrerPolicyToString(ReferrerPolicy::Strict_origin),
+ static_cast<int16_t>(ReferrerPolicy::Strict_origin)},
+ {ReferrerInfo::ReferrerPolicyToString(ReferrerPolicy::Same_origin),
+ static_cast<int16_t>(ReferrerPolicy::Same_origin)},
+ {ReferrerInfo::ReferrerPolicyToString(
+ ReferrerPolicy::Strict_origin_when_cross_origin),
+ static_cast<int16_t>(ReferrerPolicy::Strict_origin_when_cross_origin)},
+ {nullptr, ReferrerPolicy::_empty}};
+ return aResult.ParseEnumValue(aString, kReferrerPolicyTable, false);
+}
+
+bool nsGenericHTMLElement::ParseFrameborderValue(const nsAString& aString,
+ nsAttrValue& aResult) {
+ return aResult.ParseEnumValue(aString, kFrameborderTable, false);
+}
+
+bool nsGenericHTMLElement::ParseScrollingValue(const nsAString& aString,
+ nsAttrValue& aResult) {
+ return aResult.ParseEnumValue(aString, kScrollingTable, false);
+}
+
+static inline void MapLangAttributeInto(MappedDeclarationsBuilder& aBuilder) {
+ const nsAttrValue* langValue = aBuilder.GetAttr(nsGkAtoms::lang);
+ if (!langValue) {
+ return;
+ }
+ MOZ_ASSERT(langValue->Type() == nsAttrValue::eAtom);
+ aBuilder.SetIdentAtomValueIfUnset(eCSSProperty__x_lang,
+ langValue->GetAtomValue());
+ if (!aBuilder.PropertyIsSet(eCSSProperty_text_emphasis_position)) {
+ const nsAtom* lang = langValue->GetAtomValue();
+ if (nsStyleUtil::MatchesLanguagePrefix(lang, u"zh")) {
+ aBuilder.SetKeywordValue(eCSSProperty_text_emphasis_position,
+ StyleTextEmphasisPosition::UNDER._0);
+ } else if (nsStyleUtil::MatchesLanguagePrefix(lang, u"ja") ||
+ nsStyleUtil::MatchesLanguagePrefix(lang, u"mn")) {
+ // This branch is currently no part of the spec.
+ // See bug 1040668 comment 69 and comment 75.
+ aBuilder.SetKeywordValue(eCSSProperty_text_emphasis_position,
+ StyleTextEmphasisPosition::OVER._0);
+ }
+ }
+}
+
+/**
+ * Handle attributes common to all html elements
+ */
+void nsGenericHTMLElement::MapCommonAttributesIntoExceptHidden(
+ MappedDeclarationsBuilder& aBuilder) {
+ if (!aBuilder.PropertyIsSet(eCSSProperty__moz_user_modify)) {
+ const nsAttrValue* value = aBuilder.GetAttr(nsGkAtoms::contenteditable);
+ if (value) {
+ if (value->Equals(nsGkAtoms::_empty, eCaseMatters) ||
+ value->Equals(nsGkAtoms::_true, eIgnoreCase)) {
+ aBuilder.SetKeywordValue(eCSSProperty__moz_user_modify,
+ StyleUserModify::ReadWrite);
+ } else if (value->Equals(nsGkAtoms::_false, eIgnoreCase)) {
+ aBuilder.SetKeywordValue(eCSSProperty__moz_user_modify,
+ StyleUserModify::ReadOnly);
+ }
+ }
+ }
+
+ MapLangAttributeInto(aBuilder);
+}
+
+void nsGenericHTMLElement::MapCommonAttributesInto(
+ MappedDeclarationsBuilder& aBuilder) {
+ MapCommonAttributesIntoExceptHidden(aBuilder);
+ if (!aBuilder.PropertyIsSet(eCSSProperty_display)) {
+ if (aBuilder.GetAttr(nsGkAtoms::hidden)) {
+ aBuilder.SetKeywordValue(eCSSProperty_display, StyleDisplay::None._0);
+ }
+ }
+}
+
+/* static */
+const nsGenericHTMLElement::MappedAttributeEntry
+ nsGenericHTMLElement::sCommonAttributeMap[] = {{nsGkAtoms::contenteditable},
+ {nsGkAtoms::lang},
+ {nsGkAtoms::hidden},
+ {nullptr}};
+
+/* static */
+const Element::MappedAttributeEntry
+ nsGenericHTMLElement::sImageMarginSizeAttributeMap[] = {{nsGkAtoms::width},
+ {nsGkAtoms::height},
+ {nsGkAtoms::hspace},
+ {nsGkAtoms::vspace},
+ {nullptr}};
+
+/* static */
+const Element::MappedAttributeEntry
+ nsGenericHTMLElement::sImageAlignAttributeMap[] = {{nsGkAtoms::align},
+ {nullptr}};
+
+/* static */
+const Element::MappedAttributeEntry
+ nsGenericHTMLElement::sDivAlignAttributeMap[] = {{nsGkAtoms::align},
+ {nullptr}};
+
+/* static */
+const Element::MappedAttributeEntry
+ nsGenericHTMLElement::sImageBorderAttributeMap[] = {{nsGkAtoms::border},
+ {nullptr}};
+
+/* static */
+const Element::MappedAttributeEntry
+ nsGenericHTMLElement::sBackgroundAttributeMap[] = {
+ {nsGkAtoms::background}, {nsGkAtoms::bgcolor}, {nullptr}};
+
+/* static */
+const Element::MappedAttributeEntry
+ nsGenericHTMLElement::sBackgroundColorAttributeMap[] = {
+ {nsGkAtoms::bgcolor}, {nullptr}};
+
+void nsGenericHTMLElement::MapImageAlignAttributeInto(
+ MappedDeclarationsBuilder& aBuilder) {
+ const nsAttrValue* value = aBuilder.GetAttr(nsGkAtoms::align);
+ if (value && value->Type() == nsAttrValue::eEnum) {
+ int32_t align = value->GetEnumValue();
+ if (!aBuilder.PropertyIsSet(eCSSProperty_float)) {
+ if (align == uint8_t(StyleTextAlign::Left)) {
+ aBuilder.SetKeywordValue(eCSSProperty_float, StyleFloat::Left);
+ } else if (align == uint8_t(StyleTextAlign::Right)) {
+ aBuilder.SetKeywordValue(eCSSProperty_float, StyleFloat::Right);
+ }
+ }
+ if (!aBuilder.PropertyIsSet(eCSSProperty_vertical_align)) {
+ switch (align) {
+ case uint8_t(StyleTextAlign::Left):
+ case uint8_t(StyleTextAlign::Right):
+ break;
+ default:
+ aBuilder.SetKeywordValue(eCSSProperty_vertical_align, align);
+ break;
+ }
+ }
+ }
+}
+
+void nsGenericHTMLElement::MapDivAlignAttributeInto(
+ MappedDeclarationsBuilder& aBuilder) {
+ if (!aBuilder.PropertyIsSet(eCSSProperty_text_align)) {
+ // align: enum
+ const nsAttrValue* value = aBuilder.GetAttr(nsGkAtoms::align);
+ if (value && value->Type() == nsAttrValue::eEnum)
+ aBuilder.SetKeywordValue(eCSSProperty_text_align, value->GetEnumValue());
+ }
+}
+
+void nsGenericHTMLElement::MapVAlignAttributeInto(
+ MappedDeclarationsBuilder& aBuilder) {
+ if (!aBuilder.PropertyIsSet(eCSSProperty_vertical_align)) {
+ // align: enum
+ const nsAttrValue* value = aBuilder.GetAttr(nsGkAtoms::valign);
+ if (value && value->Type() == nsAttrValue::eEnum)
+ aBuilder.SetKeywordValue(eCSSProperty_vertical_align,
+ value->GetEnumValue());
+ }
+}
+
+void nsGenericHTMLElement::MapDimensionAttributeInto(
+ MappedDeclarationsBuilder& aBuilder, nsCSSPropertyID aProp,
+ const nsAttrValue& aValue) {
+ MOZ_ASSERT(!aBuilder.PropertyIsSet(aProp),
+ "Why mapping the same property twice?");
+ if (aValue.Type() == nsAttrValue::eInteger) {
+ return aBuilder.SetPixelValue(aProp, aValue.GetIntegerValue());
+ }
+ if (aValue.Type() == nsAttrValue::ePercent) {
+ return aBuilder.SetPercentValue(aProp, aValue.GetPercentValue());
+ }
+ if (aValue.Type() == nsAttrValue::eDoubleValue) {
+ return aBuilder.SetPixelValue(aProp, aValue.GetDoubleValue());
+ }
+}
+
+void nsGenericHTMLElement::MapImageMarginAttributeInto(
+ MappedDeclarationsBuilder& aBuilder) {
+ // hspace: value
+ if (const nsAttrValue* value = aBuilder.GetAttr(nsGkAtoms::hspace)) {
+ MapDimensionAttributeInto(aBuilder, eCSSProperty_margin_left, *value);
+ MapDimensionAttributeInto(aBuilder, eCSSProperty_margin_right, *value);
+ }
+
+ // vspace: value
+ if (const nsAttrValue* value = aBuilder.GetAttr(nsGkAtoms::vspace)) {
+ MapDimensionAttributeInto(aBuilder, eCSSProperty_margin_top, *value);
+ MapDimensionAttributeInto(aBuilder, eCSSProperty_margin_bottom, *value);
+ }
+}
+
+void nsGenericHTMLElement::MapWidthAttributeInto(
+ MappedDeclarationsBuilder& aBuilder) {
+ if (const nsAttrValue* value = aBuilder.GetAttr(nsGkAtoms::width)) {
+ MapDimensionAttributeInto(aBuilder, eCSSProperty_width, *value);
+ }
+}
+
+void nsGenericHTMLElement::MapHeightAttributeInto(
+ MappedDeclarationsBuilder& aBuilder) {
+ if (const nsAttrValue* value = aBuilder.GetAttr(nsGkAtoms::height)) {
+ MapDimensionAttributeInto(aBuilder, eCSSProperty_height, *value);
+ }
+}
+
+void nsGenericHTMLElement::DoMapAspectRatio(
+ const nsAttrValue& aWidth, const nsAttrValue& aHeight,
+ MappedDeclarationsBuilder& aBuilder) {
+ Maybe<double> w;
+ if (aWidth.Type() == nsAttrValue::eInteger) {
+ w.emplace(aWidth.GetIntegerValue());
+ } else if (aWidth.Type() == nsAttrValue::eDoubleValue) {
+ w.emplace(aWidth.GetDoubleValue());
+ }
+
+ Maybe<double> h;
+ if (aHeight.Type() == nsAttrValue::eInteger) {
+ h.emplace(aHeight.GetIntegerValue());
+ } else if (aHeight.Type() == nsAttrValue::eDoubleValue) {
+ h.emplace(aHeight.GetDoubleValue());
+ }
+
+ if (w && h) {
+ aBuilder.SetAspectRatio(*w, *h);
+ }
+}
+
+void nsGenericHTMLElement::MapImageSizeAttributesInto(
+ MappedDeclarationsBuilder& aBuilder, MapAspectRatio aMapAspectRatio) {
+ auto* width = aBuilder.GetAttr(nsGkAtoms::width);
+ auto* height = aBuilder.GetAttr(nsGkAtoms::height);
+ if (width) {
+ MapDimensionAttributeInto(aBuilder, eCSSProperty_width, *width);
+ }
+ if (height) {
+ MapDimensionAttributeInto(aBuilder, eCSSProperty_height, *height);
+ }
+ if (aMapAspectRatio == MapAspectRatio::Yes && width && height) {
+ DoMapAspectRatio(*width, *height, aBuilder);
+ }
+}
+
+void nsGenericHTMLElement::MapAspectRatioInto(
+ MappedDeclarationsBuilder& aBuilder) {
+ auto* width = aBuilder.GetAttr(nsGkAtoms::width);
+ auto* height = aBuilder.GetAttr(nsGkAtoms::height);
+ if (width && height) {
+ DoMapAspectRatio(*width, *height, aBuilder);
+ }
+}
+
+void nsGenericHTMLElement::MapImageBorderAttributeInto(
+ MappedDeclarationsBuilder& aBuilder) {
+ // border: pixels
+ const nsAttrValue* value = aBuilder.GetAttr(nsGkAtoms::border);
+ if (!value) return;
+
+ nscoord val = 0;
+ if (value->Type() == nsAttrValue::eInteger) val = value->GetIntegerValue();
+
+ aBuilder.SetPixelValueIfUnset(eCSSProperty_border_top_width, (float)val);
+ aBuilder.SetPixelValueIfUnset(eCSSProperty_border_right_width, (float)val);
+ aBuilder.SetPixelValueIfUnset(eCSSProperty_border_bottom_width, (float)val);
+ aBuilder.SetPixelValueIfUnset(eCSSProperty_border_left_width, (float)val);
+
+ aBuilder.SetKeywordValueIfUnset(eCSSProperty_border_top_style,
+ StyleBorderStyle::Solid);
+ aBuilder.SetKeywordValueIfUnset(eCSSProperty_border_right_style,
+ StyleBorderStyle::Solid);
+ aBuilder.SetKeywordValueIfUnset(eCSSProperty_border_bottom_style,
+ StyleBorderStyle::Solid);
+ aBuilder.SetKeywordValueIfUnset(eCSSProperty_border_left_style,
+ StyleBorderStyle::Solid);
+
+ aBuilder.SetCurrentColorIfUnset(eCSSProperty_border_top_color);
+ aBuilder.SetCurrentColorIfUnset(eCSSProperty_border_right_color);
+ aBuilder.SetCurrentColorIfUnset(eCSSProperty_border_bottom_color);
+ aBuilder.SetCurrentColorIfUnset(eCSSProperty_border_left_color);
+}
+
+void nsGenericHTMLElement::MapBackgroundInto(
+ MappedDeclarationsBuilder& aBuilder) {
+ if (!aBuilder.PropertyIsSet(eCSSProperty_background_image)) {
+ // background
+ if (const nsAttrValue* value = aBuilder.GetAttr(nsGkAtoms::background)) {
+ aBuilder.SetBackgroundImage(*value);
+ }
+ }
+}
+
+void nsGenericHTMLElement::MapBGColorInto(MappedDeclarationsBuilder& aBuilder) {
+ if (aBuilder.PropertyIsSet(eCSSProperty_background_color)) {
+ return;
+ }
+ const nsAttrValue* value = aBuilder.GetAttr(nsGkAtoms::bgcolor);
+ nscolor color;
+ if (value && value->GetColorValue(color)) {
+ aBuilder.SetColorValue(eCSSProperty_background_color, color);
+ }
+}
+
+void nsGenericHTMLElement::MapBackgroundAttributesInto(
+ MappedDeclarationsBuilder& aBuilder) {
+ MapBackgroundInto(aBuilder);
+ MapBGColorInto(aBuilder);
+}
+
+//----------------------------------------------------------------------
+
+int32_t nsGenericHTMLElement::GetIntAttr(nsAtom* aAttr,
+ int32_t aDefault) const {
+ const nsAttrValue* attrVal = mAttrs.GetAttr(aAttr);
+ if (attrVal && attrVal->Type() == nsAttrValue::eInteger) {
+ return attrVal->GetIntegerValue();
+ }
+ return aDefault;
+}
+
+nsresult nsGenericHTMLElement::SetIntAttr(nsAtom* aAttr, int32_t aValue) {
+ nsAutoString value;
+ value.AppendInt(aValue);
+
+ return SetAttr(kNameSpaceID_None, aAttr, value, true);
+}
+
+uint32_t nsGenericHTMLElement::GetUnsignedIntAttr(nsAtom* aAttr,
+ uint32_t aDefault) const {
+ const nsAttrValue* attrVal = mAttrs.GetAttr(aAttr);
+ if (!attrVal || attrVal->Type() != nsAttrValue::eInteger) {
+ return aDefault;
+ }
+
+ return attrVal->GetIntegerValue();
+}
+
+uint32_t nsGenericHTMLElement::GetDimensionAttrAsUnsignedInt(
+ nsAtom* aAttr, uint32_t aDefault) const {
+ const nsAttrValue* attrVal = mAttrs.GetAttr(aAttr);
+ if (!attrVal) {
+ return aDefault;
+ }
+
+ if (attrVal->Type() == nsAttrValue::eInteger) {
+ return attrVal->GetIntegerValue();
+ }
+
+ if (attrVal->Type() == nsAttrValue::ePercent) {
+ // This is a nasty hack. When we parsed the value, we stored it as an
+ // ePercent, not eInteger, because there was a '%' after it in the string.
+ // But the spec says to basically re-parse the string as an integer.
+ // Luckily, we can just return the value we have stored. But
+ // GetPercentValue() divides it by 100, so we need to multiply it back.
+ return uint32_t(attrVal->GetPercentValue() * 100.0f);
+ }
+
+ if (attrVal->Type() == nsAttrValue::eDoubleValue) {
+ return uint32_t(attrVal->GetDoubleValue());
+ }
+
+ // Unfortunately, the set of values that are valid dimensions is not a
+ // superset of values that are valid unsigned ints. In particular "+100" is
+ // not a valid dimension, but should parse as the unsigned int "100". So if
+ // we got here and we don't have a valid dimension value, just try re-parsing
+ // the string we have as an integer.
+ nsAutoString val;
+ attrVal->ToString(val);
+ nsContentUtils::ParseHTMLIntegerResultFlags result;
+ int32_t parsedInt = nsContentUtils::ParseHTMLInteger(val, &result);
+ if ((result & nsContentUtils::eParseHTMLInteger_Error) || parsedInt < 0) {
+ return aDefault;
+ }
+
+ return parsedInt;
+}
+
+void nsGenericHTMLElement::GetURIAttr(nsAtom* aAttr, nsAtom* aBaseAttr,
+ nsAString& aResult) const {
+ nsCOMPtr<nsIURI> uri;
+ bool hadAttr = GetURIAttr(aAttr, aBaseAttr, getter_AddRefs(uri));
+ if (!hadAttr) {
+ aResult.Truncate();
+ return;
+ }
+
+ if (!uri) {
+ // Just return the attr value
+ GetAttr(aAttr, aResult);
+ return;
+ }
+
+ nsAutoCString spec;
+ uri->GetSpec(spec);
+ CopyUTF8toUTF16(spec, aResult);
+}
+
+bool nsGenericHTMLElement::GetURIAttr(nsAtom* aAttr, nsAtom* aBaseAttr,
+ nsIURI** aURI) const {
+ *aURI = nullptr;
+
+ const nsAttrValue* attr = mAttrs.GetAttr(aAttr);
+ if (!attr) {
+ return false;
+ }
+
+ nsCOMPtr<nsIURI> baseURI = GetBaseURI();
+
+ if (aBaseAttr) {
+ nsAutoString baseAttrValue;
+ if (GetAttr(aBaseAttr, baseAttrValue)) {
+ nsCOMPtr<nsIURI> baseAttrURI;
+ nsresult rv = nsContentUtils::NewURIWithDocumentCharset(
+ getter_AddRefs(baseAttrURI), baseAttrValue, OwnerDoc(), baseURI);
+ if (NS_FAILED(rv)) {
+ return true;
+ }
+ baseURI.swap(baseAttrURI);
+ }
+ }
+
+ // Don't care about return value. If it fails, we still want to
+ // return true, and *aURI will be null.
+ nsContentUtils::NewURIWithDocumentCharset(aURI, attr->GetStringValue(),
+ OwnerDoc(), baseURI);
+ return true;
+}
+
+bool nsGenericHTMLElement::IsLabelable() const {
+ return IsAnyOfHTMLElements(nsGkAtoms::progress, nsGkAtoms::meter);
+}
+
+/* static */
+bool nsGenericHTMLElement::MatchLabelsElement(Element* aElement,
+ int32_t aNamespaceID,
+ nsAtom* aAtom, void* aData) {
+ HTMLLabelElement* element = HTMLLabelElement::FromNode(aElement);
+ return element && element->GetControl() == aData;
+}
+
+already_AddRefed<nsINodeList> nsGenericHTMLElement::Labels() {
+ MOZ_ASSERT(IsLabelable(),
+ "Labels() only allow labelable elements to use it.");
+ nsExtendedDOMSlots* slots = ExtendedDOMSlots();
+
+ if (!slots->mLabelsList) {
+ slots->mLabelsList =
+ new nsLabelsNodeList(SubtreeRoot(), MatchLabelsElement, nullptr, this);
+ }
+
+ RefPtr<nsLabelsNodeList> labels = slots->mLabelsList;
+ return labels.forget();
+}
+
+// static
+bool nsGenericHTMLElement::LegacyTouchAPIEnabled(JSContext* aCx,
+ JSObject* aGlobal) {
+ return TouchEvent::LegacyAPIEnabled(aCx, aGlobal);
+}
+
+bool nsGenericHTMLElement::IsFormControlDefaultFocusable(
+ bool aWithMouse) const {
+ if (!aWithMouse) {
+ return true;
+ }
+ switch (StaticPrefs::accessibility_mouse_focuses_formcontrol()) {
+ case 0:
+ return false;
+ case 1:
+ return true;
+ default:
+ return !IsInChromeDocument();
+ }
+}
+
+//----------------------------------------------------------------------
+
+nsGenericHTMLFormElement::nsGenericHTMLFormElement(
+ already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo)
+ : nsGenericHTMLElement(std::move(aNodeInfo)) {
+ // We should add the ElementState::ENABLED bit here as needed, but that
+ // depends on our type, which is not initialized yet. So we have to do this
+ // in subclasses. Same for a couple other bits.
+}
+
+void nsGenericHTMLFormElement::ClearForm(bool aRemoveFromForm,
+ bool aUnbindOrDelete) {
+ MOZ_ASSERT(IsFormAssociatedElement());
+
+ HTMLFormElement* form = GetFormInternal();
+ NS_ASSERTION((form != nullptr) == HasFlag(ADDED_TO_FORM),
+ "Form control should have had flag set correctly");
+
+ if (!form) {
+ return;
+ }
+
+ if (aRemoveFromForm) {
+ nsAutoString nameVal, idVal;
+ GetAttr(nsGkAtoms::name, nameVal);
+ GetAttr(nsGkAtoms::id, idVal);
+
+ form->RemoveElement(this, true);
+
+ if (!nameVal.IsEmpty()) {
+ form->RemoveElementFromTable(this, nameVal);
+ }
+
+ if (!idVal.IsEmpty()) {
+ form->RemoveElementFromTable(this, idVal);
+ }
+ }
+
+ UnsetFlags(ADDED_TO_FORM);
+ SetFormInternal(nullptr, false);
+ AfterClearForm(aUnbindOrDelete);
+}
+
+nsresult nsGenericHTMLFormElement::BindToTree(BindContext& aContext,
+ nsINode& aParent) {
+ nsresult rv = nsGenericHTMLElement::BindToTree(aContext, aParent);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (IsFormAssociatedElement()) {
+ // If @form is set, the element *has* to be in a composed document,
+ // otherwise it wouldn't be possible to find an element with the
+ // corresponding id. If @form isn't set, the element *has* to have a parent,
+ // otherwise it wouldn't be possible to find a form ancestor. We should not
+ // call UpdateFormOwner if none of these conditions are fulfilled.
+ if (HasAttr(nsGkAtoms::form) ? IsInComposedDoc() : aParent.IsContent()) {
+ UpdateFormOwner(true, nullptr);
+ }
+ }
+
+ // Set parent fieldset which should be used for the disabled state.
+ UpdateFieldSet(false);
+ return NS_OK;
+}
+
+void nsGenericHTMLFormElement::UnbindFromTree(bool aNullParent) {
+ // Save state before doing anything else.
+ SaveState();
+
+ if (IsFormAssociatedElement()) {
+ if (HTMLFormElement* form = GetFormInternal()) {
+ // Might need to unset form
+ if (aNullParent) {
+ // No more parent means no more form
+ ClearForm(true, true);
+ } else {
+ // Recheck whether we should still have an form.
+ if (HasAttr(nsGkAtoms::form) || !FindAncestorForm(form)) {
+ ClearForm(true, true);
+ } else {
+ UnsetFlags(MAYBE_ORPHAN_FORM_ELEMENT);
+ }
+ }
+ }
+
+ // We have to remove the form id observer if there was one.
+ // We will re-add one later if needed (during bind to tree).
+ if (nsContentUtils::HasNonEmptyAttr(this, kNameSpaceID_None,
+ nsGkAtoms::form)) {
+ RemoveFormIdObserver();
+ }
+ }
+
+ nsGenericHTMLElement::UnbindFromTree(aNullParent);
+
+ // The element might not have a fieldset anymore.
+ UpdateFieldSet(false);
+}
+
+void nsGenericHTMLFormElement::BeforeSetAttr(int32_t aNameSpaceID,
+ nsAtom* aName,
+ const nsAttrValue* aValue,
+ bool aNotify) {
+ if (aNameSpaceID == kNameSpaceID_None && IsFormAssociatedElement()) {
+ nsAutoString tmp;
+ HTMLFormElement* form = GetFormInternal();
+
+ // remove the control from the hashtable as needed
+
+ if (form && (aName == nsGkAtoms::name || aName == nsGkAtoms::id)) {
+ GetAttr(aName, tmp);
+
+ if (!tmp.IsEmpty()) {
+ form->RemoveElementFromTable(this, tmp);
+ }
+ }
+
+ if (form && aName == nsGkAtoms::type) {
+ GetAttr(nsGkAtoms::name, tmp);
+
+ if (!tmp.IsEmpty()) {
+ form->RemoveElementFromTable(this, tmp);
+ }
+
+ GetAttr(nsGkAtoms::id, tmp);
+
+ if (!tmp.IsEmpty()) {
+ form->RemoveElementFromTable(this, tmp);
+ }
+
+ form->RemoveElement(this, false);
+ }
+
+ if (aName == nsGkAtoms::form) {
+ // If @form isn't set or set to the empty string, there were no observer
+ // so we don't have to remove it.
+ if (nsContentUtils::HasNonEmptyAttr(this, kNameSpaceID_None,
+ nsGkAtoms::form)) {
+ // The current form id observer is no longer needed.
+ // A new one may be added in AfterSetAttr.
+ RemoveFormIdObserver();
+ }
+ }
+ }
+
+ return nsGenericHTMLElement::BeforeSetAttr(aNameSpaceID, aName, aValue,
+ aNotify);
+}
+
+void nsGenericHTMLFormElement::AfterSetAttr(
+ int32_t aNameSpaceID, nsAtom* aName, const nsAttrValue* aValue,
+ const nsAttrValue* aOldValue, nsIPrincipal* aMaybeScriptedPrincipal,
+ bool aNotify) {
+ if (aNameSpaceID == kNameSpaceID_None && IsFormAssociatedElement()) {
+ HTMLFormElement* form = GetFormInternal();
+
+ // add the control to the hashtable as needed
+ if (form && (aName == nsGkAtoms::name || aName == nsGkAtoms::id) &&
+ aValue && !aValue->IsEmptyString()) {
+ MOZ_ASSERT(aValue->Type() == nsAttrValue::eAtom,
+ "Expected atom value for name/id");
+ form->AddElementToTable(this,
+ nsDependentAtomString(aValue->GetAtomValue()));
+ }
+
+ if (form && aName == nsGkAtoms::type) {
+ nsAutoString tmp;
+
+ GetAttr(nsGkAtoms::name, tmp);
+
+ if (!tmp.IsEmpty()) {
+ form->AddElementToTable(this, tmp);
+ }
+
+ GetAttr(nsGkAtoms::id, tmp);
+
+ if (!tmp.IsEmpty()) {
+ form->AddElementToTable(this, tmp);
+ }
+
+ form->AddElement(this, false, aNotify);
+ }
+
+ if (aName == nsGkAtoms::form) {
+ // We need a new form id observer.
+ DocumentOrShadowRoot* docOrShadow =
+ GetUncomposedDocOrConnectedShadowRoot();
+ if (docOrShadow) {
+ Element* formIdElement = nullptr;
+ if (aValue && !aValue->IsEmptyString()) {
+ formIdElement = AddFormIdObserver();
+ }
+
+ // Because we have a new @form value (or no more @form), we have to
+ // update our form owner.
+ UpdateFormOwner(false, formIdElement);
+ }
+ }
+ }
+
+ return nsGenericHTMLElement::AfterSetAttr(
+ aNameSpaceID, aName, aValue, aOldValue, aMaybeScriptedPrincipal, aNotify);
+}
+
+void nsGenericHTMLFormElement::ForgetFieldSet(nsIContent* aFieldset) {
+ MOZ_DIAGNOSTIC_ASSERT(IsFormAssociatedElement());
+ if (GetFieldSetInternal() == aFieldset) {
+ SetFieldSetInternal(nullptr);
+ }
+}
+
+Element* nsGenericHTMLFormElement::AddFormIdObserver() {
+ MOZ_ASSERT(IsFormAssociatedElement());
+
+ nsAutoString formId;
+ DocumentOrShadowRoot* docOrShadow = GetUncomposedDocOrConnectedShadowRoot();
+ GetAttr(nsGkAtoms::form, formId);
+ NS_ASSERTION(!formId.IsEmpty(),
+ "@form value should not be the empty string!");
+ RefPtr<nsAtom> atom = NS_Atomize(formId);
+
+ return docOrShadow->AddIDTargetObserver(atom, FormIdUpdated, this, false);
+}
+
+void nsGenericHTMLFormElement::RemoveFormIdObserver() {
+ MOZ_ASSERT(IsFormAssociatedElement());
+
+ DocumentOrShadowRoot* docOrShadow = GetUncomposedDocOrConnectedShadowRoot();
+ if (!docOrShadow) {
+ return;
+ }
+
+ nsAutoString formId;
+ GetAttr(nsGkAtoms::form, formId);
+ NS_ASSERTION(!formId.IsEmpty(),
+ "@form value should not be the empty string!");
+ RefPtr<nsAtom> atom = NS_Atomize(formId);
+
+ docOrShadow->RemoveIDTargetObserver(atom, FormIdUpdated, this, false);
+}
+
+/* static */
+bool nsGenericHTMLFormElement::FormIdUpdated(Element* aOldElement,
+ Element* aNewElement,
+ void* aData) {
+ nsGenericHTMLFormElement* element =
+ static_cast<nsGenericHTMLFormElement*>(aData);
+
+ NS_ASSERTION(element->IsHTMLElement(), "aData should be an HTML element");
+
+ element->UpdateFormOwner(false, aNewElement);
+
+ return true;
+}
+
+bool nsGenericHTMLFormElement::IsElementDisabledForEvents(WidgetEvent* aEvent,
+ nsIFrame* aFrame) {
+ MOZ_ASSERT(aEvent);
+
+ // Allow dispatch of CustomEvent and untrusted Events.
+ if (!aEvent->IsTrusted()) {
+ return false;
+ }
+
+ switch (aEvent->mMessage) {
+ case eAnimationStart:
+ case eAnimationEnd:
+ case eAnimationIteration:
+ case eAnimationCancel:
+ case eFormChange:
+ case eMouseMove:
+ case eMouseOver:
+ case eMouseOut:
+ case eMouseEnter:
+ case eMouseLeave:
+ case ePointerMove:
+ case ePointerOver:
+ case ePointerOut:
+ case ePointerEnter:
+ case ePointerLeave:
+ case eTransitionCancel:
+ case eTransitionEnd:
+ case eTransitionRun:
+ case eTransitionStart:
+ case eWheel:
+ case eLegacyMouseLineOrPageScroll:
+ case eLegacyMousePixelScroll:
+ return false;
+ case eFocus:
+ case eBlur:
+ case eFocusIn:
+ case eFocusOut:
+ case eKeyPress:
+ case eKeyUp:
+ case eKeyDown:
+ if (StaticPrefs::dom_forms_always_allow_key_and_focus_events_enabled()) {
+ return false;
+ }
+ [[fallthrough]];
+ case ePointerDown:
+ case ePointerUp:
+ case ePointerCancel:
+ case ePointerGotCapture:
+ case ePointerLostCapture:
+ if (StaticPrefs::dom_forms_always_allow_pointer_events_enabled()) {
+ return false;
+ }
+ [[fallthrough]];
+ default:
+ break;
+ }
+
+ if (aEvent->mSpecifiedEventType == nsGkAtoms::oninput) {
+ return false;
+ }
+
+ // FIXME(emilio): This poking at the style of the frame is slightly bogus
+ // unless we flush before every event, which we don't really want to do.
+ if (aFrame && aFrame->StyleUI()->UserInput() == StyleUserInput::None) {
+ return true;
+ }
+
+ return IsDisabled();
+}
+
+void nsGenericHTMLFormElement::UpdateFormOwner(bool aBindToTree,
+ Element* aFormIdElement) {
+ MOZ_ASSERT(IsFormAssociatedElement());
+ MOZ_ASSERT(!aBindToTree || !aFormIdElement,
+ "aFormIdElement shouldn't be set if aBindToTree is true!");
+
+ HTMLFormElement* form = GetFormInternal();
+ if (!aBindToTree) {
+ ClearForm(true, false);
+ form = nullptr;
+ }
+
+ HTMLFormElement* oldForm = form;
+ if (!form) {
+ // If @form is set, we have to use that to find the form.
+ nsAutoString formId;
+ if (GetAttr(nsGkAtoms::form, formId)) {
+ if (!formId.IsEmpty()) {
+ Element* element = nullptr;
+
+ if (aBindToTree) {
+ element = AddFormIdObserver();
+ } else {
+ element = aFormIdElement;
+ }
+
+ NS_ASSERTION(!IsInComposedDoc() ||
+ element == GetUncomposedDocOrConnectedShadowRoot()
+ ->GetElementById(formId),
+ "element should be equals to the current element "
+ "associated with the id in @form!");
+
+ if (element && element->IsHTMLElement(nsGkAtoms::form) &&
+ nsContentUtils::IsInSameAnonymousTree(this, element)) {
+ form = static_cast<HTMLFormElement*>(element);
+ SetFormInternal(form, aBindToTree);
+ }
+ }
+ } else {
+ // We now have a parent, so we may have picked up an ancestor form. Search
+ // for it. Note that if form is already set we don't want to do this,
+ // because that means someone (probably the content sink) has already set
+ // it to the right value. Also note that even if being bound here didn't
+ // change our parent, we still need to search, since our parent chain
+ // probably changed _somewhere_.
+ form = FindAncestorForm();
+ SetFormInternal(form, aBindToTree);
+ }
+ }
+
+ if (form && !HasFlag(ADDED_TO_FORM)) {
+ // Now we need to add ourselves to the form
+ nsAutoString nameVal, idVal;
+ GetAttr(nsGkAtoms::name, nameVal);
+ GetAttr(nsGkAtoms::id, idVal);
+
+ SetFlags(ADDED_TO_FORM);
+
+ // Notify only if we just found this form.
+ form->AddElement(this, true, oldForm == nullptr);
+
+ if (!nameVal.IsEmpty()) {
+ form->AddElementToTable(this, nameVal);
+ }
+
+ if (!idVal.IsEmpty()) {
+ form->AddElementToTable(this, idVal);
+ }
+ }
+}
+
+void nsGenericHTMLFormElement::UpdateFieldSet(bool aNotify) {
+ if (IsInNativeAnonymousSubtree() || !IsFormAssociatedElement()) {
+ MOZ_ASSERT_IF(IsFormAssociatedElement(), !GetFieldSetInternal());
+ return;
+ }
+
+ nsIContent* parent = nullptr;
+ nsIContent* prev = nullptr;
+ HTMLFieldSetElement* fieldset = GetFieldSetInternal();
+
+ for (parent = GetParent(); parent;
+ prev = parent, parent = parent->GetParent()) {
+ HTMLFieldSetElement* parentFieldset = HTMLFieldSetElement::FromNode(parent);
+ if (parentFieldset && (!prev || parentFieldset->GetFirstLegend() != prev)) {
+ if (fieldset == parentFieldset) {
+ // We already have the right fieldset;
+ return;
+ }
+
+ if (fieldset) {
+ fieldset->RemoveElement(this);
+ }
+ SetFieldSetInternal(parentFieldset);
+ parentFieldset->AddElement(this);
+
+ // The disabled state may have changed
+ FieldSetDisabledChanged(aNotify);
+ return;
+ }
+ }
+
+ // No fieldset found.
+ if (fieldset) {
+ fieldset->RemoveElement(this);
+ SetFieldSetInternal(nullptr);
+ // The disabled state may have changed
+ FieldSetDisabledChanged(aNotify);
+ }
+}
+
+void nsGenericHTMLFormElement::UpdateDisabledState(bool aNotify) {
+ if (!CanBeDisabled()) {
+ return;
+ }
+
+ HTMLFieldSetElement* fieldset = GetFieldSetInternal();
+ const bool isDisabled =
+ HasAttr(nsGkAtoms::disabled) || (fieldset && fieldset->IsDisabled());
+
+ const ElementState disabledStates =
+ isDisabled ? ElementState::DISABLED : ElementState::ENABLED;
+
+ ElementState oldDisabledStates = State() & ElementState::DISABLED_STATES;
+ ElementState changedStates = disabledStates ^ oldDisabledStates;
+
+ if (!changedStates.IsEmpty()) {
+ ToggleStates(changedStates, aNotify);
+ if (DoesReadOnlyApply()) {
+ // :disabled influences :read-only / :read-write.
+ UpdateReadOnlyState(aNotify);
+ }
+ }
+}
+
+bool nsGenericHTMLFormElement::IsReadOnlyInternal() const {
+ if (DoesReadOnlyApply()) {
+ return IsDisabled() || GetBoolAttr(nsGkAtoms::readonly);
+ }
+ return nsGenericHTMLElement::IsReadOnlyInternal();
+}
+
+void nsGenericHTMLFormElement::FieldSetDisabledChanged(bool aNotify) {
+ UpdateDisabledState(aNotify);
+}
+
+void nsGenericHTMLFormElement::SaveSubtreeState() {
+ SaveState();
+
+ nsGenericHTMLElement::SaveSubtreeState();
+}
+
+//----------------------------------------------------------------------
+
+void nsGenericHTMLElement::Click(CallerType aCallerType) {
+ if (HandlingClick()) {
+ return;
+ }
+
+ // There are two notions of disabled.
+ // "disabled":
+ // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#attr-fe-disabled
+ // "actually disabled":
+ // https://html.spec.whatwg.org/multipage/semantics-other.html#concept-element-disabled
+ // click() reads the former but IsDisabled() is for the latter. <fieldset> is
+ // included only in the latter, so we exclude it here.
+ // XXX(krosylight): What about <optgroup>? And should we add a separate method
+ // for this?
+ if (IsDisabled() &&
+ !(mNodeInfo->Equals(nsGkAtoms::fieldset) &&
+ StaticPrefs::dom_forms_fieldset_disable_only_descendants_enabled())) {
+ return;
+ }
+
+ // Strong in case the event kills it
+ nsCOMPtr<Document> doc = GetComposedDoc();
+
+ RefPtr<nsPresContext> context;
+ if (doc) {
+ PresShell* presShell = doc->GetPresShell();
+ if (!presShell) {
+ // We need the nsPresContext for dispatching the click event. In some
+ // rare cases we need to flush notifications to force creation of the
+ // nsPresContext here (for example when a script calls button.click()
+ // from script early during page load). We only flush the notifications
+ // if the PresShell hasn't been created yet, to limit the performance
+ // impact.
+ doc->FlushPendingNotifications(FlushType::EnsurePresShellInitAndFrames);
+ presShell = doc->GetPresShell();
+ }
+ if (presShell) {
+ context = presShell->GetPresContext();
+ }
+ }
+
+ SetHandlingClick();
+
+ // Mark this event trusted if Click() is called from system code.
+ WidgetMouseEvent event(aCallerType == CallerType::System, eMouseClick,
+ nullptr, WidgetMouseEvent::eReal);
+ event.mFlags.mIsPositionless = true;
+ event.mInputSource = MouseEvent_Binding::MOZ_SOURCE_UNKNOWN;
+
+ EventDispatcher::Dispatch(this, context, &event);
+
+ ClearHandlingClick();
+}
+
+bool nsGenericHTMLElement::IsHTMLFocusable(bool aWithMouse, bool* aIsFocusable,
+ int32_t* aTabIndex) {
+ MOZ_ASSERT(aIsFocusable);
+ MOZ_ASSERT(aTabIndex);
+ if (ShadowRoot* root = GetShadowRoot()) {
+ if (root->DelegatesFocus()) {
+ *aIsFocusable = false;
+ return true;
+ }
+ }
+
+ if (!IsInComposedDoc() || IsInDesignMode()) {
+ // In designMode documents we only allow focusing the document.
+ *aTabIndex = -1;
+ *aIsFocusable = false;
+ return true;
+ }
+
+ *aTabIndex = TabIndex();
+ bool disabled = false;
+ bool disallowOverridingFocusability = true;
+ Maybe<int32_t> attrVal = GetTabIndexAttrValue();
+ if (IsEditingHost()) {
+ // Editable roots should always be focusable.
+ disallowOverridingFocusability = true;
+
+ // Ignore the disabled attribute in editable contentEditable/designMode
+ // roots.
+ if (attrVal.isNothing()) {
+ // The default value for tabindex should be 0 for editable
+ // contentEditable roots.
+ *aTabIndex = 0;
+ }
+ } else {
+ disallowOverridingFocusability = false;
+
+ // Just check for disabled attribute on form controls
+ disabled = IsDisabled();
+ if (disabled) {
+ *aTabIndex = -1;
+ }
+ }
+
+ // If a tabindex is specified at all, or the default tabindex is 0, we're
+ // focusable.
+ *aIsFocusable = (*aTabIndex >= 0 || (!disabled && attrVal.isSome()));
+ return disallowOverridingFocusability;
+}
+
+Result<bool, nsresult> nsGenericHTMLElement::PerformAccesskey(
+ bool aKeyCausesActivation, bool aIsTrustedEvent) {
+ RefPtr<nsPresContext> presContext = GetPresContext(eForComposedDoc);
+ if (!presContext) {
+ return Err(NS_ERROR_UNEXPECTED);
+ }
+
+ // It's hard to say what HTML4 wants us to do in all cases.
+ bool focused = true;
+ if (RefPtr<nsFocusManager> fm = nsFocusManager::GetFocusManager()) {
+ fm->SetFocus(this, nsIFocusManager::FLAG_BYKEY);
+
+ // Return true if the element became the current focus within its window.
+ nsPIDOMWindowOuter* window = OwnerDoc()->GetWindow();
+ focused = window && window->GetFocusedElement() == this;
+ }
+
+ if (aKeyCausesActivation) {
+ // Click on it if the users prefs indicate to do so.
+ AutoHandlingUserInputStatePusher userInputStatePusher(aIsTrustedEvent);
+ AutoPopupStatePusher popupStatePusher(
+ aIsTrustedEvent ? PopupBlocker::openAllowed : PopupBlocker::openAbused);
+ DispatchSimulatedClick(this, aIsTrustedEvent, presContext);
+ return focused;
+ }
+
+ // If the accesskey won't cause the activation and the focus isn't changed,
+ // either. Return error so EventStateManager would try to find next element
+ // to handle the accesskey.
+ return focused ? Result<bool, nsresult>{focused} : Err(NS_ERROR_ABORT);
+}
+
+void nsGenericHTMLElement::HandleKeyboardActivation(
+ EventChainPostVisitor& aVisitor) {
+ MOZ_ASSERT(aVisitor.mEvent->HasKeyEventMessage());
+ MOZ_ASSERT(aVisitor.mEvent->IsTrusted());
+
+ // If focused element is different from this element, it may be editable.
+ // In that case, associated editor for the element should handle the keyboard
+ // instead. Therefore, if this is not the focused element, we should not
+ // handle the event here. Note that this element may be an editing host,
+ // i.e., focused and editable. In the case, keyboard events should be
+ // handled by the focused element instead of associated editor because
+ // Chrome handles the case so. For compatibility with Chrome, we follow them.
+ if (nsFocusManager::GetFocusedElementStatic() != this) {
+ return;
+ }
+
+ const auto message = aVisitor.mEvent->mMessage;
+ const WidgetKeyboardEvent* keyEvent = aVisitor.mEvent->AsKeyboardEvent();
+ if (nsEventStatus_eIgnore != aVisitor.mEventStatus) {
+ if (message == eKeyUp && keyEvent->mKeyCode == NS_VK_SPACE) {
+ // Unset the flag even if the event is default-prevented or something.
+ UnsetFlags(HTML_ELEMENT_ACTIVE_FOR_KEYBOARD);
+ }
+ return;
+ }
+
+ bool shouldActivate = false;
+ switch (message) {
+ case eKeyDown:
+ if (keyEvent->ShouldWorkAsSpaceKey()) {
+ SetFlags(HTML_ELEMENT_ACTIVE_FOR_KEYBOARD);
+ }
+ return;
+ case eKeyPress:
+ shouldActivate = keyEvent->mKeyCode == NS_VK_RETURN;
+ if (keyEvent->ShouldWorkAsSpaceKey()) {
+ // Consume 'space' key to prevent scrolling the page down.
+ aVisitor.mEventStatus = nsEventStatus_eConsumeNoDefault;
+ }
+ break;
+ case eKeyUp:
+ shouldActivate = keyEvent->ShouldWorkAsSpaceKey() &&
+ HasFlag(HTML_ELEMENT_ACTIVE_FOR_KEYBOARD);
+ if (shouldActivate) {
+ UnsetFlags(HTML_ELEMENT_ACTIVE_FOR_KEYBOARD);
+ }
+ break;
+ default:
+ MOZ_ASSERT_UNREACHABLE("why didn't we bail out earlier?");
+ break;
+ }
+
+ if (!shouldActivate) {
+ return;
+ }
+
+ RefPtr<nsPresContext> presContext = aVisitor.mPresContext;
+ DispatchSimulatedClick(this, aVisitor.mEvent->IsTrusted(), presContext);
+ aVisitor.mEventStatus = nsEventStatus_eConsumeNoDefault;
+}
+
+nsresult nsGenericHTMLElement::DispatchSimulatedClick(
+ nsGenericHTMLElement* aElement, bool aIsTrusted,
+ nsPresContext* aPresContext) {
+ WidgetMouseEvent event(aIsTrusted, eMouseClick, nullptr,
+ WidgetMouseEvent::eReal);
+ event.mInputSource = MouseEvent_Binding::MOZ_SOURCE_KEYBOARD;
+ event.mFlags.mIsPositionless = true;
+ return EventDispatcher::Dispatch(aElement, aPresContext, &event);
+}
+
+already_AddRefed<EditorBase> nsGenericHTMLElement::GetAssociatedEditor() {
+ // If contenteditable is ever implemented, it might need to do something
+ // different here?
+
+ RefPtr<TextEditor> textEditor = GetTextEditorInternal();
+ return textEditor.forget();
+}
+
+// static
+void nsGenericHTMLElement::SyncEditorsOnSubtree(nsIContent* content) {
+ /* Sync this node */
+ nsGenericHTMLElement* element = FromNode(content);
+ if (element) {
+ if (RefPtr<EditorBase> editorBase = element->GetAssociatedEditor()) {
+ editorBase->SyncRealTimeSpell();
+ }
+ }
+
+ /* Sync all children */
+ for (nsIContent* child = content->GetFirstChild(); child;
+ child = child->GetNextSibling()) {
+ SyncEditorsOnSubtree(child);
+ }
+}
+
+static void MakeContentDescendantsEditable(nsIContent* aContent) {
+ // If aContent is not an element, we just need to update its
+ // internal editable state and don't need to notify anyone about
+ // that. For elements, we need to send a ElementStateChanged
+ // notification.
+ if (!aContent->IsElement()) {
+ aContent->UpdateEditableState(false);
+ return;
+ }
+
+ Element* element = aContent->AsElement();
+
+ element->UpdateEditableState(true);
+
+ for (nsIContent* child = aContent->GetFirstChild(); child;
+ child = child->GetNextSibling()) {
+ if (!child->IsElement() ||
+ !child->AsElement()->HasAttr(nsGkAtoms::contenteditable)) {
+ MakeContentDescendantsEditable(child);
+ }
+ }
+}
+
+void nsGenericHTMLElement::ChangeEditableState(int32_t aChange) {
+ Document* document = GetComposedDoc();
+ if (!document) {
+ return;
+ }
+
+ Document::EditingState previousEditingState = Document::EditingState::eOff;
+ if (aChange != 0) {
+ document->ChangeContentEditableCount(this, aChange);
+ previousEditingState = document->GetEditingState();
+ }
+
+ // MakeContentDescendantsEditable is going to call ElementStateChanged for
+ // this element and all descendants if editable state has changed.
+ // We might as well wrap it all in one script blocker.
+ nsAutoScriptBlocker scriptBlocker;
+ MakeContentDescendantsEditable(this);
+
+ // If the document already had contenteditable and JS adds new
+ // contenteditable, that might cause changing editing host to current editing
+ // host's ancestor. In such case, HTMLEditor needs to know that
+ // synchronously to update selection limitter.
+ // Additionally, elements in shadow DOM is not editable in the normal cases,
+ // but if its content has `contenteditable`, only in it can be ediable.
+ // So we don't need to notify HTMLEditor of this change only when we're not
+ // in shadow DOM and the composed document is in design mode.
+ if (IsInDesignMode() && !IsInShadowTree() && aChange > 0 &&
+ previousEditingState == Document::EditingState::eContentEditable) {
+ if (HTMLEditor* htmlEditor =
+ nsContentUtils::GetHTMLEditor(document->GetPresContext())) {
+ htmlEditor->NotifyEditingHostMaybeChanged();
+ }
+ }
+}
+
+//----------------------------------------------------------------------
+
+nsGenericHTMLFormControlElement::nsGenericHTMLFormControlElement(
+ already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo, FormControlType aType)
+ : nsGenericHTMLFormElement(std::move(aNodeInfo)),
+ nsIFormControl(aType),
+ mForm(nullptr),
+ mFieldSet(nullptr) {}
+
+nsGenericHTMLFormControlElement::~nsGenericHTMLFormControlElement() {
+ if (mFieldSet) {
+ mFieldSet->RemoveElement(this);
+ }
+
+ // Check that this element doesn't know anything about its form at this point.
+ NS_ASSERTION(!mForm, "mForm should be null at this point!");
+}
+
+NS_IMPL_ISUPPORTS_INHERITED(nsGenericHTMLFormControlElement,
+ nsGenericHTMLFormElement, nsIFormControl)
+
+nsINode* nsGenericHTMLFormControlElement::GetScopeChainParent() const {
+ return mForm ? mForm : nsGenericHTMLElement::GetScopeChainParent();
+}
+
+nsIContent::IMEState nsGenericHTMLFormControlElement::GetDesiredIMEState() {
+ TextEditor* textEditor = GetTextEditorInternal();
+ if (!textEditor) {
+ return nsGenericHTMLFormElement::GetDesiredIMEState();
+ }
+ IMEState state;
+ nsresult rv = textEditor->GetPreferredIMEState(&state);
+ if (NS_FAILED(rv)) {
+ return nsGenericHTMLFormElement::GetDesiredIMEState();
+ }
+ return state;
+}
+
+void nsGenericHTMLFormControlElement::GetAutocapitalize(
+ nsAString& aValue) const {
+ if (nsContentUtils::HasNonEmptyAttr(this, kNameSpaceID_None,
+ nsGkAtoms::autocapitalize)) {
+ nsGenericHTMLFormElement::GetAutocapitalize(aValue);
+ return;
+ }
+
+ if (mForm && IsAutocapitalizeInheriting()) {
+ mForm->GetAutocapitalize(aValue);
+ }
+}
+
+bool nsGenericHTMLFormControlElement::IsHTMLFocusable(bool aWithMouse,
+ bool* aIsFocusable,
+ int32_t* aTabIndex) {
+ if (nsGenericHTMLFormElement::IsHTMLFocusable(aWithMouse, aIsFocusable,
+ aTabIndex)) {
+ return true;
+ }
+
+ *aIsFocusable = *aIsFocusable && IsFormControlDefaultFocusable(aWithMouse);
+ return false;
+}
+
+void nsGenericHTMLFormControlElement::GetEventTargetParent(
+ EventChainPreVisitor& aVisitor) {
+ if (aVisitor.mEvent->IsTrusted() && (aVisitor.mEvent->mMessage == eFocus ||
+ aVisitor.mEvent->mMessage == eBlur)) {
+ // We have to handle focus/blur event to change focus states in
+ // PreHandleEvent to prevent it breaks event target chain creation.
+ aVisitor.mWantsPreHandleEvent = true;
+ }
+ nsGenericHTMLFormElement::GetEventTargetParent(aVisitor);
+}
+
+nsresult nsGenericHTMLFormControlElement::PreHandleEvent(
+ EventChainVisitor& aVisitor) {
+ if (aVisitor.mEvent->IsTrusted()) {
+ switch (aVisitor.mEvent->mMessage) {
+ case eFocus: {
+ // Check to see if focus has bubbled up from a form control's
+ // child textfield or button. If that's the case, don't focus
+ // this parent file control -- leave focus on the child.
+ nsIFormControlFrame* formControlFrame = GetFormControlFrame(true);
+ if (formControlFrame &&
+ aVisitor.mEvent->mOriginalTarget == static_cast<nsINode*>(this)) {
+ formControlFrame->SetFocus(true, true);
+ }
+ break;
+ }
+ case eBlur: {
+ nsIFormControlFrame* formControlFrame = GetFormControlFrame(true);
+ if (formControlFrame) {
+ formControlFrame->SetFocus(false, false);
+ }
+ break;
+ }
+ default:
+ break;
+ }
+ }
+ return nsGenericHTMLFormElement::PreHandleEvent(aVisitor);
+}
+
+HTMLFieldSetElement* nsGenericHTMLFormControlElement::GetFieldSet() {
+ return GetFieldSetInternal();
+}
+
+void nsGenericHTMLFormControlElement::SetForm(HTMLFormElement* aForm) {
+ MOZ_ASSERT(aForm, "Don't pass null here");
+ NS_ASSERTION(!mForm,
+ "We don't support switching from one non-null form to another.");
+
+ SetFormInternal(aForm, false);
+}
+
+void nsGenericHTMLFormControlElement::ClearForm(bool aRemoveFromForm,
+ bool aUnbindOrDelete) {
+ nsGenericHTMLFormElement::ClearForm(aRemoveFromForm, aUnbindOrDelete);
+}
+
+bool nsGenericHTMLFormControlElement::IsLabelable() const {
+ auto type = ControlType();
+ return (IsInputElement(type) && type != FormControlType::InputHidden) ||
+ IsButtonElement(type) || type == FormControlType::Output ||
+ type == FormControlType::Select || type == FormControlType::Textarea;
+}
+
+bool nsGenericHTMLFormControlElement::CanBeDisabled() const {
+ auto type = ControlType();
+ // It's easier to test the types that _cannot_ be disabled
+ return type != FormControlType::Object && type != FormControlType::Output;
+}
+
+bool nsGenericHTMLFormControlElement::DoesReadOnlyApply() const {
+ auto type = ControlType();
+ if (!IsInputElement(type) && type != FormControlType::Textarea) {
+ return false;
+ }
+
+ switch (type) {
+ case FormControlType::InputHidden:
+ case FormControlType::InputButton:
+ case FormControlType::InputImage:
+ case FormControlType::InputReset:
+ case FormControlType::InputSubmit:
+ case FormControlType::InputRadio:
+ case FormControlType::InputFile:
+ case FormControlType::InputCheckbox:
+ case FormControlType::InputRange:
+ case FormControlType::InputColor:
+ return false;
+#ifdef DEBUG
+ case FormControlType::Textarea:
+ case FormControlType::InputText:
+ case FormControlType::InputPassword:
+ case FormControlType::InputSearch:
+ case FormControlType::InputTel:
+ case FormControlType::InputEmail:
+ case FormControlType::InputUrl:
+ case FormControlType::InputNumber:
+ case FormControlType::InputDate:
+ case FormControlType::InputTime:
+ case FormControlType::InputMonth:
+ case FormControlType::InputWeek:
+ case FormControlType::InputDatetimeLocal:
+ return true;
+ default:
+ MOZ_ASSERT_UNREACHABLE("Unexpected input type in DoesReadOnlyApply()");
+ return true;
+#else // DEBUG
+ default:
+ return true;
+#endif // DEBUG
+ }
+}
+
+void nsGenericHTMLFormControlElement::SetFormInternal(HTMLFormElement* aForm,
+ bool aBindToTree) {
+ if (aForm) {
+ BeforeSetForm(aForm, aBindToTree);
+ }
+
+ // keep a *weak* ref to the form here
+ mForm = aForm;
+}
+
+HTMLFormElement* nsGenericHTMLFormControlElement::GetFormInternal() const {
+ return mForm;
+}
+
+HTMLFieldSetElement* nsGenericHTMLFormControlElement::GetFieldSetInternal()
+ const {
+ return mFieldSet;
+}
+
+void nsGenericHTMLFormControlElement::SetFieldSetInternal(
+ HTMLFieldSetElement* aFieldset) {
+ mFieldSet = aFieldset;
+}
+
+void nsGenericHTMLFormControlElement::UpdateRequiredState(bool aIsRequired,
+ bool aNotify) {
+#ifdef DEBUG
+ auto type = ControlType();
+#endif
+ MOZ_ASSERT(IsInputElement(type) || type == FormControlType::Select ||
+ type == FormControlType::Textarea,
+ "This should be called only on types that @required applies");
+
+#ifdef DEBUG
+ if (HTMLInputElement* input = HTMLInputElement::FromNode(this)) {
+ MOZ_ASSERT(
+ input->DoesRequiredApply(),
+ "This should be called only on input types that @required applies");
+ }
+#endif
+
+ ElementState requiredStates;
+ if (aIsRequired) {
+ requiredStates |= ElementState::REQUIRED;
+ } else {
+ requiredStates |= ElementState::OPTIONAL_;
+ }
+
+ ElementState oldRequiredStates = State() & ElementState::REQUIRED_STATES;
+ ElementState changedStates = requiredStates ^ oldRequiredStates;
+
+ if (!changedStates.IsEmpty()) {
+ ToggleStates(changedStates, aNotify);
+ }
+}
+
+bool nsGenericHTMLFormControlElement::IsAutocapitalizeInheriting() const {
+ auto type = ControlType();
+ return IsInputElement(type) || IsButtonElement(type) ||
+ type == FormControlType::Fieldset || type == FormControlType::Output ||
+ type == FormControlType::Select || type == FormControlType::Textarea;
+}
+
+nsresult nsGenericHTMLFormControlElement::SubmitDirnameDir(
+ FormData* aFormData) {
+ // Submit dirname=dir if element has non-empty dirname attribute
+ if (HasAttr(nsGkAtoms::dirname)) {
+ nsAutoString dirname;
+ GetAttr(nsGkAtoms::dirname, dirname);
+ if (!dirname.IsEmpty()) {
+ const Directionality dir = GetDirectionality();
+ MOZ_ASSERT(dir == Directionality::Ltr || dir == Directionality::Rtl,
+ "The directionality of an element is either ltr or rtl");
+ return aFormData->AddNameValuePair(
+ dirname, dir == Directionality::Ltr ? u"ltr"_ns : u"rtl"_ns);
+ }
+ }
+ return NS_OK;
+}
+
+//----------------------------------------------------------------------
+
+static const nsAttrValue::EnumTable kPopoverTargetActionTable[] = {
+ {"toggle", PopoverTargetAction::Toggle},
+ {"show", PopoverTargetAction::Show},
+ {"hide", PopoverTargetAction::Hide},
+ {nullptr, 0}};
+
+static const nsAttrValue::EnumTable* kPopoverTargetActionDefault =
+ &kPopoverTargetActionTable[0];
+
+nsGenericHTMLFormControlElementWithState::
+ nsGenericHTMLFormControlElementWithState(
+ already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo,
+ FromParser aFromParser, FormControlType aType)
+ : nsGenericHTMLFormControlElement(std::move(aNodeInfo), aType),
+ mControlNumber(!!(aFromParser & FROM_PARSER_NETWORK)
+ ? OwnerDoc()->GetNextControlNumber()
+ : -1) {
+ mStateKey.SetIsVoid(true);
+}
+
+bool nsGenericHTMLFormControlElementWithState::ParseAttribute(
+ int32_t aNamespaceID, nsAtom* aAttribute, const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal, nsAttrValue& aResult) {
+ if (aNamespaceID == kNameSpaceID_None) {
+ if (StaticPrefs::dom_element_popover_enabled()) {
+ if (aAttribute == nsGkAtoms::popovertargetaction) {
+ return aResult.ParseEnumValue(aValue, kPopoverTargetActionTable, false,
+ kPopoverTargetActionDefault);
+ }
+ if (aAttribute == nsGkAtoms::popovertarget) {
+ aResult.ParseAtom(aValue);
+ return true;
+ }
+ }
+
+ if (StaticPrefs::dom_element_invokers_enabled()) {
+ if (aAttribute == nsGkAtoms::invokeaction) {
+ aResult.ParseAtom(aValue);
+ return true;
+ }
+ if (aAttribute == nsGkAtoms::invoketarget) {
+ aResult.ParseAtom(aValue);
+ return true;
+ }
+ }
+ }
+
+ return nsGenericHTMLFormControlElement::ParseAttribute(
+ aNamespaceID, aAttribute, aValue, aMaybeScriptedPrincipal, aResult);
+}
+
+mozilla::dom::Element*
+nsGenericHTMLFormControlElementWithState::GetPopoverTargetElement() const {
+ return GetAttrAssociatedElement(nsGkAtoms::popovertarget);
+}
+
+void nsGenericHTMLFormControlElementWithState::SetPopoverTargetElement(
+ mozilla::dom::Element* aElement) {
+ ExplicitlySetAttrElement(nsGkAtoms::popovertarget, aElement);
+}
+
+void nsGenericHTMLFormControlElementWithState::HandlePopoverTargetAction() {
+ RefPtr<nsGenericHTMLElement> target = GetEffectivePopoverTargetElement();
+ if (!target) {
+ return;
+ }
+
+ auto action = PopoverTargetAction::Toggle;
+ if (const nsAttrValue* value =
+ GetParsedAttr(nsGkAtoms::popovertargetaction)) {
+ MOZ_ASSERT(value->Type() == nsAttrValue::eEnum);
+ action = static_cast<PopoverTargetAction>(value->GetEnumValue());
+ }
+
+ bool canHide = action == PopoverTargetAction::Hide ||
+ action == PopoverTargetAction::Toggle;
+ bool shouldHide = canHide && target->IsPopoverOpen();
+ bool canShow = action == PopoverTargetAction::Show ||
+ action == PopoverTargetAction::Toggle;
+ bool shouldShow = canShow && !target->IsPopoverOpen();
+
+ if (shouldHide) {
+ target->HidePopover(IgnoreErrors());
+ } else if (shouldShow) {
+ target->ShowPopoverInternal(this, IgnoreErrors());
+ }
+}
+
+void nsGenericHTMLFormControlElementWithState::GetInvokeAction(
+ nsAString& aValue) const {
+ GetInvokeAction()->ToString(aValue);
+}
+
+nsAtom* nsGenericHTMLFormControlElementWithState::GetInvokeAction() const {
+ const nsAttrValue* attr = GetParsedAttr(nsGkAtoms::invokeaction);
+ if (attr && attr->GetAtomValue() != nsGkAtoms::_empty) {
+ return attr->GetAtomValue();
+ }
+ return nsGkAtoms::_auto;
+}
+
+mozilla::dom::Element*
+nsGenericHTMLFormControlElementWithState::GetInvokeTargetElement() const {
+ if (StaticPrefs::dom_element_invokers_enabled()) {
+ return GetAttrAssociatedElement(nsGkAtoms::invoketarget);
+ }
+ return nullptr;
+}
+
+void nsGenericHTMLFormControlElementWithState::SetInvokeTargetElement(
+ mozilla::dom::Element* aElement) {
+ ExplicitlySetAttrElement(nsGkAtoms::invoketarget, aElement);
+}
+
+void nsGenericHTMLFormControlElementWithState::HandleInvokeTargetAction() {
+ // 1. Let invokee be node's invoke target element.
+ RefPtr<Element> invokee = GetInvokeTargetElement();
+
+ // 2. If invokee is null, then return.
+ if (!invokee) {
+ return;
+ }
+
+ // 3. Let action be node's invokeaction attribute
+ // 4. If action is null or empty, then let action be the string "auto".
+ RefPtr<nsAtom> aAction = GetInvokeAction();
+ MOZ_ASSERT(!aAction->IsEmpty(), "Action should not be empty");
+
+ // 5. Let notCancelled be the result of firing an event named invoke at
+ // invokee with its action set to action, its invoker set to node,
+ // and its cancelable attribute initialized to true.
+ InvokeEventInit init;
+ aAction->ToString(init.mAction);
+ init.mInvoker = this;
+ init.mCancelable = true;
+ init.mComposed = true;
+ RefPtr<Event> event = InvokeEvent::Constructor(this, u"invoke"_ns, init);
+ event->SetTrusted(true);
+ event->SetTarget(invokee);
+
+ EventDispatcher::DispatchDOMEvent(invokee, nullptr, event, nullptr, nullptr);
+
+ // 6. If notCancelled is true and invokee has an associated invocation action
+ // algorithm then run the invokee's invocation action algorithm given action.
+ if (event->DefaultPrevented()) {
+ return;
+ }
+
+ invokee->HandleInvokeInternal(aAction, IgnoreErrors());
+}
+
+void nsGenericHTMLFormControlElementWithState::GenerateStateKey() {
+ // Keep the key if already computed
+ if (!mStateKey.IsVoid()) {
+ return;
+ }
+
+ Document* doc = GetUncomposedDoc();
+ if (!doc) {
+ mStateKey.Truncate();
+ return;
+ }
+
+ // Generate the state key
+ nsContentUtils::GenerateStateKey(this, doc, mStateKey);
+
+ // If the state key is blank, this is anonymous content or for whatever
+ // reason we are not supposed to save/restore state: keep it as such.
+ if (!mStateKey.IsEmpty()) {
+ // Add something unique to content so layout doesn't muck us up.
+ mStateKey += "-C";
+ }
+}
+
+PresState* nsGenericHTMLFormControlElementWithState::GetPrimaryPresState() {
+ if (mStateKey.IsEmpty()) {
+ return nullptr;
+ }
+
+ nsCOMPtr<nsILayoutHistoryState> history = GetLayoutHistory(false);
+
+ if (!history) {
+ return nullptr;
+ }
+
+ // Get the pres state for this key, if it doesn't exist, create one.
+ PresState* result = history->GetState(mStateKey);
+ if (!result) {
+ UniquePtr<PresState> newState = NewPresState();
+ result = newState.get();
+ history->AddState(mStateKey, std::move(newState));
+ }
+
+ return result;
+}
+
+already_AddRefed<nsILayoutHistoryState>
+nsGenericHTMLFormElement::GetLayoutHistory(bool aRead) {
+ nsCOMPtr<Document> doc = GetUncomposedDoc();
+ if (!doc) {
+ return nullptr;
+ }
+
+ //
+ // Get the history
+ //
+ nsCOMPtr<nsILayoutHistoryState> history = doc->GetLayoutHistoryState();
+ if (!history) {
+ return nullptr;
+ }
+
+ if (aRead && !history->HasStates()) {
+ return nullptr;
+ }
+
+ return history.forget();
+}
+
+bool nsGenericHTMLFormControlElementWithState::RestoreFormControlState() {
+ MOZ_ASSERT(!mStateKey.IsVoid(),
+ "GenerateStateKey must already have been called");
+
+ if (mStateKey.IsEmpty()) {
+ return false;
+ }
+
+ nsCOMPtr<nsILayoutHistoryState> history = GetLayoutHistory(true);
+ if (!history) {
+ return false;
+ }
+
+ // Get the pres state for this key
+ PresState* state = history->GetState(mStateKey);
+ if (state) {
+ bool result = RestoreState(state);
+ history->RemoveState(mStateKey);
+ return result;
+ }
+
+ return false;
+}
+
+void nsGenericHTMLFormControlElementWithState::NodeInfoChanged(
+ Document* aOldDoc) {
+ nsGenericHTMLFormControlElement::NodeInfoChanged(aOldDoc);
+
+ // We need to regenerate the state key now we're in a new document. Clearing
+ // mControlNumber means we stop considering this control to be parser
+ // inserted, and we'll generate a state key based on its position in the
+ // document rather than the order it was inserted into the document.
+ mControlNumber = -1;
+ mStateKey.SetIsVoid(true);
+}
+
+void nsGenericHTMLFormControlElementWithState::GetFormAction(nsString& aValue) {
+ auto type = ControlType();
+ if (!IsInputElement(type) && !IsButtonElement(type)) {
+ return;
+ }
+
+ if (!GetAttr(nsGkAtoms::formaction, aValue) || aValue.IsEmpty()) {
+ Document* document = OwnerDoc();
+ nsIURI* docURI = document->GetDocumentURI();
+ if (docURI) {
+ nsAutoCString spec;
+ nsresult rv = docURI->GetSpec(spec);
+ if (NS_FAILED(rv)) {
+ return;
+ }
+
+ CopyUTF8toUTF16(spec, aValue);
+ }
+ } else {
+ GetURIAttr(nsGkAtoms::formaction, nullptr, aValue);
+ }
+}
+
+bool nsGenericHTMLElement::IsEventAttributeNameInternal(nsAtom* aName) {
+ return nsContentUtils::IsEventAttributeName(aName, EventNameType_HTML);
+}
+
+/**
+ * Construct a URI from a string, as an element.src attribute
+ * would be set to. Helper for the media elements.
+ */
+nsresult nsGenericHTMLElement::NewURIFromString(const nsAString& aURISpec,
+ nsIURI** aURI) {
+ NS_ENSURE_ARG_POINTER(aURI);
+
+ *aURI = nullptr;
+
+ nsCOMPtr<Document> doc = OwnerDoc();
+
+ nsresult rv = nsContentUtils::NewURIWithDocumentCharset(aURI, aURISpec, doc,
+ GetBaseURI());
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ bool equal;
+ if (aURISpec.IsEmpty() && doc->GetDocumentURI() &&
+ NS_SUCCEEDED(doc->GetDocumentURI()->Equals(*aURI, &equal)) && equal) {
+ // Assume an element can't point to a fragment of its embedding
+ // document. Fail here instead of returning the recursive URI
+ // and waiting for the subsequent load to fail.
+ NS_RELEASE(*aURI);
+ return NS_ERROR_DOM_INVALID_STATE_ERR;
+ }
+
+ return NS_OK;
+}
+
+void nsGenericHTMLElement::GetInnerText(mozilla::dom::DOMString& aValue,
+ mozilla::ErrorResult& aError) {
+ // innerText depends on layout. For example, white space processing is
+ // something that happens during reflow and which must be reflected by
+ // innerText. So for:
+ //
+ // <div style="white-space:normal"> A B C </div>
+ //
+ // innerText should give "A B C".
+ //
+ // The approach taken here to avoid the expense of reflow is to flush style
+ // and then see whether it's necessary to flush layout afterwards. Flushing
+ // layout can be skipped if we can detect that the element or its descendants
+ // are not dirty.
+
+ // Obtain the composed doc to handle elements in Shadow DOM.
+ Document* doc = GetComposedDoc();
+ if (doc) {
+ doc->FlushPendingNotifications(FlushType::Style);
+ }
+
+ // Elements with `display: content` will not have a frame. To handle Shadow
+ // DOM, walk the flattened tree looking for parent frame.
+ nsIFrame* frame = GetPrimaryFrame();
+ if (IsDisplayContents()) {
+ for (Element* parent = GetFlattenedTreeParentElement(); parent;
+ parent = parent->GetFlattenedTreeParentElement()) {
+ frame = parent->GetPrimaryFrame();
+ if (frame) {
+ break;
+ }
+ }
+ }
+
+ // Check for dirty reflow roots in the subtree from targetFrame; this requires
+ // a reflow flush.
+ bool dirty = frame && frame->PresShell()->FrameIsAncestorOfDirtyRoot(frame);
+
+ // The way we do that is by checking whether the element has either of the two
+ // dirty bits (NS_FRAME_IS_DIRTY or NS_FRAME_HAS_DIRTY_DESCENDANTS) or if any
+ // ancestor has NS_FRAME_IS_DIRTY. We need to check for NS_FRAME_IS_DIRTY on
+ // ancestors since that is something that implies NS_FRAME_IS_DIRTY on all
+ // descendants.
+ dirty |= frame && frame->HasAnyStateBits(NS_FRAME_HAS_DIRTY_CHILDREN);
+ while (!dirty && frame) {
+ dirty |= frame->HasAnyStateBits(NS_FRAME_IS_DIRTY);
+ frame = frame->GetInFlowParent();
+ }
+
+ // Flush layout if we determined a reflow is required.
+ if (dirty && doc) {
+ doc->FlushPendingNotifications(FlushType::Layout);
+ }
+
+ if (!IsRendered()) {
+ GetTextContentInternal(aValue, aError);
+ } else {
+ nsRange::GetInnerTextNoFlush(aValue, aError, this);
+ }
+}
+
+static already_AddRefed<nsINode> TextToNode(const nsAString& aString,
+ nsNodeInfoManager* aNim) {
+ nsString str;
+ const char16_t* s = aString.BeginReading();
+ const char16_t* end = aString.EndReading();
+ RefPtr<DocumentFragment> fragment;
+ while (true) {
+ if (s != end && *s == '\r' && s + 1 != end && s[1] == '\n') {
+ // a \r\n pair should only generate one <br>, so just skip the \r
+ ++s;
+ }
+ if (s == end || *s == '\r' || *s == '\n') {
+ if (!str.IsEmpty()) {
+ RefPtr<nsTextNode> textContent = new (aNim) nsTextNode(aNim);
+ textContent->SetText(str, true);
+ if (!fragment) {
+ if (s == end) {
+ return textContent.forget();
+ }
+ fragment = new (aNim) DocumentFragment(aNim);
+ }
+ fragment->AppendChildTo(textContent, true, IgnoreErrors());
+ }
+ if (s == end) {
+ break;
+ }
+ str.Truncate();
+ RefPtr<NodeInfo> ni = aNim->GetNodeInfo(
+ nsGkAtoms::br, nullptr, kNameSpaceID_XHTML, nsINode::ELEMENT_NODE);
+ auto* nim = ni->NodeInfoManager();
+ RefPtr<HTMLBRElement> br = new (nim) HTMLBRElement(ni.forget());
+ if (!fragment) {
+ if (s + 1 == end) {
+ return br.forget();
+ }
+ fragment = new (aNim) DocumentFragment(aNim);
+ }
+ fragment->AppendChildTo(br, true, IgnoreErrors());
+ } else {
+ str.Append(*s);
+ }
+ ++s;
+ }
+ return fragment.forget();
+}
+
+void nsGenericHTMLElement::SetInnerText(const nsAString& aValue) {
+ RefPtr<nsINode> node = TextToNode(aValue, NodeInfo()->NodeInfoManager());
+ ReplaceChildren(node, IgnoreErrors());
+}
+
+// https://html.spec.whatwg.org/#merge-with-the-next-text-node
+static void MergeWithNextTextNode(Text& aText, ErrorResult& aRv) {
+ RefPtr<Text> nextSibling = Text::FromNodeOrNull(aText.GetNextSibling());
+ if (!nextSibling) {
+ return;
+ }
+ nsAutoString data;
+ nextSibling->GetData(data);
+ aText.AppendData(data, aRv);
+ nextSibling->Remove();
+}
+
+// https://html.spec.whatwg.org/#dom-outertext
+void nsGenericHTMLElement::SetOuterText(const nsAString& aValue,
+ ErrorResult& aRv) {
+ nsCOMPtr<nsINode> parent = GetParentNode();
+ if (!parent) {
+ return aRv.ThrowNoModificationAllowedError("Element has no parent");
+ }
+
+ RefPtr<nsINode> next = GetNextSibling();
+ RefPtr<nsINode> previous = GetPreviousSibling();
+
+ // Batch possible DOMSubtreeModified events.
+ mozAutoSubtreeModified subtree(OwnerDoc(), nullptr);
+
+ nsNodeInfoManager* nim = NodeInfo()->NodeInfoManager();
+ RefPtr<nsINode> node = TextToNode(aValue, nim);
+ if (!node) {
+ // This doesn't match the spec, see
+ // https://github.com/whatwg/html/issues/7508
+ node = new (nim) nsTextNode(nim);
+ }
+ parent->ReplaceChild(*node, *this, aRv);
+ if (aRv.Failed()) {
+ return;
+ }
+
+ if (next) {
+ if (RefPtr<Text> text = Text::FromNodeOrNull(next->GetPreviousSibling())) {
+ MergeWithNextTextNode(*text, aRv);
+ if (aRv.Failed()) {
+ return;
+ }
+ }
+ }
+ if (auto* text = Text::FromNodeOrNull(previous)) {
+ MergeWithNextTextNode(*text, aRv);
+ }
+}
+
+// This should be true when `:open` should match.
+bool nsGenericHTMLElement::PopoverOpen() const {
+ if (PopoverData* popoverData = GetPopoverData()) {
+ return popoverData->GetPopoverVisibilityState() ==
+ PopoverVisibilityState::Showing;
+ }
+ return false;
+}
+
+// https://html.spec.whatwg.org/#check-popover-validity
+bool nsGenericHTMLElement::CheckPopoverValidity(
+ PopoverVisibilityState aExpectedState, Document* aExpectedDocument,
+ ErrorResult& aRv) {
+ if (GetPopoverAttributeState() == PopoverAttributeState::None) {
+ aRv.ThrowNotSupportedError("Element is in the no popover state");
+ return false;
+ }
+
+ if (GetPopoverData()->GetPopoverVisibilityState() != aExpectedState) {
+ return false;
+ }
+
+ if (!IsInComposedDoc()) {
+ aRv.ThrowInvalidStateError("Element is not connected");
+ return false;
+ }
+
+ if (aExpectedDocument && aExpectedDocument != OwnerDoc()) {
+ aRv.ThrowInvalidStateError("Element is moved to other document");
+ return false;
+ }
+
+ if (auto* dialog = HTMLDialogElement::FromNode(this)) {
+ if (dialog->IsInTopLayer()) {
+ aRv.ThrowInvalidStateError("Element is a modal <dialog> element");
+ return false;
+ }
+ }
+
+ if (State().HasState(ElementState::FULLSCREEN)) {
+ aRv.ThrowInvalidStateError("Element is fullscreen");
+ return false;
+ }
+
+ return true;
+}
+
+PopoverAttributeState nsGenericHTMLElement::GetPopoverAttributeState() const {
+ return GetPopoverData() ? GetPopoverData()->GetPopoverAttributeState()
+ : PopoverAttributeState::None;
+}
+
+void nsGenericHTMLElement::PopoverPseudoStateUpdate(bool aOpen, bool aNotify) {
+ SetStates(ElementState::POPOVER_OPEN, aOpen, aNotify);
+}
+
+already_AddRefed<ToggleEvent> nsGenericHTMLElement::CreateToggleEvent(
+ const nsAString& aEventType, const nsAString& aOldState,
+ const nsAString& aNewState, Cancelable aCancelable) {
+ ToggleEventInit init;
+ init.mBubbles = false;
+ init.mOldState = aOldState;
+ init.mNewState = aNewState;
+ init.mCancelable = aCancelable == Cancelable::eYes;
+ RefPtr<ToggleEvent> event = ToggleEvent::Constructor(this, aEventType, init);
+ event->SetTrusted(true);
+ event->SetTarget(this);
+ return event.forget();
+}
+
+bool nsGenericHTMLElement::FireToggleEvent(PopoverVisibilityState aOldState,
+ PopoverVisibilityState aNewState,
+ const nsAString& aType) {
+ auto stringForState = [](PopoverVisibilityState state) {
+ return state == PopoverVisibilityState::Hidden ? u"closed"_ns : u"open"_ns;
+ };
+ const auto cancelable = aType == u"beforetoggle"_ns &&
+ aNewState == PopoverVisibilityState::Showing
+ ? Cancelable::eYes
+ : Cancelable::eNo;
+ RefPtr event = CreateToggleEvent(aType, stringForState(aOldState),
+ stringForState(aNewState), cancelable);
+ EventDispatcher::DispatchDOMEvent(this, nullptr, event, nullptr, nullptr);
+ return event->DefaultPrevented();
+}
+
+// https://html.spec.whatwg.org/#queue-a-popover-toggle-event-task
+void nsGenericHTMLElement::QueuePopoverEventTask(
+ PopoverVisibilityState aOldState) {
+ auto* data = GetPopoverData();
+ MOZ_ASSERT(data, "Should have popover data");
+
+ if (auto* queuedToggleEventTask = data->GetToggleEventTask()) {
+ aOldState = queuedToggleEventTask->GetOldState();
+ }
+
+ auto task =
+ MakeRefPtr<PopoverToggleEventTask>(do_GetWeakReference(this), aOldState);
+ data->SetToggleEventTask(task);
+ OwnerDoc()->Dispatch(task.forget());
+}
+
+void nsGenericHTMLElement::RunPopoverToggleEventTask(
+ PopoverToggleEventTask* aTask, PopoverVisibilityState aOldState) {
+ auto* data = GetPopoverData();
+ if (!data) {
+ return;
+ }
+
+ auto* popoverToggleEventTask = data->GetToggleEventTask();
+ if (!popoverToggleEventTask || aTask != popoverToggleEventTask) {
+ return;
+ }
+ data->ClearToggleEventTask();
+ // Intentionally ignore the return value here as only on open event the
+ // cancelable attribute is initialized to true for beforetoggle event.
+ FireToggleEvent(aOldState, data->GetPopoverVisibilityState(), u"toggle"_ns);
+}
+
+// https://html.spec.whatwg.org/#dom-showpopover
+void nsGenericHTMLElement::ShowPopover(ErrorResult& aRv) {
+ return ShowPopoverInternal(nullptr, aRv);
+}
+void nsGenericHTMLElement::ShowPopoverInternal(Element* aInvoker,
+ ErrorResult& aRv) {
+ if (!CheckPopoverValidity(PopoverVisibilityState::Hidden, nullptr, aRv)) {
+ return;
+ }
+ RefPtr<Document> document = OwnerDoc();
+
+ MOZ_ASSERT(!GetPopoverData() || !GetPopoverData()->GetInvoker());
+ MOZ_ASSERT(!OwnerDoc()->TopLayerContains(*this));
+
+ bool wasShowingOrHiding = GetPopoverData()->IsShowingOrHiding();
+ GetPopoverData()->SetIsShowingOrHiding(true);
+ auto cleanupShowingFlag = MakeScopeExit([&]() {
+ if (auto* popoverData = GetPopoverData()) {
+ popoverData->SetIsShowingOrHiding(wasShowingOrHiding);
+ }
+ });
+
+ // Fire beforetoggle event and re-check popover validity.
+ if (FireToggleEvent(PopoverVisibilityState::Hidden,
+ PopoverVisibilityState::Showing, u"beforetoggle"_ns)) {
+ return;
+ }
+ if (!CheckPopoverValidity(PopoverVisibilityState::Hidden, document, aRv)) {
+ return;
+ }
+
+ bool shouldRestoreFocus = false;
+ nsWeakPtr originallyFocusedElement;
+ if (IsAutoPopover()) {
+ auto originalState = GetPopoverAttributeState();
+ RefPtr<nsINode> ancestor = GetTopmostPopoverAncestor(aInvoker, true);
+ if (!ancestor) {
+ ancestor = document;
+ }
+ document->HideAllPopoversUntil(*ancestor, false,
+ /* aFireEvents = */ !wasShowingOrHiding);
+ if (GetPopoverAttributeState() != originalState) {
+ aRv.ThrowInvalidStateError(
+ "The value of the popover attribute was changed while hiding the "
+ "popover.");
+ return;
+ }
+
+ // TODO: Handle if document changes, see
+ // https://github.com/whatwg/html/issues/9177
+ if (!IsAutoPopover() ||
+ !CheckPopoverValidity(PopoverVisibilityState::Hidden, document, aRv)) {
+ return;
+ }
+
+ shouldRestoreFocus = !document->GetTopmostAutoPopover();
+ // Let originallyFocusedElement be document's focused area of the document's
+ // DOM anchor.
+ if (nsIContent* unretargetedFocus =
+ document->GetUnretargetedFocusedContent()) {
+ originallyFocusedElement =
+ do_GetWeakReference(unretargetedFocus->AsElement());
+ }
+ }
+
+ document->AddPopoverToTopLayer(*this);
+
+ PopoverPseudoStateUpdate(true, true);
+
+ {
+ auto* popoverData = GetPopoverData();
+ popoverData->SetPopoverVisibilityState(PopoverVisibilityState::Showing);
+ popoverData->SetInvoker(aInvoker);
+ }
+
+ // Run the popover focusing steps given element.
+ FocusPopover();
+ if (shouldRestoreFocus &&
+ GetPopoverAttributeState() != PopoverAttributeState::None) {
+ GetPopoverData()->SetPreviouslyFocusedElement(originallyFocusedElement);
+ }
+
+ // Queue popover toggle event task.
+ QueuePopoverEventTask(PopoverVisibilityState::Hidden);
+}
+
+void nsGenericHTMLElement::HidePopoverWithoutRunningScript() {
+ HidePopoverInternal(/* aFocusPreviousElement = */ false,
+ /* aFireEvents = */ false, IgnoreErrors());
+}
+
+// https://html.spec.whatwg.org/#dom-hidepopover
+void nsGenericHTMLElement::HidePopover(ErrorResult& aRv) {
+ HidePopoverInternal(/* aFocusPreviousElement = */ true,
+ /* aFireEvents = */ true, aRv);
+}
+
+void nsGenericHTMLElement::HidePopoverInternal(bool aFocusPreviousElement,
+ bool aFireEvents,
+ ErrorResult& aRv) {
+ OwnerDoc()->HidePopover(*this, aFocusPreviousElement, aFireEvents, aRv);
+}
+
+void nsGenericHTMLElement::ForgetPreviouslyFocusedElementAfterHidingPopover() {
+ auto* data = GetPopoverData();
+ MOZ_ASSERT(data, "Should have popover data");
+ data->SetPreviouslyFocusedElement(nullptr);
+}
+
+void nsGenericHTMLElement::FocusPreviousElementAfterHidingPopover() {
+ auto* data = GetPopoverData();
+ MOZ_ASSERT(data, "Should have popover data");
+
+ RefPtr<Element> control =
+ do_QueryReferent(data->GetPreviouslyFocusedElement().get());
+ data->SetPreviouslyFocusedElement(nullptr);
+
+ if (!control) {
+ return;
+ }
+
+ // Step 14.2 at
+ // https://html.spec.whatwg.org/multipage/popover.html#hide-popover-algorithm
+ // If focusPreviousElement is true and document's focused area of the
+ // document's DOM anchor is a shadow-including inclusive descendant of
+ // element, then run the focusing steps for previouslyFocusedElement;
+ nsIContent* currentFocus = OwnerDoc()->GetUnretargetedFocusedContent();
+ if (currentFocus &&
+ currentFocus->IsShadowIncludingInclusiveDescendantOf(this)) {
+ FocusOptions options;
+ options.mPreventScroll = true;
+ control->Focus(options, CallerType::NonSystem, IgnoreErrors());
+ }
+}
+
+// https://html.spec.whatwg.org/multipage/popover.html#dom-togglepopover
+bool nsGenericHTMLElement::TogglePopover(const Optional<bool>& aForce,
+ ErrorResult& aRv) {
+ if (PopoverOpen() && (!aForce.WasPassed() || !aForce.Value())) {
+ HidePopover(aRv);
+ } else if (!aForce.WasPassed() || aForce.Value()) {
+ ShowPopover(aRv);
+ } else {
+ CheckPopoverValidity(GetPopoverData()
+ ? GetPopoverData()->GetPopoverVisibilityState()
+ : PopoverVisibilityState::Showing,
+ nullptr, aRv);
+ }
+
+ return PopoverOpen();
+}
+
+// https://html.spec.whatwg.org/multipage/popover.html#popover-focusing-steps
+void nsGenericHTMLElement::FocusPopover() {
+ if (auto* dialog = HTMLDialogElement::FromNode(this)) {
+ return MOZ_KnownLive(dialog)->FocusDialog();
+ }
+
+ if (RefPtr<Document> doc = GetComposedDoc()) {
+ doc->FlushPendingNotifications(FlushType::Frames);
+ }
+
+ RefPtr<Element> control = GetBoolAttr(nsGkAtoms::autofocus)
+ ? this
+ : GetAutofocusDelegate(false /* aWithMouse */);
+
+ if (!control) {
+ return;
+ }
+ FocusCandidate(control, false /* aClearUpFocus */);
+}
+
+void nsGenericHTMLElement::FocusCandidate(Element* aControl,
+ bool aClearUpFocus) {
+ // 1) Run the focusing steps given control.
+ IgnoredErrorResult rv;
+ if (RefPtr<Element> elementToFocus = nsFocusManager::GetTheFocusableArea(
+ aControl, nsFocusManager::ProgrammaticFocusFlags(FocusOptions()))) {
+ elementToFocus->Focus(FocusOptions(), CallerType::NonSystem, rv);
+ if (rv.Failed()) {
+ return;
+ }
+ } else if (aClearUpFocus) {
+ if (RefPtr<nsFocusManager> fm = nsFocusManager::GetFocusManager()) {
+ // Clear the focus which ends up making the body gets focused
+ nsCOMPtr<nsPIDOMWindowOuter> outerWindow = OwnerDoc()->GetWindow();
+ fm->ClearFocus(outerWindow);
+ }
+ }
+
+ // 2) Let topDocument be the active document of control's node document's
+ // browsing context's top-level browsing context.
+ // 3) If control's node document's origin is not the same as the origin of
+ // topDocument, then return.
+ BrowsingContext* bc = aControl->OwnerDoc()->GetBrowsingContext();
+ if (bc && bc->IsInProcess() && bc->SameOriginWithTop()) {
+ if (nsCOMPtr<nsIDocShell> docShell = bc->Top()->GetDocShell()) {
+ if (Document* topDocument = docShell->GetExtantDocument()) {
+ // 4) Empty topDocument's autofocus candidates.
+ // 5) Set topDocument's autofocus processed flag to true.
+ topDocument->SetAutoFocusFired();
+ }
+ }
+ }
+}
+
+already_AddRefed<ElementInternals> nsGenericHTMLElement::AttachInternals(
+ ErrorResult& aRv) {
+ // ElementInternals is only available on autonomous custom element, so throws
+ // an error by default. The spec steps are implemented in HTMLElement because
+ // ElementInternals needs to hold a pointer to HTMLElement in order to forward
+ // form operation to it.
+ aRv.ThrowNotSupportedError(nsPrintfCString(
+ "Cannot attach ElementInternals to a customized built-in or non-custom "
+ "element "
+ "'%s'",
+ NS_ConvertUTF16toUTF8(NodeInfo()->NameAtom()->GetUTF16String()).get()));
+ return nullptr;
+}
+
+ElementInternals* nsGenericHTMLElement::GetInternals() const {
+ if (CustomElementData* data = GetCustomElementData()) {
+ return data->GetElementInternals();
+ }
+ return nullptr;
+}
+
+bool nsGenericHTMLElement::IsFormAssociatedCustomElements() const {
+ if (CustomElementData* data = GetCustomElementData()) {
+ return data->IsFormAssociated();
+ }
+ return false;
+}
+
+void nsGenericHTMLElement::GetAutocapitalize(nsAString& aValue) const {
+ GetEnumAttr(nsGkAtoms::autocapitalize, nullptr, kDefaultAutocapitalize->tag,
+ aValue);
+}
+
+bool nsGenericHTMLElement::Translate() const {
+ if (const nsAttrValue* attr = mAttrs.GetAttr(nsGkAtoms::translate)) {
+ if (attr->IsEmptyString() || attr->Equals(nsGkAtoms::yes, eIgnoreCase)) {
+ return true;
+ }
+ if (attr->Equals(nsGkAtoms::no, eIgnoreCase)) {
+ return false;
+ }
+ }
+ return nsGenericHTMLElementBase::Translate();
+}
+
+void nsGenericHTMLElement::GetPopover(nsString& aPopover) const {
+ GetHTMLEnumAttr(nsGkAtoms::popover, aPopover);
+ if (aPopover.IsEmpty() && !DOMStringIsNull(aPopover)) {
+ aPopover.Assign(NS_ConvertUTF8toUTF16(kPopoverAttributeValueAuto));
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-13 13:26:36 +0000