, because // after "removing" the custom elements data, this is again a known // built-in and thus defined element. SetDefined(!nsContentUtils::IsCustomElementName(NodeInfo()->NameAtom(), NodeInfo()->NamespaceID())); nsExtendedDOMSlots* slots = ExtendedDOMSlots(); slots->mCustomElementData = nullptr; } nsTArray>& Element::EnsureCustomStates() { MOZ_ASSERT(IsHTMLElement()); nsExtendedDOMSlots* slots = ExtendedDOMSlots(); return slots->mCustomStates; } CustomElementDefinition* Element::GetCustomElementDefinition() const { CustomElementData* data = GetCustomElementData(); if (!data) { return nullptr; } return data->GetCustomElementDefinition(); } void Element::SetCustomElementDefinition(CustomElementDefinition* aDefinition) { CustomElementData* data = GetCustomElementData(); MOZ_ASSERT(data); data->SetCustomElementDefinition(aDefinition); } already_AddRefed Element::AsXULButton() { nsCOMPtr value; GetCustomInterface(getter_AddRefs(value)); return value.forget(); } already_AddRefed Element::AsXULContainer() { nsCOMPtr value; GetCustomInterface(getter_AddRefs(value)); return value.forget(); } already_AddRefed Element::AsXULContainerItem() { nsCOMPtr value; GetCustomInterface(getter_AddRefs(value)); return value.forget(); } already_AddRefed Element::AsXULControl() { nsCOMPtr value; GetCustomInterface(getter_AddRefs(value)); return value.forget(); } already_AddRefed Element::AsXULMenuList() { nsCOMPtr value; GetCustomInterface(getter_AddRefs(value)); return value.forget(); } already_AddRefed Element::AsXULMultiSelectControl() { nsCOMPtr value; GetCustomInterface(getter_AddRefs(value)); return value.forget(); } already_AddRefed Element::AsXULRadioGroup() { nsCOMPtr value; GetCustomInterface(getter_AddRefs(value)); return value.forget(); } already_AddRefed Element::AsXULRelated() { nsCOMPtr value; GetCustomInterface(getter_AddRefs(value)); return value.forget(); } already_AddRefed Element::AsXULSelectControl() { nsCOMPtr value; GetCustomInterface(getter_AddRefs(value)); return value.forget(); } already_AddRefed Element::AsXULSelectControlItem() { nsCOMPtr value; GetCustomInterface(getter_AddRefs(value)); return value.forget(); } already_AddRefed Element::AsBrowser() { nsCOMPtr value; GetCustomInterface(getter_AddRefs(value)); return value.forget(); } already_AddRefed Element::AsAutoCompletePopup() { nsCOMPtr value; GetCustomInterface(getter_AddRefs(value)); return value.forget(); } nsPresContext* Element::GetPresContext(PresContextFor aFor) const { // Get the document Document* doc = (aFor == eForComposedDoc) ? GetComposedDoc() : GetUncomposedDoc(); if (doc) { return doc->GetPresContext(); } return nullptr; } MOZ_DEFINE_MALLOC_SIZE_OF(ServoElementMallocSizeOf) MOZ_DEFINE_MALLOC_ENCLOSING_SIZE_OF(ServoElementMallocEnclosingSizeOf) void Element::AddSizeOfExcludingThis(nsWindowSizes& aSizes, size_t* aNodeSize) const { FragmentOrElement::AddSizeOfExcludingThis(aSizes, aNodeSize); *aNodeSize += mAttrs.SizeOfExcludingThis(aSizes.mState.mMallocSizeOf); if (HasServoData()) { // Measure the ElementData object itself. aSizes.mLayoutElementDataObjects += aSizes.mState.mMallocSizeOf(mServoData.Get()); // Measure mServoData, excluding the ComputedValues. This measurement // counts towards the element's size. We use ServoElementMallocSizeOf and // ServoElementMallocEnclosingSizeOf rather than |aState.mMallocSizeOf| to // better distinguish in DMD's output the memory measured within Servo // code. *aNodeSize += Servo_Element_SizeOfExcludingThisAndCVs( ServoElementMallocSizeOf, ServoElementMallocEnclosingSizeOf, &aSizes.mState.mSeenPtrs, this); // Now measure just the ComputedValues (and style structs) under // mServoData. This counts towards the relevant fields in |aSizes|. if (auto* style = Servo_Element_GetMaybeOutOfDateStyle(this)) { if (!aSizes.mState.HaveSeenPtr(style)) { style->AddSizeOfIncludingThis(aSizes, &aSizes.mLayoutComputedValuesDom); } for (size_t i = 0; i < PseudoStyle::kEagerPseudoCount; i++) { if (auto* style = Servo_Element_GetMaybeOutOfDatePseudoStyle(this, i)) { if (!aSizes.mState.HaveSeenPtr(style)) { style->AddSizeOfIncludingThis(aSizes, &aSizes.mLayoutComputedValuesDom); } } } } } } #ifdef DEBUG static bool BitsArePropagated(const Element* aElement, uint32_t aBits, nsINode* aRestyleRoot) { const Element* curr = aElement; while (curr) { if (curr == aRestyleRoot) { return true; } if (!curr->HasAllFlags(aBits)) { return false; } nsINode* parentNode = curr->GetParentNode(); curr = curr->GetFlattenedTreeParentElementForStyle(); MOZ_ASSERT_IF(!curr, parentNode == aElement->OwnerDoc() || parentNode == parentNode->OwnerDoc()->GetRootElement()); } return true; } #endif static inline void AssertNoBitsPropagatedFrom(nsINode* aRoot) { #ifdef DEBUG if (!aRoot || !aRoot->IsElement()) { return; } auto* element = aRoot->GetFlattenedTreeParentElementForStyle(); while (element) { MOZ_ASSERT(!element->HasAnyOfFlags(Element::kAllServoDescendantBits)); element = element->GetFlattenedTreeParentElementForStyle(); } #endif } // Sets `aBits` on `aElement` and all of its flattened-tree ancestors up to and // including aStopAt or the root element (whichever is encountered first), and // as long as `aBitsToStopAt` isn't found anywhere in the chain. static inline Element* PropagateBits(Element* aElement, uint32_t aBits, nsINode* aStopAt, uint32_t aBitsToStopAt) { Element* curr = aElement; while (curr && !curr->HasAllFlags(aBitsToStopAt)) { curr->SetFlags(aBits); if (curr == aStopAt) { break; } curr = curr->GetFlattenedTreeParentElementForStyle(); } if (aBitsToStopAt != aBits && curr) { curr->SetFlags(aBits); } return curr; } // Notes that a given element is "dirty" with respect to the given descendants // bit (which may be one of dirty descendants, dirty animation descendants, or // need frame construction for descendants). // // This function operates on the dirty element itself, despite the fact that the // bits are generally used to describe descendants. This allows restyle roots // to be scoped as tightly as possible. On the first call to NoteDirtyElement // since the last restyle, we don't set any descendant bits at all, and just set // the element as the restyle root. // // Because the style traversal handles multiple tasks (styling, // animation-ticking, and lazy frame construction), there are potentially three // separate kinds of dirtiness to track. Rather than maintaining three separate // restyle roots, we use a single root, and always bubble it up to be the // nearest common ancestor of all the dirty content in the tree. This means that // we need to track the types of dirtiness that the restyle root corresponds to, // so SetServoRestyleRoot accepts a bitfield along with an element. // // The overall algorithm is as follows: // * When the first dirty element is noted, we just set as the restyle root. // * When additional dirty elements are noted, we propagate the given bit up // the tree, until we either reach the restyle root or the document root. // * If we reach the document root, we then propagate the bits associated with // the restyle root up the tree until we cross the path of the new root. Once // we find this common ancestor, we record it as the restyle root, and then // clear the bits between the new restyle root and the document root. // * If we have dirty content beneath multiple "document style traversal roots" // (which are the main DOM + each piece of document-level native-anoymous // content), we set the restyle root to the nsINode of the document itself. // This is the bail-out case where we traverse everything. // // Note that, since we track a root, we try to optimize the case where an // element under the current root is dirtied, that's why we don't trivially use // `nsContentUtils::GetCommonFlattenedTreeAncestorForStyle`. static void NoteDirtyElement(Element* aElement, uint32_t aBits) { MOZ_ASSERT(aElement->IsInComposedDoc()); // Check the existing root early on, since it may allow us to short-circuit // before examining the parent chain. Document* doc = aElement->GetComposedDoc(); nsINode* existingRoot = doc->GetServoRestyleRoot(); if (existingRoot == aElement) { doc->SetServoRestyleRootDirtyBits(doc->GetServoRestyleRootDirtyBits() | aBits); return; } nsINode* parent = aElement->GetFlattenedTreeParentNodeForStyle(); if (!parent) { // The element is not in the flattened tree, bail. return; } if (MOZ_LIKELY(parent->IsElement())) { // If our parent is unstyled, we can inductively assume that it will be // traversed when the time is right, and that the traversal will reach us // when it happens. Nothing left to do. if (!parent->AsElement()->HasServoData()) { return; } // Similarly, if our parent already has the bit we're propagating, we can // assume everything is already set up. if (parent->HasAllFlags(aBits)) { return; } // If the parent is styled but is display:none, we're done. // // We can't check for a frame here, since elements inside // still need to generate a frame, even if they're display: none. :( // // The servo traversal doesn't keep style data under display: none subtrees, // so in order for it to not need to cleanup each time anything happens in a // display: none subtree, we keep it clean. // // Also, we can't be much more smarter about using the parent's frame in // order to avoid work here, because since the style system keeps style data // in, e.g., subtrees under a leaf frame, missing restyles and such in there // has observable behavior via getComputedStyle, for example. if (Servo_Element_IsDisplayNone(parent->AsElement())) { return; } } if (PresShell* presShell = doc->GetPresShell()) { presShell->EnsureStyleFlush(); } MOZ_ASSERT(parent->IsElement() || parent == doc); // The bit checks below rely on this to arrive to useful conclusions about the // shape of the tree. AssertNoBitsPropagatedFrom(existingRoot); // If there's no existing restyle root, or if the root is already aElement, // just note the root+bits and return. if (!existingRoot) { doc->SetServoRestyleRoot(aElement, aBits); return; } // There is an existing restyle root - walk up the tree from our element, // propagating bits as we go. const bool reachedDocRoot = !parent->IsElement() || !PropagateBits(parent->AsElement(), aBits, existingRoot, aBits); uint32_t existingBits = doc->GetServoRestyleRootDirtyBits(); if (!reachedDocRoot || existingRoot == doc) { // We're a descendant of the existing root. All that's left to do is to // make sure the bit we propagated is also registered on the root. doc->SetServoRestyleRoot(existingRoot, existingBits | aBits); } else { // We reached the root without crossing the pre-existing restyle root. We // now need to find the nearest common ancestor, so climb up from the // existing root, extending bits along the way. Element* rootParent = existingRoot->GetFlattenedTreeParentElementForStyle(); // We can stop at the first occurrence of `aBits` in order to find the // common ancestor. if (Element* commonAncestor = PropagateBits(rootParent, existingBits, aElement, aBits)) { MOZ_ASSERT(commonAncestor == aElement || commonAncestor == nsContentUtils::GetCommonFlattenedTreeAncestorForStyle( aElement, rootParent)); // We found a common ancestor. Make that the new style root, and clear the // bits between the new style root and the document root. doc->SetServoRestyleRoot(commonAncestor, existingBits | aBits); Element* curr = commonAncestor; while ((curr = curr->GetFlattenedTreeParentElementForStyle())) { MOZ_ASSERT(curr->HasAllFlags(aBits)); curr->UnsetFlags(aBits); } AssertNoBitsPropagatedFrom(commonAncestor); } else { // We didn't find a common ancestor element. That means we're descended // from two different document style roots, so the common ancestor is the // document. doc->SetServoRestyleRoot(doc, existingBits | aBits); } } // See the comment in Document::SetServoRestyleRoot about the !IsElement() // check there. Same justification here. MOZ_ASSERT(aElement == doc->GetServoRestyleRoot() || !doc->GetServoRestyleRoot()->IsElement() || nsContentUtils::ContentIsFlattenedTreeDescendantOfForStyle( aElement, doc->GetServoRestyleRoot())); MOZ_ASSERT(aElement == doc->GetServoRestyleRoot() || !doc->GetServoRestyleRoot()->IsElement() || !parent->IsElement() || BitsArePropagated(parent->AsElement(), aBits, doc->GetServoRestyleRoot())); MOZ_ASSERT(doc->GetServoRestyleRootDirtyBits() & aBits); } void Element::NoteDirtySubtreeForServo() { MOZ_ASSERT(IsInComposedDoc()); MOZ_ASSERT(HasServoData()); Document* doc = GetComposedDoc(); nsINode* existingRoot = doc->GetServoRestyleRoot(); uint32_t existingBits = existingRoot ? doc->GetServoRestyleRootDirtyBits() : 0; if (existingRoot && existingRoot->IsElement() && existingRoot != this && nsContentUtils::ContentIsFlattenedTreeDescendantOfForStyle( existingRoot->AsElement(), this)) { PropagateBits( existingRoot->AsElement()->GetFlattenedTreeParentElementForStyle(), existingBits, this, existingBits); doc->ClearServoRestyleRoot(); } NoteDirtyElement(this, existingBits | ELEMENT_HAS_DIRTY_DESCENDANTS_FOR_SERVO); } void Element::NoteDirtyForServo() { NoteDirtyElement(this, ELEMENT_HAS_DIRTY_DESCENDANTS_FOR_SERVO); } void Element::NoteAnimationOnlyDirtyForServo() { NoteDirtyElement(this, ELEMENT_HAS_ANIMATION_ONLY_DIRTY_DESCENDANTS_FOR_SERVO); } void Element::NoteDescendantsNeedFramesForServo() { // Since lazy frame construction can be required for non-element nodes, this // Note() method operates on the parent of the frame-requiring content, unlike // the other Note() methods above (which operate directly on the element that // needs processing). NoteDirtyElement(this, NODE_DESCENDANTS_NEED_FRAMES); SetFlags(NODE_DESCENDANTS_NEED_FRAMES); } double Element::FirstLineBoxBSize() const { const nsBlockFrame* frame = do_QueryFrame(GetPrimaryFrame()); if (!frame) { return 0.0; } nsBlockFrame::ConstLineIterator line = frame->LinesBegin(); nsBlockFrame::ConstLineIterator lineEnd = frame->LinesEnd(); return line != lineEnd ? nsPresContext::AppUnitsToDoubleCSSPixels(line->BSize()) : 0.0; } // static nsAtom* Element::GetEventNameForAttr(nsAtom* aAttr) { if (aAttr == nsGkAtoms::onwebkitanimationend) { return nsGkAtoms::onwebkitAnimationEnd; } if (aAttr == nsGkAtoms::onwebkitanimationiteration) { return nsGkAtoms::onwebkitAnimationIteration; } if (aAttr == nsGkAtoms::onwebkitanimationstart) { return nsGkAtoms::onwebkitAnimationStart; } if (aAttr == nsGkAtoms::onwebkittransitionend) { return nsGkAtoms::onwebkitTransitionEnd; } return aAttr; } void Element::RegUnRegAccessKey(bool aDoReg) { // first check to see if we have an access key nsAutoString accessKey; GetAttr(nsGkAtoms::accesskey, accessKey); if (accessKey.IsEmpty()) { return; } // We have an access key, so get the ESM from the pres context. if (nsPresContext* presContext = GetPresContext(eForComposedDoc)) { EventStateManager* esm = presContext->EventStateManager(); // Register or unregister as appropriate. if (aDoReg) { esm->RegisterAccessKey(this, (uint32_t)accessKey.First()); } else { esm->UnregisterAccessKey(this, (uint32_t)accessKey.First()); } } } void Element::SetHTML(const nsAString& aHTML, const SetHTMLOptions& aOptions, ErrorResult& aError) { nsContentUtils::SetHTML(this, this, aHTML, aOptions, aError); } void Element::GetHTML(const GetHTMLOptions& aOptions, nsAString& aResult) { if (aOptions.mSerializableShadowRoots || !aOptions.mShadowRoots.IsEmpty()) { nsContentUtils::SerializeNodeToMarkup( this, true, aResult, aOptions.mSerializableShadowRoots, aOptions.mShadowRoots); } else { nsContentUtils::SerializeNodeToMarkup( this, true, aResult, aOptions.mSerializableShadowRoots, aOptions.mShadowRoots); } } StylePropertyMapReadOnly* Element::ComputedStyleMap() { nsDOMSlots* slots = DOMSlots(); if (!slots->mComputedStyleMap) { slots->mComputedStyleMap = MakeRefPtr(this); } return slots->mComputedStyleMap; } bool Element::Translate() const { if (const auto* parent = Element::FromNodeOrNull(mParent)) { return parent->Translate(); } return true; } EditorBase* Element::GetExtantEditor() const { if (!IsInComposedDoc()) { return nullptr; } const bool isInDesignMode = IsInDesignMode(); // Even if a text control element is an editing host, TextEditor handles // user input. Therefore, we should return TextEditor (or nullptr) in this // case. Note that text control element in the design mode does not work as // a text control. Therefore, in that case, we should return HTMLEditor. if (!isInDesignMode) { if (const auto* textControlElement = TextControlElement::FromNode(this)) { if (textControlElement->IsSingleLineTextControlOrTextArea()) { return textControlElement->GetExtantTextEditor(); } } } if (!isInDesignMode && !IsEditable()) { return nullptr; } // FYI: This never creates HTMLEditor immediately. nsDocShell* const docShell = nsDocShell::Cast(OwnerDoc()->GetDocShell()); return docShell ? docShell->GetHTMLEditorInternal() : nullptr; } /* https://html.spec.whatwg.org/#dom-element-sethtmlunsafe */ void Element::SetHTMLUnsafe(const TrustedHTMLOrString& aHTML, const SetHTMLUnsafeOptions& aOptions, nsIPrincipal* aSubjectPrincipal, ErrorResult& aError) { nsContentUtils::SetHTMLUnsafe(this, this, aHTML, aOptions, false /*aIsShadowRoot*/, aSubjectPrincipal, aError); } // https://html.spec.whatwg.org/#event-beforematch void Element::FireBeforematchEvent(ErrorResult& aRv) { RefPtr event = NS_NewDOMEvent(this, nullptr, nullptr); event->InitEvent(u"beforematch"_ns, /*aCanBubble=*/true, /*aCancelable=*/false); event->SetTrusted(true); DispatchEvent(*event, aRv); } bool Element::BlockingContainsRender() const { const nsAttrValue* attrValue = GetParsedAttr(nsGkAtoms::blocking); if (!attrValue || !StaticPrefs::dom_element_blocking_enabled()) { return false; } MOZ_ASSERT(attrValue->Type() == nsAttrValue::eAtomArray, "Checking blocking attribute on element that doesn't parse it?"); return attrValue->Contains(nsGkAtoms::render, eIgnoreCase); } 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; nsRect 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(); const auto effectiveZoom = frame->Style()->EffectiveZoom(); 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; } // WebKit-ism: offsetParent stops at zoom changes. // See https://github.com/w3c/csswg-drafts/issues/10252 if (effectiveZoom != parent->Style()->EffectiveZoom()) { 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 && !frame->GetParent()->IsViewportFrame()) { // 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), 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* Element::GetOffsetRect(CSSIntRect& aRect) { aRect = CSSIntRect(); nsIFrame* frame = GetPrimaryFrame(FlushType::Layout); if (!frame) { return nullptr; } OffsetResult thisResult = GetUnretargetedOffsetsFor(*this); nsRect rect = thisResult.mRect; Element* parent = thisResult.mParent; while (parent && ShouldBeRetargeted(*this, *parent)) { OffsetResult result = GetUnretargetedOffsetsFor(*parent); rect += result.mRect.TopLeft(); parent = result.mParent; } aRect = CSSIntRect::FromAppUnitsRounded( frame->Style()->EffectiveZoom().Unzoom(rect)); return parent; } } // namespace mozilla::dom