diff options
Diffstat (limited to '')
| -rw-r--r-- | layout/generic/nsIFrame.cpp | 12506 |
1 files changed, 12506 insertions, 0 deletions
diff --git a/layout/generic/nsIFrame.cpp b/layout/generic/nsIFrame.cpp new file mode 100644 index 0000000000..18b53baa91 --- /dev/null +++ b/layout/generic/nsIFrame.cpp @@ -0,0 +1,12506 @@ +/* -*- 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/. */ + +/* base class of all rendering objects */ + +#include "nsIFrame.h" + +#include <stdarg.h> +#include <algorithm> + +#include "gfx2DGlue.h" +#include "gfxUtils.h" +#include "mozilla/Attributes.h" +#include "mozilla/ComputedStyle.h" +#include "mozilla/DebugOnly.h" +#include "mozilla/DisplayPortUtils.h" +#include "mozilla/dom/CSSAnimation.h" +#include "mozilla/dom/CSSTransition.h" +#include "mozilla/dom/ContentVisibilityAutoStateChangeEvent.h" +#include "mozilla/dom/DocumentInlines.h" +#include "mozilla/dom/AncestorIterator.h" +#include "mozilla/dom/ElementInlines.h" +#include "mozilla/dom/ImageTracker.h" +#include "mozilla/dom/Selection.h" +#include "mozilla/gfx/2D.h" +#include "mozilla/gfx/PathHelpers.h" +#include "mozilla/intl/BidiEmbeddingLevel.h" +#include "mozilla/Maybe.h" +#include "mozilla/PresShell.h" +#include "mozilla/PresShellInlines.h" +#include "mozilla/ResultExtensions.h" +#include "mozilla/Sprintf.h" +#include "mozilla/StaticAnalysisFunctions.h" +#include "mozilla/StaticPrefs_layout.h" +#include "mozilla/StaticPrefs_print.h" +#include "mozilla/SVGMaskFrame.h" +#include "mozilla/SVGObserverUtils.h" +#include "mozilla/SVGTextFrame.h" +#include "mozilla/SVGIntegrationUtils.h" +#include "mozilla/SVGUtils.h" +#include "mozilla/ToString.h" +#include "mozilla/ViewportUtils.h" + +#include "nsCOMPtr.h" +#include "nsFieldSetFrame.h" +#include "nsFlexContainerFrame.h" +#include "nsFocusManager.h" +#include "nsFrameList.h" +#include "nsPlaceholderFrame.h" +#include "nsIBaseWindow.h" +#include "nsIContent.h" +#include "nsIContentInlines.h" +#include "nsContentUtils.h" +#include "nsCSSFrameConstructor.h" +#include "nsCSSProps.h" +#include "nsCSSPseudoElements.h" +#include "nsCSSRendering.h" +#include "nsAtom.h" +#include "nsString.h" +#include "nsReadableUtils.h" +#include "nsTableWrapperFrame.h" +#include "nsView.h" +#include "nsViewManager.h" +#include "nsIScrollableFrame.h" +#include "nsPresContext.h" +#include "nsPresContextInlines.h" +#include "nsStyleConsts.h" +#include "mozilla/Logging.h" +#include "nsLayoutUtils.h" +#include "LayoutLogging.h" +#include "mozilla/RestyleManager.h" +#include "nsImageFrame.h" +#include "nsInlineFrame.h" +#include "nsFrameSelection.h" +#include "nsGkAtoms.h" +#include "nsGridContainerFrame.h" +#include "nsGfxScrollFrame.h" +#include "nsCSSAnonBoxes.h" +#include "nsCanvasFrame.h" + +#include "nsFieldSetFrame.h" +#include "nsFrameTraversal.h" +#include "nsRange.h" +#include "nsITextControlFrame.h" +#include "nsNameSpaceManager.h" +#include "nsIPercentBSizeObserver.h" +#include "nsStyleStructInlines.h" + +#include "nsBidiPresUtils.h" +#include "RubyUtils.h" +#include "TextOverflow.h" +#include "nsAnimationManager.h" + +// For triple-click pref +#include "imgIRequest.h" +#include "nsError.h" +#include "nsContainerFrame.h" +#include "nsBlockFrame.h" +#include "nsDisplayList.h" +#include "nsChangeHint.h" +#include "nsSubDocumentFrame.h" +#include "RetainedDisplayListBuilder.h" + +#include "gfxContext.h" +#include "nsAbsoluteContainingBlock.h" +#include "ScrollSnap.h" +#include "StickyScrollContainer.h" +#include "nsFontInflationData.h" +#include "nsRegion.h" +#include "nsIFrameInlines.h" +#include "nsStyleChangeList.h" +#include "nsWindowSizes.h" + +#ifdef ACCESSIBILITY +# include "nsAccessibilityService.h" +#endif + +#include "mozilla/AsyncEventDispatcher.h" +#include "mozilla/CSSClipPathInstance.h" +#include "mozilla/EffectCompositor.h" +#include "mozilla/EffectSet.h" +#include "mozilla/EventListenerManager.h" +#include "mozilla/EventStateManager.h" +#include "mozilla/Preferences.h" +#include "mozilla/LookAndFeel.h" +#include "mozilla/MouseEvents.h" +#include "mozilla/ServoStyleSet.h" +#include "mozilla/ServoStyleSetInlines.h" +#include "mozilla/css/ImageLoader.h" +#include "mozilla/dom/HTMLBodyElement.h" +#include "mozilla/dom/SVGPathData.h" +#include "mozilla/dom/TouchEvent.h" +#include "mozilla/gfx/Tools.h" +#include "mozilla/layers/WebRenderUserData.h" +#include "mozilla/layout/ScrollAnchorContainer.h" +#include "nsPrintfCString.h" +#include "ActiveLayerTracker.h" + +#include "nsITheme.h" + +using namespace mozilla; +using namespace mozilla::css; +using namespace mozilla::dom; +using namespace mozilla::gfx; +using namespace mozilla::layers; +using namespace mozilla::layout; +typedef nsAbsoluteContainingBlock::AbsPosReflowFlags AbsPosReflowFlags; +using nsStyleTransformMatrix::TransformReferenceBox; + +const mozilla::LayoutFrameType nsIFrame::sLayoutFrameTypes[ +#define FRAME_ID(...) 1 + +#define ABSTRACT_FRAME_ID(...) +#include "mozilla/FrameIdList.h" +#undef FRAME_ID +#undef ABSTRACT_FRAME_ID + 0] = { +#define FRAME_ID(class_, type_, ...) mozilla::LayoutFrameType::type_, +#define ABSTRACT_FRAME_ID(...) +#include "mozilla/FrameIdList.h" +#undef FRAME_ID +#undef ABSTRACT_FRAME_ID +}; + +const nsIFrame::FrameClassBits nsIFrame::sFrameClassBits[ +#define FRAME_ID(...) 1 + +#define ABSTRACT_FRAME_ID(...) +#include "mozilla/FrameIdList.h" +#undef FRAME_ID +#undef ABSTRACT_FRAME_ID + 0] = { +#define Leaf eFrameClassBitsLeaf +#define NotLeaf eFrameClassBitsNone +#define DynamicLeaf eFrameClassBitsDynamicLeaf +#define FRAME_ID(class_, type_, leaf_, ...) leaf_, +#define ABSTRACT_FRAME_ID(...) +#include "mozilla/FrameIdList.h" +#undef Leaf +#undef NotLeaf +#undef DynamicLeaf +#undef FRAME_ID +#undef ABSTRACT_FRAME_ID +}; + +std::ostream& operator<<(std::ostream& aStream, const nsDirection& aDirection) { + return aStream << (aDirection == eDirNext ? "eDirNext" : "eDirPrevious"); +} + +struct nsContentAndOffset { + nsIContent* mContent = nullptr; + int32_t mOffset = 0; +}; + +// Some Misc #defines +#define SELECTION_DEBUG 0 +#define FORCE_SELECTION_UPDATE 1 +#define CALC_DEBUG 0 + +#include "nsILineIterator.h" +#include "prenv.h" + +// Utility function to set a nsRect-valued property table entry on aFrame, +// reusing the existing storage if the property happens to be already set. +template <typename T> +static void SetOrUpdateRectValuedProperty( + nsIFrame* aFrame, FrameProperties::Descriptor<T> aProperty, + const nsRect& aNewValue) { + bool found; + nsRect* rectStorage = aFrame->GetProperty(aProperty, &found); + if (!found) { + rectStorage = new nsRect(aNewValue); + aFrame->AddProperty(aProperty, rectStorage); + } else { + *rectStorage = aNewValue; + } +} + +FrameDestroyContext::~FrameDestroyContext() { + for (auto& content : mozilla::Reversed(mAnonymousContent)) { + mPresShell->NativeAnonymousContentRemoved(content); + content->UnbindFromTree(); + } +} + +// Formerly the nsIFrameDebug interface + +std::ostream& operator<<(std::ostream& aStream, const nsReflowStatus& aStatus) { + char complete = 'Y'; + if (aStatus.IsIncomplete()) { + complete = 'N'; + } else if (aStatus.IsOverflowIncomplete()) { + complete = 'O'; + } + + char brk = 'N'; + if (aStatus.IsInlineBreakBefore()) { + brk = 'B'; + } else if (aStatus.IsInlineBreakAfter()) { + brk = 'A'; + } + + aStream << "[" + << "Complete=" << complete << "," + << "NIF=" << (aStatus.NextInFlowNeedsReflow() ? 'Y' : 'N') << "," + << "Break=" << brk << "," + << "FirstLetter=" << (aStatus.FirstLetterComplete() ? 'Y' : 'N') + << "]"; + return aStream; +} + +#ifdef DEBUG + +/** + * Note: the log module is created during library initialization which + * means that you cannot perform logging before then. + */ +mozilla::LazyLogModule nsIFrame::sFrameLogModule("frame"); + +#endif + +NS_DECLARE_FRAME_PROPERTY_DELETABLE(AbsoluteContainingBlockProperty, + nsAbsoluteContainingBlock) + +bool nsIFrame::HasAbsolutelyPositionedChildren() const { + return IsAbsoluteContainer() && + GetAbsoluteContainingBlock()->HasAbsoluteFrames(); +} + +nsAbsoluteContainingBlock* nsIFrame::GetAbsoluteContainingBlock() const { + NS_ASSERTION(IsAbsoluteContainer(), + "The frame is not marked as an abspos container correctly"); + nsAbsoluteContainingBlock* absCB = + GetProperty(AbsoluteContainingBlockProperty()); + NS_ASSERTION(absCB, + "The frame is marked as an abspos container but doesn't have " + "the property"); + return absCB; +} + +void nsIFrame::MarkAsAbsoluteContainingBlock() { + MOZ_ASSERT(HasAnyStateBits(NS_FRAME_CAN_HAVE_ABSPOS_CHILDREN)); + NS_ASSERTION(!GetProperty(AbsoluteContainingBlockProperty()), + "Already has an abs-pos containing block property?"); + NS_ASSERTION(!HasAnyStateBits(NS_FRAME_HAS_ABSPOS_CHILDREN), + "Already has NS_FRAME_HAS_ABSPOS_CHILDREN state bit?"); + AddStateBits(NS_FRAME_HAS_ABSPOS_CHILDREN); + SetProperty(AbsoluteContainingBlockProperty(), + new nsAbsoluteContainingBlock(GetAbsoluteListID())); +} + +void nsIFrame::MarkAsNotAbsoluteContainingBlock() { + NS_ASSERTION(!HasAbsolutelyPositionedChildren(), "Think of the children!"); + NS_ASSERTION(GetProperty(AbsoluteContainingBlockProperty()), + "Should have an abs-pos containing block property"); + NS_ASSERTION(HasAnyStateBits(NS_FRAME_HAS_ABSPOS_CHILDREN), + "Should have NS_FRAME_HAS_ABSPOS_CHILDREN state bit"); + MOZ_ASSERT(HasAnyStateBits(NS_FRAME_CAN_HAVE_ABSPOS_CHILDREN)); + RemoveStateBits(NS_FRAME_HAS_ABSPOS_CHILDREN); + RemoveProperty(AbsoluteContainingBlockProperty()); +} + +bool nsIFrame::CheckAndClearPaintedState() { + bool result = HasAnyStateBits(NS_FRAME_PAINTED_THEBES); + RemoveStateBits(NS_FRAME_PAINTED_THEBES); + + for (const auto& childList : ChildLists()) { + for (nsIFrame* child : childList.mList) { + if (child->CheckAndClearPaintedState()) { + result = true; + } + } + } + return result; +} + +bool nsIFrame::CheckAndClearDisplayListState() { + bool result = BuiltDisplayList(); + SetBuiltDisplayList(false); + + for (const auto& childList : ChildLists()) { + for (nsIFrame* child : childList.mList) { + if (child->CheckAndClearDisplayListState()) { + result = true; + } + } + } + return result; +} + +bool nsIFrame::IsVisibleConsideringAncestors(uint32_t aFlags) const { + if (!StyleVisibility()->IsVisible()) { + return false; + } + + if (PresShell()->IsUnderHiddenEmbedderElement()) { + return false; + } + + const nsIFrame* frame = this; + while (frame) { + nsView* view = frame->GetView(); + if (view && view->GetVisibility() == ViewVisibility::Hide) { + return false; + } + + if (frame->StyleUIReset()->mMozSubtreeHiddenOnlyVisually) { + return false; + } + + // This method is used to determine if a frame is focusable, because it's + // called by nsIFrame::IsFocusable. `content-visibility: auto` should not + // force this frame to be unfocusable, so we only take into account + // `content-visibility: hidden` here. + if (this != frame && + frame->HidesContent(IncludeContentVisibility::Hidden)) { + return false; + } + + if (nsIFrame* parent = frame->GetParent()) { + frame = parent; + } else { + parent = nsLayoutUtils::GetCrossDocParentFrameInProcess(frame); + if (!parent) break; + + if ((aFlags & nsIFrame::VISIBILITY_CROSS_CHROME_CONTENT_BOUNDARY) == 0 && + parent->PresContext()->IsChrome() && + !frame->PresContext()->IsChrome()) { + break; + } + + frame = parent; + } + } + + return true; +} + +void nsIFrame::FindCloserFrameForSelection( + const nsPoint& aPoint, FrameWithDistance* aCurrentBestFrame) { + if (nsLayoutUtils::PointIsCloserToRect(aPoint, mRect, + aCurrentBestFrame->mXDistance, + aCurrentBestFrame->mYDistance)) { + aCurrentBestFrame->mFrame = this; + } +} + +void nsIFrame::ElementStateChanged(mozilla::dom::ElementState aStates) {} + +void WeakFrame::Clear(mozilla::PresShell* aPresShell) { + if (aPresShell) { + aPresShell->RemoveWeakFrame(this); + } + mFrame = nullptr; +} + +AutoWeakFrame::AutoWeakFrame(const WeakFrame& aOther) + : mPrev(nullptr), mFrame(nullptr) { + Init(aOther.GetFrame()); +} + +void AutoWeakFrame::Clear(mozilla::PresShell* aPresShell) { + if (aPresShell) { + aPresShell->RemoveAutoWeakFrame(this); + } + mFrame = nullptr; + mPrev = nullptr; +} + +AutoWeakFrame::~AutoWeakFrame() { + Clear(mFrame ? mFrame->PresContext()->GetPresShell() : nullptr); +} + +void AutoWeakFrame::Init(nsIFrame* aFrame) { + Clear(mFrame ? mFrame->PresContext()->GetPresShell() : nullptr); + mFrame = aFrame; + if (mFrame) { + mozilla::PresShell* presShell = mFrame->PresContext()->GetPresShell(); + NS_WARNING_ASSERTION(presShell, "Null PresShell in AutoWeakFrame!"); + if (presShell) { + presShell->AddAutoWeakFrame(this); + } else { + mFrame = nullptr; + } + } +} + +void WeakFrame::Init(nsIFrame* aFrame) { + Clear(mFrame ? mFrame->PresContext()->GetPresShell() : nullptr); + mFrame = aFrame; + if (mFrame) { + mozilla::PresShell* presShell = mFrame->PresContext()->GetPresShell(); + MOZ_ASSERT(presShell, "Null PresShell in WeakFrame!"); + if (presShell) { + presShell->AddWeakFrame(this); + } else { + mFrame = nullptr; + } + } +} + +nsIFrame* NS_NewEmptyFrame(PresShell* aPresShell, ComputedStyle* aStyle) { + return new (aPresShell) nsIFrame(aStyle, aPresShell->GetPresContext()); +} + +nsIFrame::~nsIFrame() { + MOZ_COUNT_DTOR(nsIFrame); + + MOZ_ASSERT(GetVisibility() != Visibility::ApproximatelyVisible, + "Visible nsFrame is being destroyed"); +} + +NS_IMPL_FRAMEARENA_HELPERS(nsIFrame) + +// Dummy operator delete. Will never be called, but must be defined +// to satisfy some C++ ABIs. +void nsIFrame::operator delete(void*, size_t) { + MOZ_CRASH("nsIFrame::operator delete should never be called"); +} + +NS_QUERYFRAME_HEAD(nsIFrame) + NS_QUERYFRAME_ENTRY(nsIFrame) +NS_QUERYFRAME_TAIL_INHERITANCE_ROOT + +///////////////////////////////////////////////////////////////////////////// +// nsIFrame + +static bool IsFontSizeInflationContainer(nsIFrame* aFrame, + const nsStyleDisplay* aStyleDisplay) { + /* + * Font size inflation is built around the idea that we're inflating + * the fonts for a pan-and-zoom UI so that when the user scales up a + * block or other container to fill the width of the device, the fonts + * will be readable. To do this, we need to pick what counts as a + * container. + * + * From a code perspective, the only hard requirement is that frames + * that are line participants + * (nsIFrame::IsFrameOfType(nsIFrame::eLineParticipant)) are never + * containers, since line layout assumes that the inflation is + * consistent within a line. + * + * This is not an imposition, since we obviously want a bunch of text + * (possibly with inline elements) flowing within a block to count the + * block (or higher) as its container. + * + * We also want form controls, including the text in the anonymous + * content inside of them, to match each other and the text next to + * them, so they and their anonymous content should also not be a + * container. + * + * However, because we can't reliably compute sizes across XUL during + * reflow, any XUL frame with a XUL parent is always a container. + * + * There are contexts where it would be nice if some blocks didn't + * count as a container, so that, for example, an indented quotation + * didn't end up with a smaller font size. However, it's hard to + * distinguish these situations where we really do want the indented + * thing to count as a container, so we don't try, and blocks are + * always containers. + */ + + // The root frame should always be an inflation container. + if (!aFrame->GetParent()) { + return true; + } + + nsIContent* content = aFrame->GetContent(); + if (content && content->IsInNativeAnonymousSubtree()) { + // Native anonymous content shouldn't be a font inflation root, + // except for the canvas custom content container. + nsCanvasFrame* canvas = aFrame->PresShell()->GetCanvasFrame(); + return canvas && canvas->GetCustomContentContainer() == content; + } + + LayoutFrameType frameType = aFrame->Type(); + bool isInline = + (nsStyleDisplay::IsInlineFlow(aFrame->GetDisplay()) || + RubyUtils::IsRubyBox(frameType) || + (aStyleDisplay->IsFloatingStyle() && + frameType == LayoutFrameType::Letter) || + // Given multiple frames for the same node, only the + // outer one should be considered a container. + // (Important, e.g., for nsSelectsAreaFrame.) + (aFrame->GetParent()->GetContent() == content) || + (content && + // Form controls shouldn't become inflation containers. + (content->IsAnyOfHTMLElements( + nsGkAtoms::option, nsGkAtoms::optgroup, nsGkAtoms::select, + nsGkAtoms::input, nsGkAtoms::button, nsGkAtoms::textarea)))); + NS_ASSERTION(!aFrame->IsFrameOfType(nsIFrame::eLineParticipant) || isInline || + // br frames and mathml frames report being line + // participants even when their position or display is + // set + aFrame->IsBrFrame() || + aFrame->IsFrameOfType(nsIFrame::eMathML), + "line participants must not be containers"); + return !isInline; +} + +static void MaybeScheduleReflowSVGNonDisplayText(nsIFrame* aFrame) { + if (!aFrame->IsInSVGTextSubtree()) { + return; + } + + // We need to ensure that any non-display SVGTextFrames get reflowed when a + // child text frame gets new style. Thus we need to schedule a reflow in + // |DidSetComputedStyle|. We also need to call it from |DestroyFrom|, + // because otherwise we won't get notified when style changes to + // "display:none". + SVGTextFrame* svgTextFrame = static_cast<SVGTextFrame*>( + nsLayoutUtils::GetClosestFrameOfType(aFrame, LayoutFrameType::SVGText)); + nsIFrame* anonBlock = svgTextFrame->PrincipalChildList().FirstChild(); + + // Note that we must check NS_FRAME_FIRST_REFLOW on our SVGTextFrame's + // anonymous block frame rather than our aFrame, since NS_FRAME_FIRST_REFLOW + // may be set on us if we're a new frame that has been inserted after the + // document's first reflow. (In which case this DidSetComputedStyle call may + // be happening under frame construction under a Reflow() call.) + if (!anonBlock || anonBlock->HasAnyStateBits(NS_FRAME_FIRST_REFLOW)) { + return; + } + + if (!svgTextFrame->HasAnyStateBits(NS_FRAME_IS_NONDISPLAY) || + svgTextFrame->HasAnyStateBits(NS_STATE_SVG_TEXT_IN_REFLOW)) { + return; + } + + svgTextFrame->ScheduleReflowSVGNonDisplayText( + IntrinsicDirty::FrameAncestorsAndDescendants); +} + +bool nsIFrame::IsPrimaryFrameOfRootOrBodyElement() const { + if (!IsPrimaryFrame()) { + return false; + } + nsIContent* content = GetContent(); + Document* document = content->OwnerDoc(); + return content == document->GetRootElement() || + content == document->GetBodyElement(); +} + +bool nsIFrame::IsRenderedLegend() const { + if (auto* parent = GetParent(); parent && parent->IsFieldSetFrame()) { + return static_cast<nsFieldSetFrame*>(parent)->GetLegend() == this; + } + return false; +} + +void nsIFrame::Init(nsIContent* aContent, nsContainerFrame* aParent, + nsIFrame* aPrevInFlow) { + MOZ_ASSERT(nsQueryFrame::FrameIID(mClass) == GetFrameId()); + MOZ_ASSERT(!mContent, "Double-initing a frame?"); + NS_ASSERTION(IsFrameOfType(eDEBUGAllFrames) && !IsFrameOfType(eDEBUGNoFrames), + "IsFrameOfType implementation that doesn't call base class"); + + mContent = aContent; + mParent = aParent; + MOZ_DIAGNOSTIC_ASSERT(!mParent || PresShell() == mParent->PresShell()); + + if (aPrevInFlow) { + mWritingMode = aPrevInFlow->GetWritingMode(); + + // Copy some state bits from prev-in-flow (the bits that should apply + // throughout a continuation chain). The bits are sorted according to their + // order in nsFrameStateBits.h. + + // clang-format off + AddStateBits(aPrevInFlow->GetStateBits() & + (NS_FRAME_GENERATED_CONTENT | + NS_FRAME_OUT_OF_FLOW | + NS_FRAME_CAN_HAVE_ABSPOS_CHILDREN | + NS_FRAME_INDEPENDENT_SELECTION | + NS_FRAME_PART_OF_IBSPLIT | + NS_FRAME_MAY_BE_TRANSFORMED | + NS_FRAME_HAS_MULTI_COLUMN_ANCESTOR)); + // clang-format on + + // Copy other bits in nsIFrame from prev-in-flow. + mHasColumnSpanSiblings = aPrevInFlow->HasColumnSpanSiblings(); + } else { + PresContext()->ConstructedFrame(); + } + + if (GetParent()) { + if (MOZ_UNLIKELY(mContent == PresContext()->Document()->GetRootElement() && + mContent == GetParent()->GetContent())) { + // Our content is the root element and we have the same content as our + // parent. That is, we are the internal anonymous frame of the root + // element. Copy the used mWritingMode from our parent because + // mDocElementContainingBlock gets its mWritingMode from <body>. + mWritingMode = GetParent()->GetWritingMode(); + } + + // Copy some state bits from our parent (the bits that should apply + // recursively throughout a subtree). The bits are sorted according to their + // order in nsFrameStateBits.h. + + // clang-format off + AddStateBits(GetParent()->GetStateBits() & + (NS_FRAME_GENERATED_CONTENT | + NS_FRAME_INDEPENDENT_SELECTION | + NS_FRAME_IS_SVG_TEXT | + NS_FRAME_IN_POPUP | + NS_FRAME_IS_NONDISPLAY)); + // clang-format on + + if (HasAnyStateBits(NS_FRAME_IN_POPUP) && TrackingVisibility()) { + // Assume all frames in popups are visible. + IncApproximateVisibleCount(); + } + } + if (aPrevInFlow) { + mMayHaveOpacityAnimation = aPrevInFlow->MayHaveOpacityAnimation(); + mMayHaveTransformAnimation = aPrevInFlow->MayHaveTransformAnimation(); + } else if (mContent) { + // It's fine to fetch the EffectSet for the style frame here because in the + // following code we take care of the case where animations may target + // a different frame. + EffectSet* effectSet = EffectSet::GetForStyleFrame(this); + if (effectSet) { + mMayHaveOpacityAnimation = effectSet->MayHaveOpacityAnimation(); + + if (effectSet->MayHaveTransformAnimation()) { + // If we are the inner table frame for display:table content, then + // transform animations should go on our parent frame (the table wrapper + // frame). + // + // We do this when initializing the child frame (table inner frame), + // because when initializng the table wrapper frame, we don't yet have + // access to its children so we can't tell if we have transform + // animations or not. + if (IsFrameOfType(eSupportsCSSTransforms)) { + mMayHaveTransformAnimation = true; + AddStateBits(NS_FRAME_MAY_BE_TRANSFORMED); + } else if (aParent && nsLayoutUtils::GetStyleFrame(aParent) == this) { + MOZ_ASSERT( + aParent->IsFrameOfType(eSupportsCSSTransforms), + "Style frames that don't support transforms should have parents" + " that do"); + aParent->mMayHaveTransformAnimation = true; + aParent->AddStateBits(NS_FRAME_MAY_BE_TRANSFORMED); + } + } + } + } + + const nsStyleDisplay* disp = StyleDisplay(); + if (disp->HasTransform(this)) { + // If 'transform' dynamically changes, RestyleManager takes care of + // updating this bit. + AddStateBits(NS_FRAME_MAY_BE_TRANSFORMED); + } + + if (disp->IsContainLayout() && GetContainSizeAxes().IsBoth()) { + // In general, frames that have contain:layout+size can be reflow roots. + // (One exception: table-wrapper frames don't work well as reflow roots, + // because their inner-table ReflowInput init path tries to reuse & deref + // the wrapper's containing block's reflow input, which may be null if we + // initiate reflow from the table-wrapper itself.) + // + // Changes to `contain` force frame reconstructions, so this bit can be set + // for the whole lifetime of this frame. + AddStateBits(NS_FRAME_REFLOW_ROOT); + } + + if (nsLayoutUtils::FontSizeInflationEnabled(PresContext()) || + !GetParent() +#ifdef DEBUG + // We have assertions that check inflation invariants even when + // font size inflation is not enabled. + || true +#endif + ) { + if (IsFontSizeInflationContainer(this, disp)) { + AddStateBits(NS_FRAME_FONT_INFLATION_CONTAINER); + if (!GetParent() || + // I'd use NS_FRAME_OUT_OF_FLOW, but it's not set yet. + disp->IsFloating(this) || disp->IsAbsolutelyPositioned(this) || + GetParent()->IsFlexContainerFrame() || + GetParent()->IsGridContainerFrame()) { + AddStateBits(NS_FRAME_FONT_INFLATION_FLOW_ROOT); + } + } + NS_ASSERTION( + GetParent() || HasAnyStateBits(NS_FRAME_FONT_INFLATION_CONTAINER), + "root frame should always be a container"); + } + + if (PresShell()->AssumeAllFramesVisible() && TrackingVisibility()) { + IncApproximateVisibleCount(); + } + + DidSetComputedStyle(nullptr); + + // For a newly created frame, we need to update this frame's visibility state. + // Usually we update the state when the frame is restyled and has a + // VisibilityChange change hint but we don't generate any change hints for + // newly created frames. + // Note: We don't need to do this for placeholders since placeholders have + // different styles so that the styles don't have visibility:hidden even if + // the parent has visibility:hidden style. We also don't need to update the + // state when creating continuations because its visibility is the same as its + // prev-in-flow, and the animation code cares only primary frames. + if (!IsPlaceholderFrame() && !aPrevInFlow) { + UpdateVisibleDescendantsState(); + } +} + +void nsIFrame::InitPrimaryFrame() { + MOZ_ASSERT(IsPrimaryFrame()); + const nsStyleDisplay* disp = StyleDisplay(); + + if (disp->mContainerType != StyleContainerType::Normal) { + PresContext()->RegisterContainerQueryFrame(this); + } + + if (StyleDisplay()->ContentVisibility(*this) == + StyleContentVisibility::Auto) { + PresShell()->RegisterContentVisibilityAutoFrame(this); + auto* element = Element::FromNodeOrNull(GetContent()); + MOZ_ASSERT(element); + PresContext()->Document()->ObserveForContentVisibility(*element); + } else if (auto* element = Element::FromNodeOrNull(GetContent())) { + element->ClearContentRelevancy(); + } + + // TODO(mrobinson): Once bug 1765615 is fixed, this should be called on + // layout changes. In addition, when `content-visibility: auto` is implemented + // this should also be called when scrolling or focus causes content to be + // skipped or unskipped. + UpdateAnimationVisibility(); + + HandleLastRememberedSize(); +} + +void nsIFrame::Destroy(DestroyContext& aContext) { + NS_ASSERTION(!nsContentUtils::IsSafeToRunScript(), + "destroy called on frame while scripts not blocked"); + NS_ASSERTION(!GetNextSibling() && !GetPrevSibling(), + "Frames should be removed before destruction."); + MOZ_ASSERT(!HasAbsolutelyPositionedChildren()); + MOZ_ASSERT(!HasAnyStateBits(NS_FRAME_PART_OF_IBSPLIT), + "NS_FRAME_PART_OF_IBSPLIT set on non-nsContainerFrame?"); + + MaybeScheduleReflowSVGNonDisplayText(this); + + SVGObserverUtils::InvalidateDirectRenderingObservers(this); + + const auto* disp = StyleDisplay(); + if (disp->mPosition == StylePositionProperty::Sticky) { + if (auto* ssc = + StickyScrollContainer::GetStickyScrollContainerForFrame(this)) { + ssc->RemoveFrame(this); + } + } + + if (disp->mContainerType != StyleContainerType::Normal) { + PresContext()->UnregisterContainerQueryFrame(this); + } + + nsPresContext* presContext = PresContext(); + mozilla::PresShell* presShell = presContext->GetPresShell(); + if (HasAnyStateBits(NS_FRAME_OUT_OF_FLOW)) { + if (nsPlaceholderFrame* placeholder = GetPlaceholderFrame()) { + placeholder->SetOutOfFlowFrame(nullptr); + } + } + + if (IsPrimaryFrame()) { + // This needs to happen before we clear our Properties() table. + ActiveLayerTracker::TransferActivityToContent(this, mContent); + } + + ScrollAnchorContainer* anchor = nullptr; + if (IsScrollAnchor(&anchor)) { + anchor->InvalidateAnchor(); + } + + if (HasCSSAnimations() || HasCSSTransitions() || + // It's fine to look up the style frame here since if we're destroying the + // frames for display:table content we should be destroying both wrapper + // and inner frame. + EffectSet::GetForStyleFrame(this)) { + // If no new frame for this element is created by the end of the + // restyling process, stop animations and transitions for this frame + RestyleManager::AnimationsWithDestroyedFrame* adf = + presContext->RestyleManager()->GetAnimationsWithDestroyedFrame(); + // AnimationsWithDestroyedFrame only lives during the restyling process. + if (adf) { + adf->Put(mContent, mComputedStyle); + } + } + + if (StyleDisplay()->ContentVisibility(*this) == + StyleContentVisibility::Auto) { + if (auto* element = Element::FromNodeOrNull(GetContent())) { + PresContext()->Document()->UnobserveForContentVisibility(*element); + } + } + + // Disable visibility tracking. Note that we have to do this before we clear + // frame properties and lose track of whether we were previously visible. + // XXX(seth): It'd be ideal to assert that we're already marked nonvisible + // here, but it's unfortunately tricky to guarantee in the face of things like + // frame reconstruction induced by style changes. + DisableVisibilityTracking(); + + // Ensure that we're not in the approximately visible list anymore. + PresContext()->GetPresShell()->RemoveFrameFromApproximatelyVisibleList(this); + + presShell->NotifyDestroyingFrame(this); + + if (HasAnyStateBits(NS_FRAME_EXTERNAL_REFERENCE)) { + presShell->ClearFrameRefs(this); + } + + nsView* view = GetView(); + if (view) { + view->SetFrame(nullptr); + view->Destroy(); + } + + // Make sure that our deleted frame can't be returned from GetPrimaryFrame() + if (IsPrimaryFrame()) { + mContent->SetPrimaryFrame(nullptr); + + // Pass the root of a generated content subtree (e.g. ::after/::before) to + // aPostDestroyData to unbind it after frame destruction is done. + if (HasAnyStateBits(NS_FRAME_GENERATED_CONTENT) && + mContent->IsRootOfNativeAnonymousSubtree()) { + aContext.AddAnonymousContent(mContent.forget()); + } + } + + // Remove all properties attached to the frame, to ensure any property + // destructors that need the frame pointer are handled properly. + RemoveAllProperties(); + + // Must retrieve the object ID before calling destructors, so the + // vtable is still valid. + // + // Note to future tweakers: having the method that returns the + // object size call the destructor will not avoid an indirect call; + // the compiler cannot devirtualize the call to the destructor even + // if it's from a method defined in the same class. + + nsQueryFrame::FrameIID id = GetFrameId(); + this->~nsIFrame(); + +#ifdef DEBUG + { + nsIFrame* rootFrame = presShell->GetRootFrame(); + MOZ_ASSERT(rootFrame); + if (this != rootFrame) { + auto* builder = nsLayoutUtils::GetRetainedDisplayListBuilder(rootFrame); + auto* data = builder ? builder->Data() : nullptr; + + const bool inData = + data && (data->IsModified(this) || data->HasProps(this)); + + if (inData) { + DL_LOG(LogLevel::Warning, "Frame %p found in retained data", this); + } + + MOZ_ASSERT(!inData, "Deleted frame in retained data!"); + } + } +#endif + + // Now that we're totally cleaned out, we need to add ourselves to + // the presshell's recycler. + presShell->FreeFrame(id, this); +} + +std::pair<int32_t, int32_t> nsIFrame::GetOffsets() const { + return std::make_pair(0, 0); +} + +static void CompareLayers( + const nsStyleImageLayers* aFirstLayers, + const nsStyleImageLayers* aSecondLayers, + const std::function<void(imgRequestProxy* aReq)>& aCallback) { + NS_FOR_VISIBLE_IMAGE_LAYERS_BACK_TO_FRONT(i, (*aFirstLayers)) { + const auto& image = aFirstLayers->mLayers[i].mImage; + if (!image.IsImageRequestType() || !image.IsResolved()) { + continue; + } + + // aCallback is called when the style image in aFirstLayers is thought to + // be different with the corresponded one in aSecondLayers + if (!aSecondLayers || i >= aSecondLayers->mImageCount || + (!aSecondLayers->mLayers[i].mImage.IsResolved() || + image.GetImageRequest() != + aSecondLayers->mLayers[i].mImage.GetImageRequest())) { + if (imgRequestProxy* req = image.GetImageRequest()) { + aCallback(req); + } + } + } +} + +static void AddAndRemoveImageAssociations( + ImageLoader& aImageLoader, nsIFrame* aFrame, + const nsStyleImageLayers* aOldLayers, + const nsStyleImageLayers* aNewLayers) { + // If the old context had a background-image image, or mask-image image, + // and new context does not have the same image, clear the image load + // notifier (which keeps the image loading, if it still is) for the frame. + // We want to do this conservatively because some frames paint their + // backgrounds from some other frame's style data, and we don't want + // to clear those notifiers unless we have to. (They'll be reset + // when we paint, although we could miss a notification in that + // interval.) + if (aOldLayers && aFrame->HasImageRequest()) { + CompareLayers(aOldLayers, aNewLayers, [&](imgRequestProxy* aReq) { + aImageLoader.DisassociateRequestFromFrame(aReq, aFrame); + }); + } + + CompareLayers(aNewLayers, aOldLayers, [&](imgRequestProxy* aReq) { + aImageLoader.AssociateRequestToFrame(aReq, aFrame); + }); +} + +void nsIFrame::AddDisplayItem(nsDisplayItem* aItem) { + MOZ_DIAGNOSTIC_ASSERT(!mDisplayItems.Contains(aItem)); + mDisplayItems.AppendElement(aItem); +} + +bool nsIFrame::RemoveDisplayItem(nsDisplayItem* aItem) { + return mDisplayItems.RemoveElement(aItem); +} + +bool nsIFrame::HasDisplayItems() { return !mDisplayItems.IsEmpty(); } + +bool nsIFrame::HasDisplayItem(nsDisplayItem* aItem) { + return mDisplayItems.Contains(aItem); +} + +bool nsIFrame::HasDisplayItem(uint32_t aKey) { + for (nsDisplayItem* i : mDisplayItems) { + if (i->GetPerFrameKey() == aKey) { + return true; + } + } + return false; +} + +template <typename Condition> +static void DiscardDisplayItems(nsIFrame* aFrame, Condition aCondition) { + for (nsDisplayItem* i : aFrame->DisplayItems()) { + // Only discard items that are invalidated by this frame, as we're only + // guaranteed to rebuild those items. Table background items are created by + // the relevant table part, but have the cell frame as the primary frame, + // and we don't want to remove them if this is the cell. + if (aCondition(i) && i->FrameForInvalidation() == aFrame) { + i->SetCantBeReused(); + } + } +} + +static void DiscardOldItems(nsIFrame* aFrame) { + DiscardDisplayItems(aFrame, + [](nsDisplayItem* aItem) { return aItem->IsOldItem(); }); +} + +void nsIFrame::RemoveDisplayItemDataForDeletion() { + // Destroying a WebRenderUserDataTable can cause destruction of other objects + // which can remove frame properties in their destructor. If we delete a frame + // property it runs the destructor of the stored object in the middle of + // updating the frame property table, so if the destruction of that object + // causes another update to the frame property table it would leave the frame + // property table in an inconsistent state. So we remove it from the table and + // then destroy it. (bug 1530657) + WebRenderUserDataTable* userDataTable = + TakeProperty(WebRenderUserDataProperty::Key()); + if (userDataTable) { + for (const auto& data : userDataTable->Values()) { + data->RemoveFromTable(); + } + delete userDataTable; + } + + if (!nsLayoutUtils::AreRetainedDisplayListsEnabled()) { + // Retained display lists are disabled, no need to update + // RetainedDisplayListData. + return; + } + + auto* builder = nsLayoutUtils::GetRetainedDisplayListBuilder(this); + if (!builder) { + MOZ_ASSERT(DisplayItems().IsEmpty()); + MOZ_ASSERT(!IsFrameModified()); + return; + } + + for (nsDisplayItem* i : DisplayItems()) { + if (i->GetDependentFrame() == this && !i->HasDeletedFrame()) { + i->Frame()->MarkNeedsDisplayItemRebuild(); + } + i->RemoveFrame(this); + } + + DisplayItems().Clear(); + + nsAutoString name; +#ifdef DEBUG_FRAME_DUMP + if (DL_LOG_TEST(LogLevel::Debug)) { + GetFrameName(name); + } +#endif + DL_LOGV("Removing display item data for frame %p (%s)", this, + NS_ConvertUTF16toUTF8(name).get()); + + auto* data = builder->Data(); + if (MayHaveWillChangeBudget()) { + // Keep the frame in list, so it can be removed from the will-change budget. + data->Flags(this) = RetainedDisplayListData::FrameFlag::HadWillChange; + } else { + data->Remove(this); + } +} + +void nsIFrame::MarkNeedsDisplayItemRebuild() { + if (!nsLayoutUtils::AreRetainedDisplayListsEnabled() || IsFrameModified() || + HasAnyStateBits(NS_FRAME_IN_POPUP)) { + // Skip frames that are already marked modified. + return; + } + + if (Type() == LayoutFrameType::Placeholder) { + nsIFrame* oof = static_cast<nsPlaceholderFrame*>(this)->GetOutOfFlowFrame(); + if (oof) { + oof->MarkNeedsDisplayItemRebuild(); + } + // Do not mark placeholder frames modified. + return; + } + + nsIFrame* rootFrame = PresShell()->GetRootFrame(); + + if (rootFrame->IsFrameModified()) { + // The whole frame tree is modified. + return; + } + + auto* builder = nsLayoutUtils::GetRetainedDisplayListBuilder(this); + if (!builder) { + MOZ_ASSERT(DisplayItems().IsEmpty()); + return; + } + + RetainedDisplayListData* data = builder->Data(); + MOZ_ASSERT(data); + + if (data->AtModifiedFrameLimit()) { + // This marks the whole frame tree modified. + // See |RetainedDisplayListBuilder::ShouldBuildPartial()|. + data->AddModifiedFrame(rootFrame); + return; + } + + nsAutoString name; +#ifdef DEBUG_FRAME_DUMP + if (DL_LOG_TEST(LogLevel::Debug)) { + GetFrameName(name); + } +#endif + + DL_LOGV("RDL - Rebuilding display items for frame %p (%s)", this, + NS_ConvertUTF16toUTF8(name).get()); + + data->AddModifiedFrame(this); + + MOZ_ASSERT( + PresContext()->LayoutPhaseCount(nsLayoutPhase::DisplayListBuilding) == 0); + + // Hopefully this is cheap, but we could use a frame state bit to note + // the presence of dependencies to speed it up. + for (nsDisplayItem* i : DisplayItems()) { + if (i->HasDeletedFrame() || i->Frame() == this) { + // Ignore the items with deleted frames, and the items with |this| as + // the primary frame. + continue; + } + + if (i->GetDependentFrame() == this) { + // For items with |this| as a dependent frame, mark the primary frame + // for rebuild. + i->Frame()->MarkNeedsDisplayItemRebuild(); + } + } +} + +// Subclass hook for style post processing +/* virtual */ +void nsIFrame::DidSetComputedStyle(ComputedStyle* aOldComputedStyle) { +#ifdef ACCESSIBILITY + // Don't notify for reconstructed frames here, since the frame is still being + // constructed at this point and so LocalAccessible::GetFrame() will return + // null. Style changes for reconstructed frames are handled in + // DocAccessible::PruneOrInsertSubtree. + if (aOldComputedStyle) { + if (nsAccessibilityService* accService = GetAccService()) { + accService->NotifyOfComputedStyleChange(PresShell(), mContent); + } + } +#endif + + MaybeScheduleReflowSVGNonDisplayText(this); + + Document* doc = PresContext()->Document(); + ImageLoader* loader = doc->StyleImageLoader(); + // Continuing text frame doesn't initialize its continuation pointer before + // reaching here for the first time, so we have to exclude text frames. This + // doesn't affect correctness because text can't match selectors. + // + // FIXME(emilio): We should consider fixing that. + // + // TODO(emilio): Can we avoid doing some / all of the image stuff when + // isNonTextFirstContinuation is false? We should consider doing this just for + // primary frames and pseudos, but the first-line reparenting code makes it + // all bad, should get around to bug 1465474 eventually :( + const bool isNonText = !IsTextFrame(); + if (isNonText) { + mComputedStyle->StartImageLoads(*doc, aOldComputedStyle); + } + + const nsStyleImageLayers* oldLayers = + aOldComputedStyle ? &aOldComputedStyle->StyleBackground()->mImage + : nullptr; + const nsStyleImageLayers* newLayers = &StyleBackground()->mImage; + AddAndRemoveImageAssociations(*loader, this, oldLayers, newLayers); + + oldLayers = + aOldComputedStyle ? &aOldComputedStyle->StyleSVGReset()->mMask : nullptr; + newLayers = &StyleSVGReset()->mMask; + AddAndRemoveImageAssociations(*loader, this, oldLayers, newLayers); + + const nsStyleDisplay* disp = StyleDisplay(); + bool handleStickyChange = false; + if (aOldComputedStyle) { + // Detect style changes that should trigger a scroll anchor adjustment + // suppression. + // https://drafts.csswg.org/css-scroll-anchoring/#suppression-triggers + bool needAnchorSuppression = false; + + // If we detect a change on margin, padding or border, we store the old + // values on the frame itself between now and reflow, so if someone + // calls GetUsed(Margin|Border|Padding)() before the next reflow, we + // can give an accurate answer. + // We don't want to set the property if one already exists. + nsMargin oldValue(0, 0, 0, 0); + nsMargin newValue(0, 0, 0, 0); + const nsStyleMargin* oldMargin = aOldComputedStyle->StyleMargin(); + if (oldMargin->GetMargin(oldValue)) { + if (!StyleMargin()->GetMargin(newValue) || oldValue != newValue) { + if (!HasProperty(UsedMarginProperty())) { + AddProperty(UsedMarginProperty(), new nsMargin(oldValue)); + } + needAnchorSuppression = true; + } + } + + const nsStylePadding* oldPadding = aOldComputedStyle->StylePadding(); + if (oldPadding->GetPadding(oldValue)) { + if (!StylePadding()->GetPadding(newValue) || oldValue != newValue) { + if (!HasProperty(UsedPaddingProperty())) { + AddProperty(UsedPaddingProperty(), new nsMargin(oldValue)); + } + needAnchorSuppression = true; + } + } + + const nsStyleBorder* oldBorder = aOldComputedStyle->StyleBorder(); + oldValue = oldBorder->GetComputedBorder(); + newValue = StyleBorder()->GetComputedBorder(); + if (oldValue != newValue && !HasProperty(UsedBorderProperty())) { + AddProperty(UsedBorderProperty(), new nsMargin(oldValue)); + } + + const nsStyleDisplay* oldDisp = aOldComputedStyle->StyleDisplay(); + if (oldDisp->mOverflowAnchor != disp->mOverflowAnchor) { + if (auto* container = ScrollAnchorContainer::FindFor(this)) { + container->InvalidateAnchor(); + } + if (nsIScrollableFrame* scrollableFrame = do_QueryFrame(this)) { + scrollableFrame->Anchor()->InvalidateAnchor(); + } + } + + if (mInScrollAnchorChain) { + const nsStylePosition* pos = StylePosition(); + const nsStylePosition* oldPos = aOldComputedStyle->StylePosition(); + if (!needAnchorSuppression && + (oldPos->mOffset != pos->mOffset || oldPos->mWidth != pos->mWidth || + oldPos->mMinWidth != pos->mMinWidth || + oldPos->mMaxWidth != pos->mMaxWidth || + oldPos->mHeight != pos->mHeight || + oldPos->mMinHeight != pos->mMinHeight || + oldPos->mMaxHeight != pos->mMaxHeight || + oldDisp->mPosition != disp->mPosition || + oldDisp->mTransform != disp->mTransform)) { + needAnchorSuppression = true; + } + + if (needAnchorSuppression && + StaticPrefs::layout_css_scroll_anchoring_suppressions_enabled()) { + ScrollAnchorContainer::FindFor(this)->SuppressAdjustments(); + } + } + + if (disp->mPosition != oldDisp->mPosition) { + if (!disp->IsRelativelyOrStickyPositionedStyle() && + oldDisp->IsRelativelyOrStickyPositionedStyle()) { + RemoveProperty(NormalPositionProperty()); + } + + handleStickyChange = disp->mPosition == StylePositionProperty::Sticky || + oldDisp->mPosition == StylePositionProperty::Sticky; + } + if (disp->mScrollSnapAlign != oldDisp->mScrollSnapAlign) { + ScrollSnapUtils::PostPendingResnapFor(this); + } + if (aOldComputedStyle->IsRootElementStyle() && + disp->mScrollSnapType != oldDisp->mScrollSnapType) { + if (nsIScrollableFrame* scrollableFrame = + PresShell()->GetRootScrollFrameAsScrollable()) { + scrollableFrame->PostPendingResnap(); + } + } + if (StyleUIReset()->mMozSubtreeHiddenOnlyVisually && + !aOldComputedStyle->StyleUIReset()->mMozSubtreeHiddenOnlyVisually) { + PresShell::ClearMouseCapture(this); + } + } else { // !aOldComputedStyle + handleStickyChange = disp->mPosition == StylePositionProperty::Sticky; + } + + if (handleStickyChange && !HasAnyStateBits(NS_FRAME_IS_NONDISPLAY) && + !GetPrevInFlow()) { + // Note that we only add first continuations, but we really only + // want to add first continuation-or-ib-split-siblings. But since we don't + // yet know if we're a later part of a block-in-inline split, we'll just + // add later members of a block-in-inline split here, and then + // StickyScrollContainer will remove them later. + if (auto* ssc = + StickyScrollContainer::GetStickyScrollContainerForFrame(this)) { + if (disp->mPosition == StylePositionProperty::Sticky) { + ssc->AddFrame(this); + } else { + ssc->RemoveFrame(this); + } + } + } + + imgIRequest* oldBorderImage = + aOldComputedStyle + ? aOldComputedStyle->StyleBorder()->GetBorderImageRequest() + : nullptr; + imgIRequest* newBorderImage = StyleBorder()->GetBorderImageRequest(); + // FIXME (Bug 759996): The following is no longer true. + // For border-images, we can't be as conservative (we need to set the + // new loaders if there has been any change) since the CalcDifference + // call depended on the result of GetComputedBorder() and that result + // depends on whether the image has loaded, start the image load now + // so that we'll get notified when it completes loading and can do a + // restyle. Otherwise, the image might finish loading from the + // network before we start listening to its notifications, and then + // we'll never know that it's finished loading. Likewise, we want to + // do this for freshly-created frames to prevent a similar race if the + // image loads between reflow (which can depend on whether the image + // is loaded) and paint. We also don't really care about any callers who try + // to paint borders with a different style, because they won't have the + // correct size for the border either. + if (oldBorderImage != newBorderImage) { + // stop and restart the image loading/notification + if (oldBorderImage && HasImageRequest()) { + loader->DisassociateRequestFromFrame(oldBorderImage, this); + } + if (newBorderImage) { + loader->AssociateRequestToFrame(newBorderImage, this); + } + } + + auto GetShapeImageRequest = [](const ComputedStyle* aStyle) -> imgIRequest* { + if (!aStyle) { + return nullptr; + } + auto& shape = aStyle->StyleDisplay()->mShapeOutside; + if (!shape.IsImage()) { + return nullptr; + } + return shape.AsImage().GetImageRequest(); + }; + + imgIRequest* oldShapeImage = GetShapeImageRequest(aOldComputedStyle); + imgIRequest* newShapeImage = GetShapeImageRequest(Style()); + if (oldShapeImage != newShapeImage) { + if (oldShapeImage && HasImageRequest()) { + loader->DisassociateRequestFromFrame(oldShapeImage, this); + } + if (newShapeImage) { + loader->AssociateRequestToFrame( + newShapeImage, this, + ImageLoader::Flags:: + RequiresReflowOnFirstFrameCompleteAndLoadEventBlocking); + } + } + + // SVGObserverUtils::GetEffectProperties() asserts that we only invoke it with + // the first continuation so we need to check that in advance. + const bool isNonTextFirstContinuation = isNonText && !GetPrevContinuation(); + if (isNonTextFirstContinuation) { + // Kick off loading of external SVG resources referenced from properties if + // any. This currently includes filter, clip-path, and mask. + SVGObserverUtils::InitiateResourceDocLoads(this); + } + + // If the page contains markup that overrides text direction, and + // does not contain any characters that would activate the Unicode + // bidi algorithm, we need to call |SetBidiEnabled| on the pres + // context before reflow starts. See bug 115921. + if (StyleVisibility()->mDirection == StyleDirection::Rtl) { + PresContext()->SetBidiEnabled(); + } + + // The following part is for caching offset-path:path(). We cache the + // flatten gfx path, so we don't have to rebuild and re-flattern it at + // each cycle if we have animations on offset-* with a fixed offset-path. + const StyleOffsetPath* oldPath = + aOldComputedStyle ? &aOldComputedStyle->StyleDisplay()->mOffsetPath + : nullptr; + const StyleOffsetPath& newPath = StyleDisplay()->mOffsetPath; + if (!oldPath || *oldPath != newPath) { + if (newPath.IsPath()) { + // Here we only need to build a valid path for motion path, so + // using the default values of stroke-width, stoke-linecap, and fill-rule + // is fine for now because what we want is to get the point and its normal + // vector along the path, instead of rendering it. + RefPtr<gfx::PathBuilder> builder = + gfxPlatform::GetPlatform() + ->ScreenReferenceDrawTarget() + ->CreatePathBuilder(gfx::FillRule::FILL_WINDING); + RefPtr<gfx::Path> path = + MotionPathUtils::BuildPath(newPath.AsPath(), builder); + if (path) { + // The newPath could be path('') (i.e. empty path), so its gfx path + // could be nullptr, and so we only set property for a non-empty path. + SetProperty(nsIFrame::OffsetPathCache(), path.forget().take()); + } else { + // May have an old cached path, so we have to delete it. + RemoveProperty(nsIFrame::OffsetPathCache()); + } + } else if (oldPath) { + RemoveProperty(nsIFrame::OffsetPathCache()); + } + } + + if (IsPrimaryFrame()) { + HandleLastRememberedSize(); + } + + RemoveStateBits(NS_FRAME_SIMPLE_EVENT_REGIONS | NS_FRAME_SIMPLE_DISPLAYLIST); + + mMayHaveRoundedCorners = true; +} + +void nsIFrame::HandleLastRememberedSize() { + MOZ_ASSERT(IsPrimaryFrame()); + // Storing a last remembered size requires contain-intrinsic-size, and using + // a previously stored last remembered size requires content-visibility. + if (!StaticPrefs::layout_css_contain_intrinsic_size_enabled() || + !StaticPrefs::layout_css_content_visibility_enabled()) { + return; + } + auto* element = Element::FromNodeOrNull(mContent); + if (!element) { + return; + } + const WritingMode wm = GetWritingMode(); + const nsStylePosition* stylePos = StylePosition(); + bool canRememberBSize = stylePos->ContainIntrinsicBSize(wm).IsAutoLength(); + bool canRememberISize = stylePos->ContainIntrinsicISize(wm).IsAutoLength(); + if (!canRememberBSize) { + element->RemoveLastRememberedBSize(); + } + if (!canRememberISize) { + element->RemoveLastRememberedISize(); + } + if ((canRememberBSize || canRememberISize) && !HidesContent()) { + bool isNonReplacedInline = IsFrameOfType(nsIFrame::eLineParticipant) && + !IsFrameOfType(nsIFrame::eReplaced); + if (!isNonReplacedInline) { + PresContext()->Document()->ObserveForLastRememberedSize(*element); + return; + } + } + PresContext()->Document()->UnobserveForLastRememberedSize(*element); +} + +#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED +void nsIFrame::AssertNewStyleIsSane(ComputedStyle& aNewStyle) { + MOZ_DIAGNOSTIC_ASSERT( + aNewStyle.GetPseudoType() == mComputedStyle->GetPseudoType() || + // ::first-line continuations are weird, this should probably be fixed via + // bug 1465474. + (mComputedStyle->GetPseudoType() == PseudoStyleType::firstLine && + aNewStyle.GetPseudoType() == PseudoStyleType::mozLineFrame) || + // ::first-letter continuations are broken, in particular floating ones, + // see bug 1490281. The construction code tries to fix this up after the + // fact, then restyling undoes it... + (mComputedStyle->GetPseudoType() == PseudoStyleType::mozText && + aNewStyle.GetPseudoType() == PseudoStyleType::firstLetterContinuation) || + (mComputedStyle->GetPseudoType() == + PseudoStyleType::firstLetterContinuation && + aNewStyle.GetPseudoType() == PseudoStyleType::mozText)); +} +#endif + +void nsIFrame::ReparentFrameViewTo(nsViewManager* aViewManager, + nsView* aNewParentView) { + if (HasView()) { + if (IsMenuPopupFrame()) { + // This view must be parented by the root view, don't reparent it. + return; + } + nsView* view = GetView(); + aViewManager->RemoveChild(view); + + // The view will remember the Z-order and other attributes that have been + // set on it. + nsView* insertBefore = + nsLayoutUtils::FindSiblingViewFor(aNewParentView, this); + aViewManager->InsertChild(aNewParentView, view, insertBefore, + insertBefore != nullptr); + } else if (HasAnyStateBits(NS_FRAME_HAS_CHILD_WITH_VIEW)) { + for (const auto& childList : ChildLists()) { + // Iterate the child frames, and check each child frame to see if it has + // a view + for (nsIFrame* child : childList.mList) { + child->ReparentFrameViewTo(aViewManager, aNewParentView); + } + } + } +} + +void nsIFrame::SyncFrameViewProperties(nsView* aView) { + if (!aView) { + aView = GetView(); + if (!aView) { + return; + } + } + + nsViewManager* vm = aView->GetViewManager(); + + // Make sure visibility is correct. This only affects nsSubDocumentFrame. + if (!SupportsVisibilityHidden()) { + // See if the view should be hidden or visible + ComputedStyle* sc = Style(); + vm->SetViewVisibility(aView, sc->StyleVisibility()->IsVisible() + ? ViewVisibility::Show + : ViewVisibility::Hide); + } + + const auto zIndex = ZIndex(); + const bool autoZIndex = !zIndex; + vm->SetViewZIndex(aView, autoZIndex, zIndex.valueOr(0)); +} + +void nsIFrame::CreateView() { + MOZ_ASSERT(!HasView()); + + nsView* parentView = GetParent()->GetClosestView(); + MOZ_ASSERT(parentView, "no parent with view"); + + nsViewManager* viewManager = parentView->GetViewManager(); + MOZ_ASSERT(viewManager, "null view manager"); + + nsView* view = viewManager->CreateView(GetRect(), parentView); + SyncFrameViewProperties(view); + + nsView* insertBefore = nsLayoutUtils::FindSiblingViewFor(parentView, this); + // we insert this view 'above' the insertBefore view, unless insertBefore is + // null, in which case we want to call with aAbove == false to insert at the + // beginning in document order + viewManager->InsertChild(parentView, view, insertBefore, + insertBefore != nullptr); + + // REVIEW: Don't create a widget for fixed-pos elements anymore. + // ComputeRepaintRegionForCopy will calculate the right area to repaint + // when we scroll. + // Reparent views on any child frames (or their descendants) to this + // view. We can just call ReparentFrameViewTo on this frame because + // we know this frame has no view, so it will crawl the children. Also, + // we know that any descendants with views must have 'parentView' as their + // parent view. + ReparentFrameViewTo(viewManager, view); + + // Remember our view + SetView(view); + + NS_FRAME_LOG(NS_FRAME_TRACE_CALLS, + ("nsIFrame::CreateView: frame=%p view=%p", this, view)); +} + +/* virtual */ +nsMargin nsIFrame::GetUsedMargin() const { + nsMargin margin(0, 0, 0, 0); + if (((mState & NS_FRAME_FIRST_REFLOW) && !(mState & NS_FRAME_IN_REFLOW)) || + IsInSVGTextSubtree()) + return margin; + + nsMargin* m = GetProperty(UsedMarginProperty()); + if (m) { + margin = *m; + } else { + if (!StyleMargin()->GetMargin(margin)) { + // If we get here, our caller probably shouldn't be calling us... + NS_ERROR( + "Returning bogus 0-sized margin, because this margin " + "depends on layout & isn't cached!"); + } + } + return margin; +} + +/* virtual */ +nsMargin nsIFrame::GetUsedBorder() const { + nsMargin border(0, 0, 0, 0); + if (((mState & NS_FRAME_FIRST_REFLOW) && !(mState & NS_FRAME_IN_REFLOW)) || + IsInSVGTextSubtree()) + return border; + + // Theme methods don't use const-ness. + nsIFrame* mutable_this = const_cast<nsIFrame*>(this); + + const nsStyleDisplay* disp = StyleDisplay(); + if (mutable_this->IsThemed(disp)) { + nsPresContext* pc = PresContext(); + LayoutDeviceIntMargin widgetBorder = pc->Theme()->GetWidgetBorder( + pc->DeviceContext(), mutable_this, disp->EffectiveAppearance()); + border = + LayoutDevicePixel::ToAppUnits(widgetBorder, pc->AppUnitsPerDevPixel()); + return border; + } + + nsMargin* b = GetProperty(UsedBorderProperty()); + if (b) { + border = *b; + } else { + border = StyleBorder()->GetComputedBorder(); + } + return border; +} + +/* virtual */ +nsMargin nsIFrame::GetUsedPadding() const { + nsMargin padding(0, 0, 0, 0); + if (((mState & NS_FRAME_FIRST_REFLOW) && !(mState & NS_FRAME_IN_REFLOW)) || + IsInSVGTextSubtree()) + return padding; + + // Theme methods don't use const-ness. + nsIFrame* mutable_this = const_cast<nsIFrame*>(this); + + const nsStyleDisplay* disp = StyleDisplay(); + if (mutable_this->IsThemed(disp)) { + nsPresContext* pc = PresContext(); + LayoutDeviceIntMargin widgetPadding; + if (pc->Theme()->GetWidgetPadding(pc->DeviceContext(), mutable_this, + disp->EffectiveAppearance(), + &widgetPadding)) { + return LayoutDevicePixel::ToAppUnits(widgetPadding, + pc->AppUnitsPerDevPixel()); + } + } + + nsMargin* p = GetProperty(UsedPaddingProperty()); + if (p) { + padding = *p; + } else { + if (!StylePadding()->GetPadding(padding)) { + // If we get here, our caller probably shouldn't be calling us... + NS_ERROR( + "Returning bogus 0-sized padding, because this padding " + "depends on layout & isn't cached!"); + } + } + return padding; +} + +nsIFrame::Sides nsIFrame::GetSkipSides() const { + if (MOZ_UNLIKELY(StyleBorder()->mBoxDecorationBreak == + StyleBoxDecorationBreak::Clone) && + !HasAnyStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER)) { + return Sides(); + } + + // Convert the logical skip sides to physical sides using the frame's + // writing mode + WritingMode writingMode = GetWritingMode(); + LogicalSides logicalSkip = GetLogicalSkipSides(); + Sides skip; + + if (logicalSkip.BStart()) { + if (writingMode.IsVertical()) { + skip |= writingMode.IsVerticalLR() ? SideBits::eLeft : SideBits::eRight; + } else { + skip |= SideBits::eTop; + } + } + + if (logicalSkip.BEnd()) { + if (writingMode.IsVertical()) { + skip |= writingMode.IsVerticalLR() ? SideBits::eRight : SideBits::eLeft; + } else { + skip |= SideBits::eBottom; + } + } + + if (logicalSkip.IStart()) { + if (writingMode.IsVertical()) { + skip |= SideBits::eTop; + } else { + skip |= writingMode.IsBidiLTR() ? SideBits::eLeft : SideBits::eRight; + } + } + + if (logicalSkip.IEnd()) { + if (writingMode.IsVertical()) { + skip |= SideBits::eBottom; + } else { + skip |= writingMode.IsBidiLTR() ? SideBits::eRight : SideBits::eLeft; + } + } + return skip; +} + +nsRect nsIFrame::GetPaddingRectRelativeToSelf() const { + nsMargin border = GetUsedBorder().ApplySkipSides(GetSkipSides()); + nsRect r(0, 0, mRect.width, mRect.height); + r.Deflate(border); + return r; +} + +nsRect nsIFrame::GetPaddingRect() const { + return GetPaddingRectRelativeToSelf() + GetPosition(); +} + +WritingMode nsIFrame::WritingModeForLine(WritingMode aSelfWM, + nsIFrame* aSubFrame) const { + MOZ_ASSERT(aSelfWM == GetWritingMode()); + WritingMode writingMode = aSelfWM; + + if (StyleTextReset()->mUnicodeBidi == StyleUnicodeBidi::Plaintext) { + mozilla::intl::BidiEmbeddingLevel frameLevel = + nsBidiPresUtils::GetFrameBaseLevel(aSubFrame); + writingMode.SetDirectionFromBidiLevel(frameLevel); + } + + return writingMode; +} + +nsRect nsIFrame::GetMarginRect() const { + return GetMarginRectRelativeToSelf() + GetPosition(); +} + +nsRect nsIFrame::GetMarginRectRelativeToSelf() const { + nsMargin m = GetUsedMargin().ApplySkipSides(GetSkipSides()); + nsRect r(0, 0, mRect.width, mRect.height); + r.Inflate(m); + return r; +} + +bool nsIFrame::IsTransformed() const { + if (!HasAnyStateBits(NS_FRAME_MAY_BE_TRANSFORMED)) { + MOZ_ASSERT(!IsCSSTransformed()); + MOZ_ASSERT(!IsSVGTransformed()); + return false; + } + return IsCSSTransformed() || IsSVGTransformed(); +} + +bool nsIFrame::IsCSSTransformed() const { + return HasAnyStateBits(NS_FRAME_MAY_BE_TRANSFORMED) && + (StyleDisplay()->HasTransform(this) || HasAnimationOfTransform()); +} + +bool nsIFrame::HasAnimationOfTransform() const { + return IsPrimaryFrame() && + nsLayoutUtils::HasAnimationOfTransformAndMotionPath(this) && + IsFrameOfType(eSupportsCSSTransforms); +} + +bool nsIFrame::ChildrenHavePerspective( + const nsStyleDisplay* aStyleDisplay) const { + MOZ_ASSERT(aStyleDisplay == StyleDisplay()); + return aStyleDisplay->HasPerspective(this); +} + +bool nsIFrame::HasAnimationOfOpacity(EffectSet* aEffectSet) const { + return ((nsLayoutUtils::IsPrimaryStyleFrame(this) || + nsLayoutUtils::FirstContinuationOrIBSplitSibling(this) + ->IsPrimaryFrame()) && + nsLayoutUtils::HasAnimationOfPropertySet( + this, nsCSSPropertyIDSet::OpacityProperties(), aEffectSet)); +} + +bool nsIFrame::HasOpacityInternal(float aThreshold, + const nsStyleDisplay* aStyleDisplay, + const nsStyleEffects* aStyleEffects, + EffectSet* aEffectSet) const { + MOZ_ASSERT(0.0 <= aThreshold && aThreshold <= 1.0, "Invalid argument"); + if (aStyleEffects->mOpacity < aThreshold || + aStyleDisplay->mWillChange.bits & StyleWillChangeBits::OPACITY) { + return true; + } + + if (!mMayHaveOpacityAnimation) { + return false; + } + + return HasAnimationOfOpacity(aEffectSet); +} + +bool nsIFrame::IsSVGTransformed(gfx::Matrix* aOwnTransforms, + gfx::Matrix* aFromParentTransforms) const { + return false; +} + +bool nsIFrame::Extend3DContext(const nsStyleDisplay* aStyleDisplay, + const nsStyleEffects* aStyleEffects, + mozilla::EffectSet* aEffectSetForOpacity) const { + if (!HasAnyStateBits(NS_FRAME_MAY_BE_TRANSFORMED)) { + return false; + } + const nsStyleDisplay* disp = StyleDisplayWithOptionalParam(aStyleDisplay); + if (disp->mTransformStyle != StyleTransformStyle::Preserve3d || + !IsFrameOfType(nsIFrame::eSupportsCSSTransforms)) { + return false; + } + + // If we're all scroll frame, then all descendants will be clipped, so we + // can't preserve 3d. + if (IsScrollFrame()) { + return false; + } + + const nsStyleEffects* effects = StyleEffectsWithOptionalParam(aStyleEffects); + if (HasOpacity(disp, effects, aEffectSetForOpacity)) { + return false; + } + + return ShouldApplyOverflowClipping(disp) == PhysicalAxes::None && + !GetClipPropClipRect(disp, effects, GetSize()) && + !SVGIntegrationUtils::UsingEffectsForFrame(this) && + !effects->HasMixBlendMode() && + disp->mIsolation != StyleIsolation::Isolate; +} + +bool nsIFrame::Combines3DTransformWithAncestors() const { + nsIFrame* parent = GetClosestFlattenedTreeAncestorPrimaryFrame(); + if (!parent || !parent->Extend3DContext()) { + return false; + } + return IsCSSTransformed() || BackfaceIsHidden(); +} + +bool nsIFrame::In3DContextAndBackfaceIsHidden() const { + // While both tests fail most of the time, test BackfaceIsHidden() + // first since it's likely to fail faster. + return BackfaceIsHidden() && Combines3DTransformWithAncestors(); +} + +bool nsIFrame::HasPerspective() const { + if (!IsCSSTransformed()) { + return false; + } + nsIFrame* parent = GetClosestFlattenedTreeAncestorPrimaryFrame(); + if (!parent) { + return false; + } + return parent->ChildrenHavePerspective(); +} + +nsRect nsIFrame::GetContentRectRelativeToSelf() const { + nsMargin bp = GetUsedBorderAndPadding().ApplySkipSides(GetSkipSides()); + nsRect r(0, 0, mRect.width, mRect.height); + r.Deflate(bp); + return r; +} + +nsRect nsIFrame::GetContentRect() const { + return GetContentRectRelativeToSelf() + GetPosition(); +} + +bool nsIFrame::ComputeBorderRadii(const BorderRadius& aBorderRadius, + const nsSize& aFrameSize, + const nsSize& aBorderArea, Sides aSkipSides, + nscoord aRadii[8]) { + // Percentages are relative to whichever side they're on. + for (const auto i : mozilla::AllPhysicalHalfCorners()) { + const LengthPercentage& c = aBorderRadius.Get(i); + nscoord axis = HalfCornerIsX(i) ? aFrameSize.width : aFrameSize.height; + aRadii[i] = std::max(0, c.Resolve(axis)); + } + + if (aSkipSides.Top()) { + aRadii[eCornerTopLeftX] = 0; + aRadii[eCornerTopLeftY] = 0; + aRadii[eCornerTopRightX] = 0; + aRadii[eCornerTopRightY] = 0; + } + + if (aSkipSides.Right()) { + aRadii[eCornerTopRightX] = 0; + aRadii[eCornerTopRightY] = 0; + aRadii[eCornerBottomRightX] = 0; + aRadii[eCornerBottomRightY] = 0; + } + + if (aSkipSides.Bottom()) { + aRadii[eCornerBottomRightX] = 0; + aRadii[eCornerBottomRightY] = 0; + aRadii[eCornerBottomLeftX] = 0; + aRadii[eCornerBottomLeftY] = 0; + } + + if (aSkipSides.Left()) { + aRadii[eCornerBottomLeftX] = 0; + aRadii[eCornerBottomLeftY] = 0; + aRadii[eCornerTopLeftX] = 0; + aRadii[eCornerTopLeftY] = 0; + } + + // css3-background specifies this algorithm for reducing + // corner radii when they are too big. + bool haveRadius = false; + double ratio = 1.0f; + for (const auto side : mozilla::AllPhysicalSides()) { + uint32_t hc1 = SideToHalfCorner(side, false, true); + uint32_t hc2 = SideToHalfCorner(side, true, true); + nscoord length = + SideIsVertical(side) ? aBorderArea.height : aBorderArea.width; + nscoord sum = aRadii[hc1] + aRadii[hc2]; + if (sum) { + haveRadius = true; + // avoid floating point division in the normal case + if (length < sum) { + ratio = std::min(ratio, double(length) / sum); + } + } + } + if (ratio < 1.0) { + for (const auto corner : mozilla::AllPhysicalHalfCorners()) { + aRadii[corner] *= ratio; + } + } + + return haveRadius; +} + +void nsIFrame::AdjustBorderRadii(nscoord aRadii[8], const nsMargin& aOffsets) { + auto AdjustOffset = [](const uint32_t aRadius, const nscoord aOffset) { + // Implement the cubic formula to adjust offset when aOffset > 0 and + // aRadius / aOffset < 1. + // https://drafts.csswg.org/css-shapes/#valdef-shape-box-margin-box + if (aOffset > 0) { + const double ratio = aRadius / double(aOffset); + if (ratio < 1.0) { + return nscoord(aOffset * (1.0 + std::pow(ratio - 1, 3))); + } + } + return aOffset; + }; + + for (const auto side : mozilla::AllPhysicalSides()) { + const nscoord offset = aOffsets.Side(side); + const uint32_t hc1 = SideToHalfCorner(side, false, false); + const uint32_t hc2 = SideToHalfCorner(side, true, false); + if (aRadii[hc1] > 0) { + const nscoord offset1 = AdjustOffset(aRadii[hc1], offset); + aRadii[hc1] = std::max(0, aRadii[hc1] + offset1); + } + if (aRadii[hc2] > 0) { + const nscoord offset2 = AdjustOffset(aRadii[hc2], offset); + aRadii[hc2] = std::max(0, aRadii[hc2] + offset2); + } + } +} + +static inline bool RadiiAreDefinitelyZero(const BorderRadius& aBorderRadius) { + for (const auto corner : mozilla::AllPhysicalHalfCorners()) { + if (!aBorderRadius.Get(corner).IsDefinitelyZero()) { + return false; + } + } + return true; +} + +/* virtual */ +bool nsIFrame::GetBorderRadii(const nsSize& aFrameSize, + const nsSize& aBorderArea, Sides aSkipSides, + nscoord aRadii[8]) const { + if (!mMayHaveRoundedCorners) { + memset(aRadii, 0, sizeof(nscoord) * 8); + return false; + } + + if (IsThemed()) { + // When we're themed, the native theme code draws the border and + // background, and therefore it doesn't make sense to tell other + // code that's interested in border-radius that we have any radii. + // + // In an ideal world, we might have a way for the them to tell us an + // border radius, but since we don't, we're better off assuming + // zero. + for (const auto corner : mozilla::AllPhysicalHalfCorners()) { + aRadii[corner] = 0; + } + return false; + } + + const auto& radii = StyleBorder()->mBorderRadius; + const bool hasRadii = + ComputeBorderRadii(radii, aFrameSize, aBorderArea, aSkipSides, aRadii); + if (!hasRadii) { + // TODO(emilio): Maybe we can just remove this bit and do the + // IsDefinitelyZero check unconditionally. That should still avoid most of + // the work, though maybe not the cache miss of going through the style and + // the border struct. + const_cast<nsIFrame*>(this)->mMayHaveRoundedCorners = + !RadiiAreDefinitelyZero(radii); + } + return hasRadii; +} + +bool nsIFrame::GetBorderRadii(nscoord aRadii[8]) const { + nsSize sz = GetSize(); + return GetBorderRadii(sz, sz, GetSkipSides(), aRadii); +} + +bool nsIFrame::GetMarginBoxBorderRadii(nscoord aRadii[8]) const { + return GetBoxBorderRadii(aRadii, GetUsedMargin()); +} + +bool nsIFrame::GetPaddingBoxBorderRadii(nscoord aRadii[8]) const { + return GetBoxBorderRadii(aRadii, -GetUsedBorder()); +} + +bool nsIFrame::GetContentBoxBorderRadii(nscoord aRadii[8]) const { + return GetBoxBorderRadii(aRadii, -GetUsedBorderAndPadding()); +} + +bool nsIFrame::GetBoxBorderRadii(nscoord aRadii[8], + const nsMargin& aOffsets) const { + if (!GetBorderRadii(aRadii)) { + return false; + } + AdjustBorderRadii(aRadii, aOffsets); + for (const auto corner : mozilla::AllPhysicalHalfCorners()) { + if (aRadii[corner]) { + return true; + } + } + return false; +} + +bool nsIFrame::GetShapeBoxBorderRadii(nscoord aRadii[8]) const { + using Tag = StyleShapeOutside::Tag; + auto& shapeOutside = StyleDisplay()->mShapeOutside; + auto box = StyleShapeBox::MarginBox; + switch (shapeOutside.tag) { + case Tag::Image: + case Tag::None: + return false; + case Tag::Box: + box = shapeOutside.AsBox(); + break; + case Tag::Shape: + box = shapeOutside.AsShape()._1; + break; + } + + switch (box) { + case StyleShapeBox::ContentBox: + return GetContentBoxBorderRadii(aRadii); + case StyleShapeBox::PaddingBox: + return GetPaddingBoxBorderRadii(aRadii); + case StyleShapeBox::BorderBox: + return GetBorderRadii(aRadii); + case StyleShapeBox::MarginBox: + return GetMarginBoxBorderRadii(aRadii); + default: + MOZ_ASSERT_UNREACHABLE("Unexpected box value"); + return false; + } +} + +ComputedStyle* nsIFrame::GetAdditionalComputedStyle(int32_t aIndex) const { + MOZ_ASSERT(aIndex >= 0, "invalid index number"); + return nullptr; +} + +void nsIFrame::SetAdditionalComputedStyle(int32_t aIndex, + ComputedStyle* aComputedStyle) { + MOZ_ASSERT(aIndex >= 0, "invalid index number"); +} + +nscoord nsIFrame::SynthesizeFallbackBaseline( + WritingMode aWM, BaselineSharingGroup aBaselineGroup) const { + const auto margin = GetLogicalUsedMargin(aWM); + NS_ASSERTION(!IsSubtreeDirty(), "frame must not be dirty"); + if (aWM.IsCentralBaseline()) { + return (BSize(aWM) + GetLogicalUsedMargin(aWM).BEnd(aWM)) / 2; + } + // Baseline for inverted line content is the top (block-start) margin edge, + // as the frame is in effect "flipped" for alignment purposes. + if (aWM.IsLineInverted()) { + const auto marginStart = margin.BStart(aWM); + return aBaselineGroup == BaselineSharingGroup::First + ? -marginStart + : BSize(aWM) + marginStart; + } + // Otherwise, the bottom margin edge, per CSS2.1's definition of the + // 'baseline' value of 'vertical-align'. + const auto marginEnd = margin.BEnd(aWM); + return aBaselineGroup == BaselineSharingGroup::First ? BSize(aWM) + marginEnd + : -marginEnd; +} + +nscoord nsIFrame::GetLogicalBaseline(WritingMode aWM) const { + return GetLogicalBaseline(aWM, GetDefaultBaselineSharingGroup(), + BaselineExportContext::LineLayout); +} + +nscoord nsIFrame::GetLogicalBaseline( + WritingMode aWM, BaselineSharingGroup aBaselineGroup, + BaselineExportContext aExportContext) const { + const auto result = + GetNaturalBaselineBOffset(aWM, aBaselineGroup, aExportContext) + .valueOrFrom([this, aWM, aBaselineGroup]() { + return SynthesizeFallbackBaseline(aWM, aBaselineGroup); + }); + if (aBaselineGroup == BaselineSharingGroup::Last) { + return BSize(aWM) - result; + } + return result; +} + +const nsFrameList& nsIFrame::GetChildList(ChildListID aListID) const { + if (IsAbsoluteContainer() && aListID == GetAbsoluteListID()) { + return GetAbsoluteContainingBlock()->GetChildList(); + } else { + return nsFrameList::EmptyList(); + } +} + +void nsIFrame::GetChildLists(nsTArray<ChildList>* aLists) const { + if (IsAbsoluteContainer()) { + const nsFrameList& absoluteList = + GetAbsoluteContainingBlock()->GetChildList(); + absoluteList.AppendIfNonempty(aLists, GetAbsoluteListID()); + } +} + +AutoTArray<nsIFrame::ChildList, 4> nsIFrame::CrossDocChildLists() { + AutoTArray<ChildList, 4> childLists; + nsSubDocumentFrame* subdocumentFrame = do_QueryFrame(this); + if (subdocumentFrame) { + // Descend into the subdocument + nsIFrame* root = subdocumentFrame->GetSubdocumentRootFrame(); + if (root) { + childLists.EmplaceBack( + nsFrameList(root, nsLayoutUtils::GetLastSibling(root)), + FrameChildListID::Principal); + } + } + + GetChildLists(&childLists); + return childLists; +} + +nsIFrame::CaretBlockAxisMetrics nsIFrame::GetCaretBlockAxisMetrics( + mozilla::WritingMode aWM, const nsFontMetrics& aFM) const { + // Note(dshin): Ultimately, this does something highly similar (But still + // different) to `nsLayoutUtils::GetFirstLinePosition`. + const auto baseline = GetCaretBaseline(); + nscoord ascent = 0, descent = 0; + ascent = aFM.MaxAscent(); + descent = aFM.MaxDescent(); + const nscoord height = ascent + descent; + if (aWM.IsVertical() && aWM.IsLineInverted()) { + return CaretBlockAxisMetrics{.mOffset = baseline - descent, + .mExtent = height}; + } + return CaretBlockAxisMetrics{.mOffset = baseline - ascent, .mExtent = height}; +} + +const nsAtom* nsIFrame::ComputePageValue() const { + const nsAtom* value = nsGkAtoms::_empty; + const nsIFrame* frame = this; + do { + // If this has a non-auto start value, track that instead. + if (const nsAtom* const startValue = frame->GetStartPageValue()) { + value = startValue; + } + MOZ_ASSERT(value, "Should not have a NULL page value."); + // Get the next frame to read from. + const nsIFrame* firstNonPlaceholderFrame = nullptr; + // If this is a container frame, inspect its in-flow children. + if (const nsContainerFrame* containerFrame = do_QueryFrame(frame)) { + for (const nsIFrame* childFrame : containerFrame->PrincipalChildList()) { + if (!childFrame->IsPlaceholderFrame()) { + firstNonPlaceholderFrame = childFrame; + break; + } + } + } + frame = firstNonPlaceholderFrame; + } while (frame); + return value; +} + +Visibility nsIFrame::GetVisibility() const { + if (!HasAnyStateBits(NS_FRAME_VISIBILITY_IS_TRACKED)) { + return Visibility::Untracked; + } + + bool isSet = false; + uint32_t visibleCount = GetProperty(VisibilityStateProperty(), &isSet); + + MOZ_ASSERT(isSet, + "Should have a VisibilityStateProperty value " + "if NS_FRAME_VISIBILITY_IS_TRACKED is set"); + + return visibleCount > 0 ? Visibility::ApproximatelyVisible + : Visibility::ApproximatelyNonVisible; +} + +void nsIFrame::UpdateVisibilitySynchronously() { + mozilla::PresShell* presShell = PresShell(); + if (!presShell) { + return; + } + + if (presShell->AssumeAllFramesVisible()) { + presShell->EnsureFrameInApproximatelyVisibleList(this); + return; + } + + bool visible = StyleVisibility()->IsVisible(); + nsIFrame* f = GetParent(); + nsRect rect = GetRectRelativeToSelf(); + nsIFrame* rectFrame = this; + while (f && visible) { + nsIScrollableFrame* sf = do_QueryFrame(f); + if (sf) { + nsRect transformedRect = + nsLayoutUtils::TransformFrameRectToAncestor(rectFrame, rect, f); + if (!sf->IsRectNearlyVisible(transformedRect)) { + visible = false; + break; + } + + // In this code we're trying to synchronously update *approximate* + // visibility. (In the future we may update precise visibility here as + // well, which is why the method name does not contain 'approximate'.) The + // IsRectNearlyVisible() check above tells us that the rect we're checking + // is approximately visible within the scrollframe, but we still need to + // ensure that, even if it was scrolled into view, it'd be visible when we + // consider the rest of the document. To do that, we move transformedRect + // to be contained in the scrollport as best we can (it might not fit) to + // pretend that it was scrolled into view. + rect = transformedRect.MoveInsideAndClamp(sf->GetScrollPortRect()); + rectFrame = f; + } + nsIFrame* parent = f->GetParent(); + if (!parent) { + parent = nsLayoutUtils::GetCrossDocParentFrameInProcess(f); + if (parent && parent->PresContext()->IsChrome()) { + break; + } + } + f = parent; + } + + if (visible) { + presShell->EnsureFrameInApproximatelyVisibleList(this); + } else { + presShell->RemoveFrameFromApproximatelyVisibleList(this); + } +} + +void nsIFrame::EnableVisibilityTracking() { + if (HasAnyStateBits(NS_FRAME_VISIBILITY_IS_TRACKED)) { + return; // Nothing to do. + } + + MOZ_ASSERT(!HasProperty(VisibilityStateProperty()), + "Shouldn't have a VisibilityStateProperty value " + "if NS_FRAME_VISIBILITY_IS_TRACKED is not set"); + + // Add the state bit so we know to track visibility for this frame, and + // initialize the frame property. + AddStateBits(NS_FRAME_VISIBILITY_IS_TRACKED); + SetProperty(VisibilityStateProperty(), 0); + + mozilla::PresShell* presShell = PresShell(); + if (!presShell) { + return; + } + + // Schedule a visibility update. This method will virtually always be called + // when layout has changed anyway, so it's very unlikely that any additional + // visibility updates will be triggered by this, but this way we guarantee + // that if this frame is currently visible we'll eventually find out. + presShell->ScheduleApproximateFrameVisibilityUpdateSoon(); +} + +void nsIFrame::DisableVisibilityTracking() { + if (!HasAnyStateBits(NS_FRAME_VISIBILITY_IS_TRACKED)) { + return; // Nothing to do. + } + + bool isSet = false; + uint32_t visibleCount = TakeProperty(VisibilityStateProperty(), &isSet); + + MOZ_ASSERT(isSet, + "Should have a VisibilityStateProperty value " + "if NS_FRAME_VISIBILITY_IS_TRACKED is set"); + + RemoveStateBits(NS_FRAME_VISIBILITY_IS_TRACKED); + + if (visibleCount == 0) { + return; // We were nonvisible. + } + + // We were visible, so send an OnVisibilityChange() notification. + OnVisibilityChange(Visibility::ApproximatelyNonVisible); +} + +void nsIFrame::DecApproximateVisibleCount( + const Maybe<OnNonvisible>& aNonvisibleAction + /* = Nothing() */) { + MOZ_ASSERT(HasAnyStateBits(NS_FRAME_VISIBILITY_IS_TRACKED)); + + bool isSet = false; + uint32_t visibleCount = GetProperty(VisibilityStateProperty(), &isSet); + + MOZ_ASSERT(isSet, + "Should have a VisibilityStateProperty value " + "if NS_FRAME_VISIBILITY_IS_TRACKED is set"); + MOZ_ASSERT(visibleCount > 0, + "Frame is already nonvisible and we're " + "decrementing its visible count?"); + + visibleCount--; + SetProperty(VisibilityStateProperty(), visibleCount); + if (visibleCount > 0) { + return; + } + + // We just became nonvisible, so send an OnVisibilityChange() notification. + OnVisibilityChange(Visibility::ApproximatelyNonVisible, aNonvisibleAction); +} + +void nsIFrame::IncApproximateVisibleCount() { + MOZ_ASSERT(HasAnyStateBits(NS_FRAME_VISIBILITY_IS_TRACKED)); + + bool isSet = false; + uint32_t visibleCount = GetProperty(VisibilityStateProperty(), &isSet); + + MOZ_ASSERT(isSet, + "Should have a VisibilityStateProperty value " + "if NS_FRAME_VISIBILITY_IS_TRACKED is set"); + + visibleCount++; + SetProperty(VisibilityStateProperty(), visibleCount); + if (visibleCount > 1) { + return; + } + + // We just became visible, so send an OnVisibilityChange() notification. + OnVisibilityChange(Visibility::ApproximatelyVisible); +} + +void nsIFrame::OnVisibilityChange(Visibility aNewVisibility, + const Maybe<OnNonvisible>& aNonvisibleAction + /* = Nothing() */) { + // XXX(seth): In bug 1218990 we'll implement visibility tracking for CSS + // images here. +} + +static nsIFrame* GetActiveSelectionFrame(nsPresContext* aPresContext, + nsIFrame* aFrame) { + nsIContent* capturingContent = PresShell::GetCapturingContent(); + if (capturingContent) { + nsIFrame* activeFrame = aPresContext->GetPrimaryFrameFor(capturingContent); + return activeFrame ? activeFrame : aFrame; + } + + return aFrame; +} + +int16_t nsIFrame::DetermineDisplaySelection() { + int16_t selType = nsISelectionController::SELECTION_OFF; + + nsCOMPtr<nsISelectionController> selCon; + nsresult result = + GetSelectionController(PresContext(), getter_AddRefs(selCon)); + if (NS_SUCCEEDED(result) && selCon) { + result = selCon->GetDisplaySelection(&selType); + if (NS_SUCCEEDED(result) && + (selType != nsISelectionController::SELECTION_OFF)) { + // Check whether style allows selection. + if (!IsSelectable(nullptr)) { + selType = nsISelectionController::SELECTION_OFF; + } + } + } + return selType; +} + +static Element* FindElementAncestorForMozSelection(nsIContent* aContent) { + NS_ENSURE_TRUE(aContent, nullptr); + while (aContent && aContent->IsInNativeAnonymousSubtree()) { + aContent = aContent->GetClosestNativeAnonymousSubtreeRootParentOrHost(); + } + NS_ASSERTION(aContent, "aContent isn't in non-anonymous tree?"); + return aContent ? aContent->GetAsElementOrParentElement() : nullptr; +} + +already_AddRefed<ComputedStyle> nsIFrame::ComputeSelectionStyle( + int16_t aSelectionStatus) const { + // Just bail out if not a selection-status that ::selection applies to. + if (aSelectionStatus != nsISelectionController::SELECTION_ON && + aSelectionStatus != nsISelectionController::SELECTION_DISABLED) { + return nullptr; + } + Element* element = FindElementAncestorForMozSelection(GetContent()); + if (!element) { + return nullptr; + } + RefPtr<ComputedStyle> pseudoStyle = + PresContext()->StyleSet()->ProbePseudoElementStyle( + *element, PseudoStyleType::selection, Style()); + if (!pseudoStyle) { + return nullptr; + } + // When in high-contrast mode, the style system ends up ignoring the color + // declarations, which means that the ::selection style becomes the inherited + // color, and default background. That's no good. + // When force-color-adjust is set to none allow using the color styles, + // as they will not be replaced. + if (PresContext()->ForcingColors() && + pseudoStyle->StyleText()->mForcedColorAdjust != + StyleForcedColorAdjust::None) { + return nullptr; + } + return do_AddRef(pseudoStyle); +} + +already_AddRefed<ComputedStyle> nsIFrame::ComputeHighlightSelectionStyle( + const nsAtom* aHighlightName) { + Element* element = FindElementAncestorForMozSelection(GetContent()); + if (!element) { + return nullptr; + } + return PresContext()->StyleSet()->ProbeHighlightPseudoElementStyle( + *element, aHighlightName, Style()); +} + +template <typename SizeOrMaxSize> +static inline bool IsIntrinsicKeyword(const SizeOrMaxSize& aSize) { + // All keywords other than auto/none/-moz-available depend on intrinsic sizes. + return aSize.IsMaxContent() || aSize.IsMinContent() || aSize.IsFitContent() || + aSize.IsFitContentFunction(); +} + +bool nsIFrame::CanBeDynamicReflowRoot() const { + if (!StaticPrefs::layout_dynamic_reflow_roots_enabled()) { + return false; + } + + auto& display = *StyleDisplay(); + if (IsFrameOfType(nsIFrame::eLineParticipant) || + nsStyleDisplay::IsRubyDisplayType(display.mDisplay) || + display.DisplayOutside() == StyleDisplayOutside::InternalTable || + display.DisplayInside() == StyleDisplayInside::Table) { + // We have a display type where 'width' and 'height' don't actually set the + // width or height (i.e., the size depends on content). + MOZ_ASSERT(!HasAnyStateBits(NS_FRAME_DYNAMIC_REFLOW_ROOT), + "should not have dynamic reflow root bit"); + return false; + } + + // We can't serve as a dynamic reflow root if our used 'width' and 'height' + // might be influenced by content. + // + // FIXME: For display:block, we should probably optimize inline-size: auto. + // FIXME: Other flex and grid cases? + auto& pos = *StylePosition(); + const auto& width = pos.mWidth; + const auto& height = pos.mHeight; + if (!width.IsLengthPercentage() || width.HasPercent() || + !height.IsLengthPercentage() || height.HasPercent() || + IsIntrinsicKeyword(pos.mMinWidth) || IsIntrinsicKeyword(pos.mMaxWidth) || + IsIntrinsicKeyword(pos.mMinHeight) || + IsIntrinsicKeyword(pos.mMaxHeight) || + ((pos.mMinWidth.IsAuto() || pos.mMinHeight.IsAuto()) && + IsFlexOrGridItem())) { + return false; + } + + // If our flex-basis is 'auto', it'll defer to 'width' (or 'height') which + // we've already checked. Otherwise, it preempts them, so we need to + // perform the same "could-this-value-be-influenced-by-content" checks that + // we performed for 'width' and 'height' above. + if (IsFlexItem()) { + const auto& flexBasis = pos.mFlexBasis; + if (!flexBasis.IsAuto()) { + if (!flexBasis.IsSize() || !flexBasis.AsSize().IsLengthPercentage() || + flexBasis.AsSize().HasPercent()) { + return false; + } + } + } + + if (!IsFixedPosContainingBlock()) { + // We can't treat this frame as a reflow root, since dynamic changes + // to absolutely-positioned frames inside of it require that we + // reflow the placeholder before we reflow the absolutely positioned + // frame. + // FIXME: Alternatively, we could sort the reflow roots in + // PresShell::ProcessReflowCommands by depth in the tree, from + // deepest to least deep. However, for performance (FIXME) we + // should really be sorting them in the opposite order! + return false; + } + + // If we participate in a container's block reflow context, or margins + // can collapse through us, we can't be a dynamic reflow root. + if (IsBlockFrameOrSubclass() && + !HasAllStateBits(NS_BLOCK_FLOAT_MGR | NS_BLOCK_MARGIN_ROOT)) { + return false; + } + + // Subgrids are never reflow roots, but 'contain:layout/paint' prevents + // creating a subgrid in the first place. + if (pos.mGridTemplateColumns.IsSubgrid() || + pos.mGridTemplateRows.IsSubgrid()) { + // NOTE: we could check that 'display' of our parent's primary frame is + // '[inline-]grid' here but that's probably not worth it in practice. + if (!display.IsContainLayout() && !display.IsContainPaint()) { + return false; + } + } + + // If we are split, we can't be a dynamic reflow root. Our reflow status may + // change after reflow, and our parent is responsible to create or delete our + // next-in-flow. + if (GetPrevContinuation() || GetNextContinuation()) { + return false; + } + + return true; +} + +/******************************************************** + * Refreshes each content's frame + *********************************************************/ + +void nsIFrame::DisplayOutlineUnconditional(nsDisplayListBuilder* aBuilder, + const nsDisplayListSet& aLists) { + // Per https://drafts.csswg.org/css-tables-3/#global-style-overrides: + // "All css properties of table-column and table-column-group boxes are + // ignored, except when explicitly specified by this specification." + // CSS outlines fall into this category, so we skip them on these boxes. + MOZ_ASSERT(!IsTableColGroupFrame() && !IsTableColFrame()); + const auto& outline = *StyleOutline(); + + if (!outline.ShouldPaintOutline()) { + return; + } + + // Outlines are painted by the table wrapper frame. + if (IsTableFrame()) { + return; + } + + if (HasAnyStateBits(NS_FRAME_PART_OF_IBSPLIT) && + ScrollableOverflowRect().IsEmpty()) { + // Skip parts of IB-splits with an empty overflow rect, see bug 434301. + // We may still want to fix some of the overflow area calculations over in + // that bug. + return; + } + + // We don't display outline-style: auto on themed frames that have their own + // focus indicators. + if (outline.mOutlineStyle.IsAuto()) { + auto* disp = StyleDisplay(); + if (IsThemed(disp) && PresContext()->Theme()->ThemeDrawsFocusForWidget( + this, disp->EffectiveAppearance())) { + return; + } + } + + aLists.Outlines()->AppendNewToTop<nsDisplayOutline>(aBuilder, this); +} + +void nsIFrame::DisplayOutline(nsDisplayListBuilder* aBuilder, + const nsDisplayListSet& aLists) { + if (!IsVisibleForPainting()) return; + + DisplayOutlineUnconditional(aBuilder, aLists); +} + +void nsIFrame::DisplayInsetBoxShadowUnconditional( + nsDisplayListBuilder* aBuilder, nsDisplayList* aList) { + // XXXbz should box-shadow for rows/rowgroups/columns/colgroups get painted + // just because we're visible? Or should it depend on the cell visibility + // when we're not the whole table? + const auto* effects = StyleEffects(); + if (effects->HasBoxShadowWithInset(true)) { + aList->AppendNewToTop<nsDisplayBoxShadowInner>(aBuilder, this); + } +} + +void nsIFrame::DisplayInsetBoxShadow(nsDisplayListBuilder* aBuilder, + nsDisplayList* aList) { + if (!IsVisibleForPainting()) return; + + DisplayInsetBoxShadowUnconditional(aBuilder, aList); +} + +void nsIFrame::DisplayOutsetBoxShadowUnconditional( + nsDisplayListBuilder* aBuilder, nsDisplayList* aList) { + // XXXbz should box-shadow for rows/rowgroups/columns/colgroups get painted + // just because we're visible? Or should it depend on the cell visibility + // when we're not the whole table? + const auto* effects = StyleEffects(); + if (effects->HasBoxShadowWithInset(false)) { + aList->AppendNewToTop<nsDisplayBoxShadowOuter>(aBuilder, this); + } +} + +void nsIFrame::DisplayOutsetBoxShadow(nsDisplayListBuilder* aBuilder, + nsDisplayList* aList) { + if (!IsVisibleForPainting()) return; + + DisplayOutsetBoxShadowUnconditional(aBuilder, aList); +} + +void nsIFrame::DisplayCaret(nsDisplayListBuilder* aBuilder, + nsDisplayList* aList) { + if (!IsVisibleForPainting()) return; + + aList->AppendNewToTop<nsDisplayCaret>(aBuilder, this); +} + +nscolor nsIFrame::GetCaretColorAt(int32_t aOffset) { + return nsLayoutUtils::GetColor(this, &nsStyleUI::mCaretColor); +} + +auto nsIFrame::ComputeShouldPaintBackground() const -> ShouldPaintBackground { + nsPresContext* pc = PresContext(); + ShouldPaintBackground settings{pc->GetBackgroundColorDraw(), + pc->GetBackgroundImageDraw()}; + if (settings.mColor && settings.mImage) { + return settings; + } + + if (StyleVisibility()->mPrintColorAdjust == StylePrintColorAdjust::Exact) { + return {true, true}; + } + + return settings; +} + +bool nsIFrame::DisplayBackgroundUnconditional(nsDisplayListBuilder* aBuilder, + const nsDisplayListSet& aLists) { + if (aBuilder->IsForEventDelivery() && !aBuilder->HitTestIsForVisibility()) { + // For hit-testing, we generally just need a light-weight data structure + // like nsDisplayEventReceiver. But if the hit-testing is for visibility, + // then we need to know the opaque region in order to determine whether to + // stop or not. + aLists.BorderBackground()->AppendNewToTop<nsDisplayEventReceiver>(aBuilder, + this); + return false; + } + + const AppendedBackgroundType result = + nsDisplayBackgroundImage::AppendBackgroundItemsToTop( + aBuilder, this, + GetRectRelativeToSelf() + aBuilder->ToReferenceFrame(this), + aLists.BorderBackground()); + + if (result == AppendedBackgroundType::None) { + aBuilder->BuildCompositorHitTestInfoIfNeeded(this, + aLists.BorderBackground()); + } + + return result == AppendedBackgroundType::ThemedBackground; +} + +void nsIFrame::DisplayBorderBackgroundOutline(nsDisplayListBuilder* aBuilder, + const nsDisplayListSet& aLists) { + // The visibility check belongs here since child elements have the + // opportunity to override the visibility property and display even if + // their parent is hidden. + if (!IsVisibleForPainting()) { + return; + } + + DisplayOutsetBoxShadowUnconditional(aBuilder, aLists.BorderBackground()); + + bool bgIsThemed = DisplayBackgroundUnconditional(aBuilder, aLists); + DisplayInsetBoxShadowUnconditional(aBuilder, aLists.BorderBackground()); + + // If there's a themed background, we should not create a border item. + // It won't be rendered. + // Don't paint borders for tables here, since they paint them in a different + // order. + if (!bgIsThemed && StyleBorder()->HasBorder() && !IsTableFrame()) { + aLists.BorderBackground()->AppendNewToTop<nsDisplayBorder>(aBuilder, this); + } + + DisplayOutlineUnconditional(aBuilder, aLists); +} + +inline static bool IsSVGContentWithCSSClip(const nsIFrame* aFrame) { + // The CSS spec says that the 'clip' property only applies to absolutely + // positioned elements, whereas the SVG spec says that it applies to SVG + // elements regardless of the value of the 'position' property. Here we obey + // the CSS spec for outer-<svg> (since that's what we generally do), but + // obey the SVG spec for other SVG elements to which 'clip' applies. + return aFrame->HasAnyStateBits(NS_FRAME_SVG_LAYOUT) && + aFrame->GetContent()->IsAnyOfSVGElements(nsGkAtoms::svg, + nsGkAtoms::foreignObject); +} + +Maybe<nsRect> nsIFrame::GetClipPropClipRect(const nsStyleDisplay* aDisp, + const nsStyleEffects* aEffects, + const nsSize& aSize) const { + if (aEffects->mClip.IsAuto() || + !(aDisp->IsAbsolutelyPositioned(this) || IsSVGContentWithCSSClip(this))) { + return Nothing(); + } + + auto& clipRect = aEffects->mClip.AsRect(); + nsRect rect = clipRect.ToLayoutRect(); + if (MOZ_LIKELY(StyleBorder()->mBoxDecorationBreak == + StyleBoxDecorationBreak::Slice)) { + // The clip applies to the joined boxes so it's relative the first + // continuation. + nscoord y = 0; + for (nsIFrame* f = GetPrevContinuation(); f; f = f->GetPrevContinuation()) { + y += f->GetRect().height; + } + rect.MoveBy(nsPoint(0, -y)); + } + + if (clipRect.right.IsAuto()) { + rect.width = aSize.width - rect.x; + } + if (clipRect.bottom.IsAuto()) { + rect.height = aSize.height - rect.y; + } + return Some(rect); +} + +/** + * If the CSS 'overflow' property applies to this frame, and is not + * handled by constructing a dedicated nsHTML/XULScrollFrame, set up clipping + * for that overflow in aBuilder->ClipState() to clip all containing-block + * descendants. + */ +static void ApplyOverflowClipping( + nsDisplayListBuilder* aBuilder, const nsIFrame* aFrame, + nsIFrame::PhysicalAxes aClipAxes, + DisplayListClipState::AutoClipMultiple& aClipState) { + // Only 'clip' is handled here (and 'hidden' for table frames, and any + // non-'visible' value for blocks in a paginated context). + // We allow 'clip' to apply to any kind of frame. This is required by + // comboboxes which make their display text (an inline frame) have clipping. + MOZ_ASSERT(aClipAxes != nsIFrame::PhysicalAxes::None); + MOZ_ASSERT(aFrame->ShouldApplyOverflowClipping(aFrame->StyleDisplay()) == + aClipAxes); + + nsRect clipRect; + bool haveRadii = false; + nscoord radii[8]; + auto* disp = aFrame->StyleDisplay(); + // Only deflate the padding if we clip to the content-box in that axis. + auto wm = aFrame->GetWritingMode(); + bool cbH = (wm.IsVertical() ? disp->mOverflowClipBoxBlock + : disp->mOverflowClipBoxInline) == + StyleOverflowClipBox::ContentBox; + bool cbV = (wm.IsVertical() ? disp->mOverflowClipBoxInline + : disp->mOverflowClipBoxBlock) == + StyleOverflowClipBox::ContentBox; + + nsMargin boxMargin = -aFrame->GetUsedPadding(); + if (!cbH) { + boxMargin.left = boxMargin.right = nscoord(0); + } + if (!cbV) { + boxMargin.top = boxMargin.bottom = nscoord(0); + } + + auto clipMargin = aFrame->OverflowClipMargin(aClipAxes); + + boxMargin -= aFrame->GetUsedBorder(); + boxMargin += nsMargin(clipMargin.height, clipMargin.width, clipMargin.height, + clipMargin.width); + boxMargin.ApplySkipSides(aFrame->GetSkipSides()); + + nsRect rect(nsPoint(0, 0), aFrame->GetSize()); + rect.Inflate(boxMargin); + if (MOZ_UNLIKELY(!(aClipAxes & nsIFrame::PhysicalAxes::Horizontal))) { + // NOTE(mats) We shouldn't be clipping at all in this dimension really, + // but clipping in just one axis isn't supported by our GFX APIs so we + // clip to our visual overflow rect instead. + nsRect o = aFrame->InkOverflowRect(); + rect.x = o.x; + rect.width = o.width; + } + if (MOZ_UNLIKELY(!(aClipAxes & nsIFrame::PhysicalAxes::Vertical))) { + // See the note above. + nsRect o = aFrame->InkOverflowRect(); + rect.y = o.y; + rect.height = o.height; + } + clipRect = rect + aBuilder->ToReferenceFrame(aFrame); + haveRadii = aFrame->GetBoxBorderRadii(radii, boxMargin); + aClipState.ClipContainingBlockDescendantsExtra(clipRect, + haveRadii ? radii : nullptr); +} + +nsSize nsIFrame::OverflowClipMargin(PhysicalAxes aClipAxes) const { + nsSize result; + if (aClipAxes == PhysicalAxes::None) { + return result; + } + const auto& margin = StyleMargin()->mOverflowClipMargin; + if (margin.IsZero()) { + return result; + } + nscoord marginAu = margin.ToAppUnits(); + if (aClipAxes & PhysicalAxes::Horizontal) { + result.width = marginAu; + } + if (aClipAxes & PhysicalAxes::Vertical) { + result.height = marginAu; + } + return result; +} + +/** + * Returns whether a display item that gets created with the builder's current + * state will have a scrolled clip, i.e. a clip that is scrolled by a scroll + * frame which does not move the item itself. + */ +static bool BuilderHasScrolledClip(nsDisplayListBuilder* aBuilder) { + const DisplayItemClipChain* currentClip = + aBuilder->ClipState().GetCurrentCombinedClipChain(aBuilder); + if (!currentClip) { + return false; + } + + const ActiveScrolledRoot* currentClipASR = currentClip->mASR; + const ActiveScrolledRoot* currentASR = aBuilder->CurrentActiveScrolledRoot(); + return ActiveScrolledRoot::PickDescendant(currentClipASR, currentASR) != + currentASR; +} + +class AutoSaveRestoreContainsBlendMode { + nsDisplayListBuilder& mBuilder; + bool mSavedContainsBlendMode; + + public: + explicit AutoSaveRestoreContainsBlendMode(nsDisplayListBuilder& aBuilder) + : mBuilder(aBuilder), + mSavedContainsBlendMode(aBuilder.ContainsBlendMode()) {} + + ~AutoSaveRestoreContainsBlendMode() { + mBuilder.SetContainsBlendMode(mSavedContainsBlendMode); + } +}; + +static bool IsFrameOrAncestorApzAware(nsIFrame* aFrame) { + nsIContent* node = aFrame->GetContent(); + if (!node) { + return false; + } + + do { + if (node->IsNodeApzAware()) { + return true; + } + nsIContent* shadowRoot = node->GetShadowRoot(); + if (shadowRoot && shadowRoot->IsNodeApzAware()) { + return true; + } + + // Even if the node owning aFrame doesn't have apz-aware event listeners + // itself, its shadow root or display: contents ancestors (which have no + // frames) might, so we need to account for them too. + } while ((node = node->GetFlattenedTreeParent()) && node->IsElement() && + node->AsElement()->IsDisplayContents()); + + return false; +} + +static void CheckForApzAwareEventHandlers(nsDisplayListBuilder* aBuilder, + nsIFrame* aFrame) { + if (aBuilder->GetAncestorHasApzAwareEventHandler()) { + return; + } + + if (IsFrameOrAncestorApzAware(aFrame)) { + aBuilder->SetAncestorHasApzAwareEventHandler(true); + } +} + +static void UpdateCurrentHitTestInfo(nsDisplayListBuilder* aBuilder, + nsIFrame* aFrame) { + if (!aBuilder->BuildCompositorHitTestInfo()) { + // Compositor hit test info is not used. + return; + } + + CheckForApzAwareEventHandlers(aBuilder, aFrame); + + const CompositorHitTestInfo info = aFrame->GetCompositorHitTestInfo(aBuilder); + aBuilder->SetCompositorHitTestInfo(info); +} + +/** + * True if aDescendant participates the context aAncestor participating. + */ +static bool FrameParticipatesIn3DContext(nsIFrame* aAncestor, + nsIFrame* aDescendant) { + MOZ_ASSERT(aAncestor != aDescendant); + MOZ_ASSERT(aAncestor->GetContent() != aDescendant->GetContent()); + MOZ_ASSERT(aAncestor->Extend3DContext()); + + nsIFrame* ancestor = aAncestor->FirstContinuation(); + MOZ_ASSERT(ancestor->IsPrimaryFrame()); + + nsIFrame* frame; + for (frame = aDescendant->GetClosestFlattenedTreeAncestorPrimaryFrame(); + frame && ancestor != frame; + frame = frame->GetClosestFlattenedTreeAncestorPrimaryFrame()) { + if (!frame->Extend3DContext()) { + return false; + } + } + + MOZ_ASSERT(frame == ancestor); + return true; +} + +static bool ItemParticipatesIn3DContext(nsIFrame* aAncestor, + nsDisplayItem* aItem) { + auto type = aItem->GetType(); + const bool isContainer = type == DisplayItemType::TYPE_WRAP_LIST || + type == DisplayItemType::TYPE_CONTAINER; + + if (isContainer && aItem->GetChildren()->Length() == 1) { + // If the wraplist has only one child item, use the type of that item. + type = aItem->GetChildren()->GetBottom()->GetType(); + } + + if (type != DisplayItemType::TYPE_TRANSFORM && + type != DisplayItemType::TYPE_PERSPECTIVE) { + return false; + } + nsIFrame* transformFrame = aItem->Frame(); + if (aAncestor->GetContent() == transformFrame->GetContent()) { + return true; + } + return FrameParticipatesIn3DContext(aAncestor, transformFrame); +} + +static void WrapSeparatorTransform(nsDisplayListBuilder* aBuilder, + nsIFrame* aFrame, + nsDisplayList* aNonParticipants, + nsDisplayList* aParticipants, int aIndex, + nsDisplayItem** aSeparator) { + if (aNonParticipants->IsEmpty()) { + return; + } + + nsDisplayTransform* item = MakeDisplayItemWithIndex<nsDisplayTransform>( + aBuilder, aFrame, aIndex, aNonParticipants, aBuilder->GetVisibleRect()); + + if (*aSeparator == nullptr && item) { + *aSeparator = item; + } + + aParticipants->AppendToTop(item); +} + +// Try to compute a clip rect to bound the contents of the mask item +// that will be built for |aMaskedFrame|. If we're not able to compute +// one, return an empty Maybe. +// The returned clip rect, if there is one, is relative to |aMaskedFrame|. +static Maybe<nsRect> ComputeClipForMaskItem(nsDisplayListBuilder* aBuilder, + nsIFrame* aMaskedFrame) { + const nsStyleSVGReset* svgReset = aMaskedFrame->StyleSVGReset(); + + SVGUtils::MaskUsage maskUsage; + SVGUtils::DetermineMaskUsage(aMaskedFrame, false, maskUsage); + + nsPoint offsetToUserSpace = + nsLayoutUtils::ComputeOffsetToUserSpace(aBuilder, aMaskedFrame); + int32_t devPixelRatio = aMaskedFrame->PresContext()->AppUnitsPerDevPixel(); + gfxPoint devPixelOffsetToUserSpace = + nsLayoutUtils::PointToGfxPoint(offsetToUserSpace, devPixelRatio); + CSSToLayoutDeviceScale cssToDevScale = + aMaskedFrame->PresContext()->CSSToDevPixelScale(); + + nsPoint toReferenceFrame; + aBuilder->FindReferenceFrameFor(aMaskedFrame, &toReferenceFrame); + + Maybe<gfxRect> combinedClip; + if (maskUsage.shouldApplyBasicShapeOrPath) { + Maybe<Rect> result = + CSSClipPathInstance::GetBoundingRectForBasicShapeOrPathClip( + aMaskedFrame, svgReset->mClipPath); + if (result) { + combinedClip = Some(ThebesRect(*result)); + } + } else if (maskUsage.shouldApplyClipPath) { + gfxRect result = SVGUtils::GetBBox( + aMaskedFrame, + SVGUtils::eBBoxIncludeClipped | SVGUtils::eBBoxIncludeFill | + SVGUtils::eBBoxIncludeMarkers | SVGUtils::eBBoxIncludeStroke | + SVGUtils::eDoNotClipToBBoxOfContentInsideClipPath); + combinedClip = Some( + ThebesRect((CSSRect::FromUnknownRect(ToRect(result)) * cssToDevScale) + .ToUnknownRect())); + } else { + // The code for this case is adapted from ComputeMaskGeometry(). + + nsRect borderArea(toReferenceFrame, aMaskedFrame->GetSize()); + borderArea -= offsetToUserSpace; + + // Use an infinite dirty rect to pass into nsCSSRendering:: + // GetImageLayerClip() because we don't have an actual dirty rect to + // pass in. This is fine because the only time GetImageLayerClip() will + // not intersect the incoming dirty rect with something is in the "NoClip" + // case, and we handle that specially. + nsRect dirtyRect(nscoord_MIN / 2, nscoord_MIN / 2, nscoord_MAX, + nscoord_MAX); + + nsIFrame* firstFrame = + nsLayoutUtils::FirstContinuationOrIBSplitSibling(aMaskedFrame); + nsTArray<SVGMaskFrame*> maskFrames; + // XXX check return value? + SVGObserverUtils::GetAndObserveMasks(firstFrame, &maskFrames); + + for (uint32_t i = 0; i < maskFrames.Length(); ++i) { + gfxRect clipArea; + if (maskFrames[i]) { + clipArea = maskFrames[i]->GetMaskArea(aMaskedFrame); + clipArea = ThebesRect( + (CSSRect::FromUnknownRect(ToRect(clipArea)) * cssToDevScale) + .ToUnknownRect()); + } else { + const auto& layer = svgReset->mMask.mLayers[i]; + if (layer.mClip == StyleGeometryBox::NoClip) { + return Nothing(); + } + + nsCSSRendering::ImageLayerClipState clipState; + nsCSSRendering::GetImageLayerClip( + layer, aMaskedFrame, *aMaskedFrame->StyleBorder(), borderArea, + dirtyRect, false /* aWillPaintBorder */, devPixelRatio, &clipState); + clipArea = clipState.mDirtyRectInDevPx; + } + combinedClip = UnionMaybeRects(combinedClip, Some(clipArea)); + } + } + if (combinedClip) { + if (combinedClip->IsEmpty()) { + // *clipForMask might be empty if all mask references are not resolvable + // or the size of them are empty. We still need to create a transparent + // mask before bug 1276834 fixed, so don't clip ctx by an empty rectangle + // for for now. + return Nothing(); + } + + // Convert to user space. + *combinedClip += devPixelOffsetToUserSpace; + + // Round the clip out. In FrameLayerBuilder we round clips to nearest + // pixels, and if we have a really thin clip here, that can cause the + // clip to become empty if we didn't round out here. + // The rounding happens in coordinates that are relative to the reference + // frame, which matches what FrameLayerBuilder does. + combinedClip->RoundOut(); + + // Convert to app units. + nsRect result = + nsLayoutUtils::RoundGfxRectToAppRect(*combinedClip, devPixelRatio); + + // The resulting clip is relative to the reference frame, but the caller + // expects it to be relative to the masked frame, so adjust it. + result -= toReferenceFrame; + return Some(result); + } + return Nothing(); +} + +struct AutoCheckBuilder { + explicit AutoCheckBuilder(nsDisplayListBuilder* aBuilder) + : mBuilder(aBuilder) { + aBuilder->Check(); + } + + ~AutoCheckBuilder() { mBuilder->Check(); } + + nsDisplayListBuilder* mBuilder; +}; + +/** + * Tries to reuse a top-level stacking context item from the previous paint. + * Returns true if an item was reused, otherwise false. + */ +bool TryToReuseStackingContextItem(nsDisplayListBuilder* aBuilder, + nsDisplayList* aList, nsIFrame* aFrame) { + if (!aBuilder->IsForPainting() || !aBuilder->IsPartialUpdate() || + aBuilder->InInvalidSubtree()) { + return false; + } + + if (aFrame->IsFrameModified() || aFrame->HasModifiedDescendants()) { + return false; + } + + auto& items = aFrame->DisplayItems(); + auto* res = std::find_if( + items.begin(), items.end(), + [](nsDisplayItem* aItem) { return aItem->IsPreProcessed(); }); + + if (res == items.end()) { + return false; + } + + nsDisplayItem* container = *res; + MOZ_ASSERT(container->Frame() == aFrame); + DL_LOGD("RDL - Found SC item %p (%s) (frame: %p)", container, + container->Name(), container->Frame()); + + aList->AppendToTop(container); + aBuilder->ReuseDisplayItem(container); + return true; +} + +void nsIFrame::BuildDisplayListForStackingContext( + nsDisplayListBuilder* aBuilder, nsDisplayList* aList, + bool* aCreatedContainerItem) { +#ifdef DEBUG + DL_LOGV("BuildDisplayListForStackingContext (%p) <", this); + ScopeExit e( + [this]() { DL_LOGV("> BuildDisplayListForStackingContext (%p)", this); }); +#endif + + AutoCheckBuilder check(aBuilder); + + if (aBuilder->IsReusingStackingContextItems() && + TryToReuseStackingContextItem(aBuilder, aList, this)) { + if (aCreatedContainerItem) { + *aCreatedContainerItem = true; + } + return; + } + + if (HasAnyStateBits(NS_FRAME_TOO_DEEP_IN_FRAME_TREE)) { + return; + } + + const auto& style = *Style(); + const nsStyleDisplay* disp = style.StyleDisplay(); + const nsStyleEffects* effects = style.StyleEffects(); + EffectSet* effectSetForOpacity = + EffectSet::GetForFrame(this, nsCSSPropertyIDSet::OpacityProperties()); + // We can stop right away if this is a zero-opacity stacking context and + // we're painting, and we're not animating opacity. + bool needHitTestInfo = aBuilder->BuildCompositorHitTestInfo() && + Style()->PointerEvents() != StylePointerEvents::None; + bool opacityItemForEventsOnly = false; + if (effects->IsTransparent() && aBuilder->IsForPainting() && + !(disp->mWillChange.bits & StyleWillChangeBits::OPACITY) && + !nsLayoutUtils::HasAnimationOfPropertySet( + this, nsCSSPropertyIDSet::OpacityProperties(), effectSetForOpacity)) { + if (needHitTestInfo) { + opacityItemForEventsOnly = true; + } else { + return; + } + } + + if (aBuilder->IsForPainting() && disp->mWillChange.bits) { + aBuilder->AddToWillChangeBudget(this, GetSize()); + } + + // For preserves3d, use the dirty rect already installed on the + // builder, since aDirtyRect maybe distorted for transforms along + // the chain. + nsRect visibleRect = aBuilder->GetVisibleRect(); + nsRect dirtyRect = aBuilder->GetDirtyRect(); + + // We build an opacity item if it's not going to be drawn by SVG content. + // We could in principle skip creating an nsDisplayOpacity item if + // nsDisplayOpacity::NeedsActiveLayer returns false and usingSVGEffects is + // true (the nsDisplayFilter/nsDisplayMasksAndClipPaths could handle the + // opacity). Since SVG has perf issues where we sometimes spend a lot of + // time creating display list items that might be helpful. We'd need to + // restore our mechanism to do that (changed in bug 1482403), and we'd + // need to invalidate the frame if the value that would be return from + // NeedsActiveLayer was to change, which we don't currently do. + const bool useOpacity = + HasVisualOpacity(disp, effects, effectSetForOpacity) && + !SVGUtils::CanOptimizeOpacity(this); + + const bool isTransformed = IsTransformed(); + const bool hasPerspective = isTransformed && HasPerspective(); + const bool extend3DContext = + Extend3DContext(disp, effects, effectSetForOpacity); + const bool combines3DTransformWithAncestors = + (extend3DContext || isTransformed) && Combines3DTransformWithAncestors(); + + Maybe<nsDisplayListBuilder::AutoPreserves3DContext> autoPreserves3DContext; + if (extend3DContext && !combines3DTransformWithAncestors) { + // Start a new preserves3d context to keep informations on + // nsDisplayListBuilder. + autoPreserves3DContext.emplace(aBuilder); + // Save dirty rect on the builder to avoid being distorted for + // multiple transforms along the chain. + aBuilder->SavePreserves3DRect(); + + // We rebuild everything within preserve-3d and don't try + // to retain, so override the dirty rect now. + if (aBuilder->IsRetainingDisplayList()) { + dirtyRect = visibleRect; + aBuilder->SetDisablePartialUpdates(true); + } + } + + const bool useBlendMode = effects->mMixBlendMode != StyleBlend::Normal; + if (useBlendMode) { + aBuilder->SetContainsBlendMode(true); + } + + // reset blend mode so we can keep track if this stacking context needs have + // a nsDisplayBlendContainer. Set the blend mode back when the routine exits + // so we keep track if the parent stacking context needs a container too. + AutoSaveRestoreContainsBlendMode autoRestoreBlendMode(*aBuilder); + aBuilder->SetContainsBlendMode(false); + + // NOTE: When changing this condition make sure to tweak nsGfxScrollFrame as + // well. + bool usingBackdropFilter = effects->HasBackdropFilters() && + IsVisibleForPainting() && + !style.IsRootElementStyle(); + + nsRect visibleRectOutsideTransform = visibleRect; + nsDisplayTransform::PrerenderInfo prerenderInfo; + bool inTransform = aBuilder->IsInTransform(); + if (isTransformed) { + prerenderInfo = nsDisplayTransform::ShouldPrerenderTransformedContent( + aBuilder, this, &visibleRect); + + switch (prerenderInfo.mDecision) { + case nsDisplayTransform::PrerenderDecision::Full: + case nsDisplayTransform::PrerenderDecision::Partial: + dirtyRect = visibleRect; + break; + case nsDisplayTransform::PrerenderDecision::No: { + // If we didn't prerender an animated frame in a preserve-3d context, + // then we want disable async animations for the rest of the preserve-3d + // (especially ancestors). + if ((extend3DContext || combines3DTransformWithAncestors) && + prerenderInfo.mHasAnimations) { + aBuilder->SavePreserves3DAllowAsyncAnimation(false); + } + + const nsRect overflow = InkOverflowRectRelativeToSelf(); + if (overflow.IsEmpty() && !extend3DContext) { + return; + } + + // If we're in preserve-3d then grab the dirty rect that was given to + // the root and transform using the combined transform. + if (combines3DTransformWithAncestors) { + visibleRect = dirtyRect = aBuilder->GetPreserves3DRect(); + } + + float appPerDev = PresContext()->AppUnitsPerDevPixel(); + auto transform = nsDisplayTransform::GetResultingTransformMatrix( + this, nsPoint(), appPerDev, + nsDisplayTransform::kTransformRectFlags); + nsRect untransformedDirtyRect; + if (nsDisplayTransform::UntransformRect(dirtyRect, overflow, transform, + appPerDev, + &untransformedDirtyRect)) { + dirtyRect = untransformedDirtyRect; + nsDisplayTransform::UntransformRect(visibleRect, overflow, transform, + appPerDev, &visibleRect); + } else { + // This should only happen if the transform is singular, in which case + // nothing is visible anyway + dirtyRect.SetEmpty(); + visibleRect.SetEmpty(); + } + } + } + inTransform = true; + } else if (IsFixedPosContainingBlock()) { + // Restict the building area to the overflow rect for these frames, since + // RetainedDisplayListBuilder uses it to know if the size of the stacking + // context changed. + visibleRect.IntersectRect(visibleRect, InkOverflowRect()); + dirtyRect.IntersectRect(dirtyRect, InkOverflowRect()); + } + + bool hasOverrideDirtyRect = false; + // If we're doing a partial build, we're not invalid and we're capable + // of having an override building rect (stacking context and fixed pos + // containing block), then we should assume we have one. + // Either we have an explicit one, or nothing in our subtree changed and + // we have an implicit empty rect. + // + // These conditions should match |CanStoreDisplayListBuildingRect()| in + // RetainedDisplayListBuilder.cpp + if (!aBuilder->IsReusingStackingContextItems() && + aBuilder->IsPartialUpdate() && !aBuilder->InInvalidSubtree() && + !IsFrameModified() && IsFixedPosContainingBlock() && + !GetPrevContinuation() && !GetNextContinuation()) { + dirtyRect = nsRect(); + if (HasOverrideDirtyRegion()) { + nsDisplayListBuilder::DisplayListBuildingData* data = + GetProperty(nsDisplayListBuilder::DisplayListBuildingRect()); + if (data) { + dirtyRect = data->mDirtyRect.Intersect(visibleRect); + hasOverrideDirtyRect = true; + } + } + } + + bool usingFilter = effects->HasFilters() && !style.IsRootElementStyle(); + bool usingMask = SVGIntegrationUtils::UsingMaskOrClipPathForFrame(this); + bool usingSVGEffects = usingFilter || usingMask; + + nsRect visibleRectOutsideSVGEffects = visibleRect; + nsDisplayList hoistedScrollInfoItemsStorage(aBuilder); + if (usingSVGEffects) { + dirtyRect = + SVGIntegrationUtils::GetRequiredSourceForInvalidArea(this, dirtyRect); + visibleRect = + SVGIntegrationUtils::GetRequiredSourceForInvalidArea(this, visibleRect); + aBuilder->EnterSVGEffectsContents(this, &hoistedScrollInfoItemsStorage); + } + + bool useStickyPosition = disp->mPosition == StylePositionProperty::Sticky; + + bool useFixedPosition = + disp->mPosition == StylePositionProperty::Fixed && + (DisplayPortUtils::IsFixedPosFrameInDisplayPort(this) || + BuilderHasScrolledClip(aBuilder)); + + nsDisplayListBuilder::AutoBuildingDisplayList buildingDisplayList( + aBuilder, this, visibleRect, dirtyRect, isTransformed); + + UpdateCurrentHitTestInfo(aBuilder, this); + + // Depending on the effects that are applied to this frame, we can create + // multiple container display items and wrap them around our contents. + // This enum lists all the potential container display items, in the order + // outside to inside. + enum class ContainerItemType : uint8_t { + None = 0, + OwnLayerIfNeeded, + BlendMode, + FixedPosition, + OwnLayerForTransformWithRoundedClip, + Perspective, + Transform, + SeparatorTransforms, + Opacity, + Filter, + BlendContainer + }; + + nsDisplayListBuilder::AutoContainerASRTracker contASRTracker(aBuilder); + + auto cssClip = GetClipPropClipRect(disp, effects, GetSize()); + auto ApplyClipProp = [&](DisplayListClipState::AutoSaveRestore& aClipState) { + if (!cssClip) { + return; + } + nsPoint offset = aBuilder->GetCurrentFrameOffsetToReferenceFrame(); + aBuilder->IntersectDirtyRect(*cssClip); + aBuilder->IntersectVisibleRect(*cssClip); + aClipState.ClipContentDescendants(*cssClip + offset); + }; + + // The CSS clip property is effectively inside the transform, but outside the + // filters. So if we're not transformed we can apply it just here for + // simplicity, instead of on each of the places that handle clipCapturedBy. + DisplayListClipState::AutoSaveRestore untransformedCssClip(aBuilder); + if (!isTransformed) { + ApplyClipProp(untransformedCssClip); + } + + // If there is a current clip, then depending on the container items we + // create, different things can happen to it. Some container items simply + // propagate the clip to their children and aren't clipped themselves. + // But other container items, especially those that establish a different + // geometry for their contents (e.g. transforms), capture the clip on + // themselves and unset the clip for their contents. If we create more than + // one of those container items, the clip will be captured on the outermost + // one and the inner container items will be unclipped. + ContainerItemType clipCapturedBy = ContainerItemType::None; + if (useFixedPosition) { + clipCapturedBy = ContainerItemType::FixedPosition; + } else if (isTransformed) { + const DisplayItemClipChain* currentClip = + aBuilder->ClipState().GetCurrentCombinedClipChain(aBuilder); + if ((hasPerspective || extend3DContext) && + (currentClip && currentClip->HasRoundedCorners())) { + // If we're creating an nsDisplayTransform item that is going to combine + // its transform with its children (preserve-3d or perspective), then we + // can't have an intermediate surface. Mask layers force an intermediate + // surface, so if we're going to need both then create a separate + // wrapping layer for the mask. + clipCapturedBy = ContainerItemType::OwnLayerForTransformWithRoundedClip; + } else if (hasPerspective) { + clipCapturedBy = ContainerItemType::Perspective; + } else { + clipCapturedBy = ContainerItemType::Transform; + } + } else if (usingFilter) { + clipCapturedBy = ContainerItemType::Filter; + } + + DisplayListClipState::AutoSaveRestore clipState(aBuilder); + if (clipCapturedBy != ContainerItemType::None) { + clipState.Clear(); + } + + DisplayListClipState::AutoSaveRestore transformedCssClip(aBuilder); + if (isTransformed) { + // FIXME(emilio, bug 1525159): In the case we have a both a transform _and_ + // filters, this clips the input to the filters as well, which is not + // correct (clipping by the `clip` property is supposed to happen after + // applying the filter effects, per [1]. + // + // This is not a regression though, since we used to do that anyway before + // bug 1514384, and even without the transform we get it wrong. + // + // [1]: https://drafts.fxtf.org/css-masking/#placement + ApplyClipProp(transformedCssClip); + } + + nsDisplayListCollection set(aBuilder); + Maybe<nsRect> clipForMask; + { + DisplayListClipState::AutoSaveRestore nestedClipState(aBuilder); + nsDisplayListBuilder::AutoInTransformSetter inTransformSetter(aBuilder, + inTransform); + nsDisplayListBuilder::AutoEnterFilter filterASRSetter(aBuilder, + usingFilter); + nsDisplayListBuilder::AutoInEventsOnly inEventsSetter( + aBuilder, opacityItemForEventsOnly); + + // If we have a mask, compute a clip to bound the masked content. + // This is necessary in case the content moves with an ancestor + // ASR of the mask. + // Don't do this if we also have a filter, because then the clip + // would be applied before the filter, violating + // https://www.w3.org/TR/filter-effects-1/#placement. + // Filters are a containing block for fixed and absolute descendants, + // so the masked content cannot move with an ancestor ASR. + if (usingMask && !usingFilter) { + clipForMask = ComputeClipForMaskItem(aBuilder, this); + if (clipForMask) { + aBuilder->IntersectDirtyRect(*clipForMask); + aBuilder->IntersectVisibleRect(*clipForMask); + nestedClipState.ClipContentDescendants( + *clipForMask + aBuilder->GetCurrentFrameOffsetToReferenceFrame()); + } + } + + // extend3DContext also guarantees that applyAbsPosClipping and + // usingSVGEffects are false We only modify the preserve-3d rect if we are + // the top of a preserve-3d heirarchy + if (extend3DContext) { + // Mark these first so MarkAbsoluteFramesForDisplayList knows if we are + // going to be forced to descend into frames. + aBuilder->MarkPreserve3DFramesForDisplayList(this); + } + + aBuilder->AdjustWindowDraggingRegion(this); + + MarkAbsoluteFramesForDisplayList(aBuilder); + aBuilder->Check(); + BuildDisplayList(aBuilder, set); + SetBuiltDisplayList(true); + aBuilder->Check(); + aBuilder->DisplayCaret(this, set.Outlines()); + + // Blend modes are a real pain for retained display lists. We build a blend + // container item if the built list contains any blend mode items within + // the current stacking context. This can change without an invalidation + // to the stacking context frame, or the blend mode frame (e.g. by moving + // an intermediate frame). + // When we gain/remove a blend container item, we need to mark this frame + // as invalid and have the full display list for merging to track + // the change correctly. + // It seems really hard to track this in advance, as the bookkeeping + // required to note which stacking contexts have blend descendants + // is complex and likely to be buggy. + // Instead we're doing the sad thing, detecting it afterwards, and just + // repeating display list building if it changed. + // We have to repeat building for the entire display list (or at least + // the outer stacking context), since we need to mark this frame as invalid + // to remove any existing content that isn't wrapped in the blend container, + // and then we need to build content infront/behind the blend container + // to get correct positioning during merging. + if (aBuilder->ContainsBlendMode() && aBuilder->IsRetainingDisplayList()) { + if (aBuilder->IsPartialUpdate()) { + aBuilder->SetPartialBuildFailed(true); + } else { + aBuilder->SetDisablePartialUpdates(true); + } + } + } + + if (aBuilder->IsBackgroundOnly()) { + set.BlockBorderBackgrounds()->DeleteAll(aBuilder); + set.Floats()->DeleteAll(aBuilder); + set.Content()->DeleteAll(aBuilder); + set.PositionedDescendants()->DeleteAll(aBuilder); + set.Outlines()->DeleteAll(aBuilder); + } + + if (hasOverrideDirtyRect && + StaticPrefs::layout_display_list_show_rebuild_area()) { + nsDisplaySolidColor* color = MakeDisplayItem<nsDisplaySolidColor>( + aBuilder, this, + dirtyRect + aBuilder->GetCurrentFrameOffsetToReferenceFrame(), + NS_RGBA(255, 0, 0, 64), false); + if (color) { + color->SetOverrideZIndex(INT32_MAX); + set.PositionedDescendants()->AppendToTop(color); + } + } + + nsIContent* content = GetContent(); + if (!content) { + content = PresContext()->Document()->GetRootElement(); + } + + nsDisplayList resultList(aBuilder); + set.SerializeWithCorrectZOrder(&resultList, content); + + // Get the ASR to use for the container items that we create here. + const ActiveScrolledRoot* containerItemASR = contASRTracker.GetContainerASR(); + + bool createdContainer = false; + + // If adding both a nsDisplayBlendContainer and a nsDisplayBlendMode to the + // same list, the nsDisplayBlendContainer should be added first. This only + // happens when the element creating this stacking context has mix-blend-mode + // and also contains a child which has mix-blend-mode. + // The nsDisplayBlendContainer must be added to the list first, so it does not + // isolate the containing element blending as well. + if (aBuilder->ContainsBlendMode()) { + resultList.AppendToTop(nsDisplayBlendContainer::CreateForMixBlendMode( + aBuilder, this, &resultList, containerItemASR)); + createdContainer = true; + } + + if (usingBackdropFilter) { + nsRect backdropRect = + GetRectRelativeToSelf() + aBuilder->ToReferenceFrame(this); + resultList.AppendNewToTop<nsDisplayBackdropFilters>( + aBuilder, this, &resultList, backdropRect, this); + createdContainer = true; + } + + // If there are any SVG effects, wrap the list up in an SVG effects item + // (which also handles CSS group opacity). Note that we create an SVG effects + // item even if resultList is empty, since a filter can produce graphical + // output even if the element being filtered wouldn't otherwise do so. + if (usingSVGEffects) { + MOZ_ASSERT(usingFilter || usingMask, + "Beside filter & mask/clip-path, what else effect do we have?"); + + if (clipCapturedBy == ContainerItemType::Filter) { + clipState.Restore(); + } + // Revert to the post-filter dirty rect. + aBuilder->SetVisibleRect(visibleRectOutsideSVGEffects); + + // Skip all filter effects while generating glyph mask. + if (usingFilter && !aBuilder->IsForGenerateGlyphMask()) { + /* List now emptied, so add the new list to the top. */ + resultList.AppendNewToTop<nsDisplayFilters>(aBuilder, this, &resultList, + this, usingBackdropFilter); + createdContainer = true; + } + + if (usingMask) { + // The mask should move with aBuilder->CurrentActiveScrolledRoot(), so + // that's the ASR we prefer to use for the mask item. However, we can + // only do this if the mask if clipped with respect to that ASR, because + // an item always needs to have finite bounds with respect to its ASR. + // If we weren't able to compute a clip for the mask, we fall back to + // using containerItemASR, which is the lowest common ancestor clip of + // the mask's contents. That's not entirely correct, but it satisfies + // the base requirement of the ASR system (that items have finite bounds + // wrt. their ASR). + const ActiveScrolledRoot* maskASR = + clipForMask.isSome() ? aBuilder->CurrentActiveScrolledRoot() + : containerItemASR; + /* List now emptied, so add the new list to the top. */ + resultList.AppendNewToTop<nsDisplayMasksAndClipPaths>( + aBuilder, this, &resultList, maskASR, usingBackdropFilter); + createdContainer = true; + } + + // TODO(miko): We could probably create a wraplist here and avoid creating + // it later in |BuildDisplayListForChild()|. + createdContainer = false; + + // Also add the hoisted scroll info items. We need those for APZ scrolling + // because nsDisplayMasksAndClipPaths items can't build active layers. + aBuilder->ExitSVGEffectsContents(); + resultList.AppendToTop(&hoistedScrollInfoItemsStorage); + } + + // If the list is non-empty and there is CSS group opacity without SVG + // effects, wrap it up in an opacity item. + if (useOpacity) { + const bool needsActiveOpacityLayer = + nsDisplayOpacity::NeedsActiveLayer(aBuilder, this); + resultList.AppendNewToTop<nsDisplayOpacity>( + aBuilder, this, &resultList, containerItemASR, opacityItemForEventsOnly, + needsActiveOpacityLayer, usingBackdropFilter); + createdContainer = true; + } + + // If we're going to apply a transformation and don't have preserve-3d set, + // wrap everything in an nsDisplayTransform. If there's nothing in the list, + // don't add anything. + // + // For the preserve-3d case we want to individually wrap every child in the + // list with a separate nsDisplayTransform instead. When the child is already + // an nsDisplayTransform, we can skip this step, as the computed transform + // will already include our own. + // + // We also traverse into sublists created by nsDisplayWrapList, so that we + // find all the correct children. + if (isTransformed && extend3DContext) { + // Install dummy nsDisplayTransform as a leaf containing + // descendants not participating this 3D rendering context. + nsDisplayList nonparticipants(aBuilder); + nsDisplayList participants(aBuilder); + int index = 1; + + nsDisplayItem* separator = nullptr; + + // TODO: This can be simplified: |participants| is just |resultList|. + for (nsDisplayItem* item : resultList.TakeItems()) { + if (ItemParticipatesIn3DContext(this, item) && + !item->GetClip().HasClip()) { + // The frame of this item participates the same 3D context. + WrapSeparatorTransform(aBuilder, this, &nonparticipants, &participants, + index++, &separator); + + participants.AppendToTop(item); + } else { + // The frame of the item doesn't participate the current + // context, or has no transform. + // + // For items participating but not transformed, they are add + // to nonparticipants to get a separator layer for handling + // clips, if there is, on an intermediate surface. + // \see ContainerLayer::DefaultComputeEffectiveTransforms(). + nonparticipants.AppendToTop(item); + } + } + WrapSeparatorTransform(aBuilder, this, &nonparticipants, &participants, + index++, &separator); + + if (separator) { + createdContainer = true; + } + + resultList.AppendToTop(&participants); + } + + if (isTransformed) { + transformedCssClip.Restore(); + if (clipCapturedBy == ContainerItemType::Transform) { + // Restore clip state now so nsDisplayTransform is clipped properly. + clipState.Restore(); + } + // Revert to the dirtyrect coming in from the parent, without our transform + // taken into account. + aBuilder->SetVisibleRect(visibleRectOutsideTransform); + + if (this != aBuilder->RootReferenceFrame()) { + // Revert to the outer reference frame and offset because all display + // items we create from now on are outside the transform. + nsPoint toOuterReferenceFrame; + const nsIFrame* outerReferenceFrame = + aBuilder->FindReferenceFrameFor(GetParent(), &toOuterReferenceFrame); + toOuterReferenceFrame += GetPosition(); + + buildingDisplayList.SetReferenceFrameAndCurrentOffset( + outerReferenceFrame, toOuterReferenceFrame); + } + + // We would like to block async animations for ancestors of ones not + // prerendered in the preserve-3d tree. Now that we've finished processing + // all descendants, update allowAsyncAnimation to take their prerender + // state into account + // FIXME: We don't block async animations for previous siblings because + // their prerender decisions have been made. We may have to figure out a + // better way to rollback their prerender decisions. + // Alternatively we could not block animations for later siblings, and only + // block them for ancestors of a blocked one. + if ((extend3DContext || combines3DTransformWithAncestors) && + prerenderInfo.CanUseAsyncAnimations() && + !aBuilder->GetPreserves3DAllowAsyncAnimation()) { + // aBuilder->GetPreserves3DAllowAsyncAnimation() means the inner or + // previous silbing frames are allowed/disallowed for async animations. + prerenderInfo.mDecision = nsDisplayTransform::PrerenderDecision::No; + } + + nsDisplayTransform* transformItem = MakeDisplayItem<nsDisplayTransform>( + aBuilder, this, &resultList, visibleRect, prerenderInfo.mDecision); + if (transformItem) { + resultList.AppendToTop(transformItem); + createdContainer = true; + } + + if (hasPerspective) { + transformItem->MarkWithAssociatedPerspective(); + + if (clipCapturedBy == ContainerItemType::Perspective) { + clipState.Restore(); + } + resultList.AppendNewToTop<nsDisplayPerspective>(aBuilder, this, + &resultList); + createdContainer = true; + } + } + + if (clipCapturedBy == + ContainerItemType::OwnLayerForTransformWithRoundedClip) { + clipState.Restore(); + resultList.AppendNewToTopWithIndex<nsDisplayOwnLayer>( + aBuilder, this, + /* aIndex = */ nsDisplayOwnLayer::OwnLayerForTransformWithRoundedClip, + &resultList, aBuilder->CurrentActiveScrolledRoot(), + nsDisplayOwnLayerFlags::None, ScrollbarData{}, + /* aForceActive = */ false, false); + createdContainer = true; + } + + // If we have sticky positioning, wrap it in a sticky position item. + if (useFixedPosition) { + if (clipCapturedBy == ContainerItemType::FixedPosition) { + clipState.Restore(); + } + // The ASR for the fixed item should be the ASR of our containing block, + // which has been set as the builder's current ASR, unless this frame is + // invisible and we hadn't saved display item data for it. In that case, + // we need to take the containerItemASR since we might have fixed children. + // For WebRender, we want to the know what |containerItemASR| is for the + // case where the fixed-pos item is not a "real" fixed-pos item (e.g. it's + // nested inside a scrolling transform), so we stash that on the display + // item as well. + const ActiveScrolledRoot* fixedASR = ActiveScrolledRoot::PickAncestor( + containerItemASR, aBuilder->CurrentActiveScrolledRoot()); + resultList.AppendNewToTop<nsDisplayFixedPosition>( + aBuilder, this, &resultList, fixedASR, containerItemASR); + createdContainer = true; + } else if (useStickyPosition) { + // For position:sticky, the clip needs to be applied both to the sticky + // container item and to the contents. The container item needs the clip + // because a scrolled clip needs to move independently from the sticky + // contents, and the contents need the clip so that they have finite + // clipped bounds with respect to the container item's ASR. The latter is + // a little tricky in the case where the sticky item has both fixed and + // non-fixed descendants, because that means that the sticky container + // item's ASR is the ASR of the fixed descendant. + // For WebRender display list building, though, we still want to know the + // the ASR that the sticky container item would normally have, so we stash + // that on the display item as the "container ASR" (i.e. the normal ASR of + // the container item, excluding the special behaviour induced by fixed + // descendants). + const ActiveScrolledRoot* stickyASR = ActiveScrolledRoot::PickAncestor( + containerItemASR, aBuilder->CurrentActiveScrolledRoot()); + + auto* stickyItem = MakeDisplayItem<nsDisplayStickyPosition>( + aBuilder, this, &resultList, stickyASR, + aBuilder->CurrentActiveScrolledRoot(), + clipState.IsClippedToDisplayPort()); + + bool shouldFlatten = true; + + StickyScrollContainer* stickyScrollContainer = + StickyScrollContainer::GetStickyScrollContainerForFrame(this); + if (stickyScrollContainer && + stickyScrollContainer->ScrollFrame()->IsMaybeAsynchronouslyScrolled()) { + shouldFlatten = false; + } + + stickyItem->SetShouldFlatten(shouldFlatten); + + resultList.AppendToTop(stickyItem); + createdContainer = true; + + // If the sticky element is inside a filter, annotate the scroll frame that + // scrolls the filter as having out-of-flow content inside a filter (this + // inhibits paint skipping). + if (aBuilder->GetFilterASR() && aBuilder->GetFilterASR() == stickyASR) { + aBuilder->GetFilterASR() + ->mScrollableFrame->SetHasOutOfFlowContentInsideFilter(); + } + } + + // If there's blending, wrap up the list in a blend-mode item. Note that + // opacity can be applied before blending as the blend color is not affected + // by foreground opacity (only background alpha). + if (useBlendMode) { + DisplayListClipState::AutoSaveRestore blendModeClipState(aBuilder); + resultList.AppendNewToTop<nsDisplayBlendMode>(aBuilder, this, &resultList, + effects->mMixBlendMode, + containerItemASR, false); + createdContainer = true; + } + + if (aBuilder->IsReusingStackingContextItems()) { + if (resultList.IsEmpty()) { + return; + } + + nsDisplayItem* container = resultList.GetBottom(); + if (resultList.Length() > 1 || container->Frame() != this) { + container = MakeDisplayItem<nsDisplayContainer>( + aBuilder, this, containerItemASR, &resultList); + } else { + MOZ_ASSERT(resultList.Length() == 1); + resultList.Clear(); + } + + // Mark the outermost display item as reusable. These display items and + // their chidren can be reused during the next paint if no ancestor or + // descendant frames have been modified. + if (!container->IsReusedItem()) { + container->SetReusable(); + } + aList->AppendToTop(container); + createdContainer = true; + } else { + aList->AppendToTop(&resultList); + } + + if (aCreatedContainerItem) { + *aCreatedContainerItem = createdContainer; + } +} + +static nsDisplayItem* WrapInWrapList(nsDisplayListBuilder* aBuilder, + nsIFrame* aFrame, nsDisplayList* aList, + const ActiveScrolledRoot* aContainerASR, + bool aBuiltContainerItem = false) { + nsDisplayItem* item = aList->GetBottom(); + if (!item) { + return nullptr; + } + + // We need a wrap list if there are multiple items, or if the single + // item has a different frame. This can change in a partial build depending + // on which items we build, so we need to ensure that we don't transition + // to/from a wrap list without invalidating correctly. + bool needsWrapList = + aList->Length() > 1 || item->Frame() != aFrame || item->GetChildren(); + + // If we have an explicit container item (that can't change without an + // invalidation) or we're doing a full build and don't need a wrap list, then + // we can skip adding one. + if (aBuiltContainerItem || (!aBuilder->IsPartialUpdate() && !needsWrapList)) { + MOZ_ASSERT(aList->Length() == 1); + aList->Clear(); + return item; + } + + // If we're doing a partial build and we didn't need a wrap list + // previously then we can try to work from there. + if (aBuilder->IsPartialUpdate() && + !aFrame->HasDisplayItem(uint32_t(DisplayItemType::TYPE_CONTAINER))) { + // If we now need a wrap list, we must previously have had no display items + // or a single one belonging to this frame. Mark the item itself as + // discarded so that RetainedDisplayListBuilder uses the ones we just built. + // We don't want to mark the frame as modified as that would invalidate + // positioned descendants that might be outside of this list, and might not + // have been rebuilt this time. + if (needsWrapList) { + DiscardOldItems(aFrame); + } else { + MOZ_ASSERT(aList->Length() == 1); + aList->Clear(); + return item; + } + } + + // The last case we could try to handle is when we previously had a wrap list, + // but no longer need it. Unfortunately we can't differentiate this case from + // a partial build where other children exist but we just didn't build them + // this time. + // TODO:RetainedDisplayListBuilder's merge phase has the full list and + // could strip them out. + + return MakeDisplayItem<nsDisplayContainer>(aBuilder, aFrame, aContainerASR, + aList); +} + +/** + * Check if a frame should be visited for building display list. + */ +static bool DescendIntoChild(nsDisplayListBuilder* aBuilder, + const nsIFrame* aChild, const nsRect& aVisible, + const nsRect& aDirty) { + if (aChild->HasAnyStateBits(NS_FRAME_FORCE_DISPLAY_LIST_DESCEND_INTO)) { + return true; + } + + // If the child is a scrollframe that we want to ignore, then we need + // to descend into it because its scrolled child may intersect the dirty + // area even if the scrollframe itself doesn't. + if (aChild == aBuilder->GetIgnoreScrollFrame()) { + return true; + } + + // There are cases where the "ignore scroll frame" on the builder is not set + // correctly, and so we additionally want to catch cases where the child is + // a root scrollframe and we are ignoring scrolling on the viewport. + if (aChild == aBuilder->GetPresShellIgnoreScrollFrame()) { + return true; + } + + nsRect overflow = aChild->InkOverflowRect(); + + // On mobile, there may be a dynamic toolbar. The root content document's + // root scroll frame's ink overflow rect does not include the toolbar + // height, but if the toolbar is hidden, we still want to be able to target + // content underneath the toolbar, so expand the overflow rect here to + // allow display list building to descend into the scroll frame. + if (aBuilder->IsForEventDelivery() && + aChild == aChild->PresShell()->GetRootScrollFrame() && + aChild->PresContext()->IsRootContentDocumentCrossProcess() && + aChild->PresContext()->HasDynamicToolbar()) { + overflow.SizeTo(nsLayoutUtils::ExpandHeightForDynamicToolbar( + aChild->PresContext(), overflow.Size())); + } + + if (aDirty.Intersects(overflow)) { + return true; + } + + if (aChild->ForceDescendIntoIfVisible() && aVisible.Intersects(overflow)) { + return true; + } + + if (aChild->IsFrameOfType(nsIFrame::eTablePart)) { + // Relative positioning and transforms can cause table parts to move, but we + // will still paint the backgrounds for their ancestor parts under them at + // their 'normal' position. That means that we must consider the overflow + // rects at both positions. + + // We convert the overflow rect into the nsTableFrame's coordinate + // space, applying the normal position offset at each step. Then we + // compare that against the builder's cached dirty rect in table + // coordinate space. + const nsIFrame* f = aChild; + nsRect normalPositionOverflowRelativeToTable = overflow; + + while (f->IsFrameOfType(nsIFrame::eTablePart)) { + normalPositionOverflowRelativeToTable += f->GetNormalPosition(); + f = f->GetParent(); + } + + nsDisplayTableBackgroundSet* tableBGs = aBuilder->GetTableBackgroundSet(); + if (tableBGs && tableBGs->GetDirtyRect().Intersects( + normalPositionOverflowRelativeToTable)) { + return true; + } + } + + return false; +} + +void nsIFrame::BuildDisplayListForSimpleChild(nsDisplayListBuilder* aBuilder, + nsIFrame* aChild, + const nsDisplayListSet& aLists) { + // This is the shortcut for frames been handled along the common + // path, the most common one of THE COMMON CASE mentioned later. + MOZ_ASSERT(aChild->Type() != LayoutFrameType::Placeholder); + MOZ_ASSERT(!aBuilder->GetSelectedFramesOnly() && + !aBuilder->GetIncludeAllOutOfFlows(), + "It should be held for painting to window"); + MOZ_ASSERT(aChild->HasAnyStateBits(NS_FRAME_SIMPLE_DISPLAYLIST)); + + const nsPoint offset = aChild->GetOffsetTo(this); + const nsRect visible = aBuilder->GetVisibleRect() - offset; + const nsRect dirty = aBuilder->GetDirtyRect() - offset; + + if (!DescendIntoChild(aBuilder, aChild, visible, dirty)) { + DL_LOGV("Skipped frame %p", aChild); + return; + } + + // Child cannot be transformed since it is not a stacking context. + nsDisplayListBuilder::AutoBuildingDisplayList buildingForChild( + aBuilder, aChild, visible, dirty, false); + + UpdateCurrentHitTestInfo(aBuilder, aChild); + + aChild->MarkAbsoluteFramesForDisplayList(aBuilder); + aBuilder->AdjustWindowDraggingRegion(aChild); + aBuilder->Check(); + aChild->BuildDisplayList(aBuilder, aLists); + aChild->SetBuiltDisplayList(true); + aBuilder->Check(); + aBuilder->DisplayCaret(aChild, aLists.Outlines()); +} + +static bool ShouldSkipFrame(nsDisplayListBuilder* aBuilder, + const nsIFrame* aFrame) { + // If painting is restricted to just the background of the top level frame, + // then we have nothing to do here. + if (aBuilder->IsBackgroundOnly()) { + return true; + } + if (aBuilder->IsForGenerateGlyphMask() && + (!aFrame->IsTextFrame() && aFrame->IsLeaf())) { + return true; + } + // The placeholder frame should have the same content as the OOF frame. + if (aBuilder->GetSelectedFramesOnly() && + (aFrame->IsLeaf() && !aFrame->IsSelected())) { + return true; + } + static const nsFrameState skipFlags = + (NS_FRAME_TOO_DEEP_IN_FRAME_TREE | NS_FRAME_IS_NONDISPLAY); + if (aFrame->HasAnyStateBits(skipFlags)) { + return true; + } + return aFrame->StyleUIReset()->mMozSubtreeHiddenOnlyVisually; +} + +void nsIFrame::BuildDisplayListForChild(nsDisplayListBuilder* aBuilder, + nsIFrame* aChild, + const nsDisplayListSet& aLists, + DisplayChildFlags aFlags) { + AutoCheckBuilder check(aBuilder); +#ifdef DEBUG + DL_LOGV("BuildDisplayListForChild (%p) <", aChild); + ScopeExit e( + [aChild]() { DL_LOGV("> BuildDisplayListForChild (%p)", aChild); }); +#endif + + if (ShouldSkipFrame(aBuilder, aChild)) { + return; + } + + if (HidesContent()) { + return; + } + + // If we're generating a display list for printing, include Link items for + // frames that correspond to HTML link elements so that we can have active + // links in saved PDF output. Note that the state of "within a link" is + // set on the display-list builder, such that all descendants of the link + // element will generate display-list links. + // TODO: we should be able to optimize this so as to avoid creating links + // for the same destination that entirely overlap each other, which adds + // nothing useful to the final PDF. + Maybe<nsDisplayListBuilder::Linkifier> linkifier; + if (StaticPrefs::print_save_as_pdf_links_enabled() && + aBuilder->IsForPrinting()) { + linkifier.emplace(aBuilder, aChild, aLists.Content()); + linkifier->MaybeAppendLink(aBuilder, aChild); + } + + nsIFrame* child = aChild; + auto* placeholder = child->IsPlaceholderFrame() + ? static_cast<nsPlaceholderFrame*>(child) + : nullptr; + nsIFrame* childOrOutOfFlow = + placeholder ? placeholder->GetOutOfFlowFrame() : child; + + nsIFrame* parent = childOrOutOfFlow->GetParent(); + const auto* parentDisplay = parent->StyleDisplay(); + const auto overflowClipAxes = + parent->ShouldApplyOverflowClipping(parentDisplay); + + const bool isPaintingToWindow = aBuilder->IsPaintingToWindow(); + const bool doingShortcut = + isPaintingToWindow && + child->HasAnyStateBits(NS_FRAME_SIMPLE_DISPLAYLIST) && + // Animations may change the stacking context state. + // ShouldApplyOverflowClipping is affected by the parent style, which does + // not invalidate the NS_FRAME_SIMPLE_DISPLAYLIST bit. + !(overflowClipAxes != PhysicalAxes::None || + child->MayHaveTransformAnimation() || child->MayHaveOpacityAnimation()); + + if (aBuilder->IsForPainting()) { + aBuilder->ClearWillChangeBudgetStatus(child); + } + + if (StaticPrefs::layout_css_scroll_anchoring_highlight()) { + if (child->FirstContinuation()->IsScrollAnchor()) { + nsRect bounds = child->GetContentRectRelativeToSelf() + + aBuilder->ToReferenceFrame(child); + nsDisplaySolidColor* color = MakeDisplayItem<nsDisplaySolidColor>( + aBuilder, child, bounds, NS_RGBA(255, 0, 255, 64)); + if (color) { + color->SetOverrideZIndex(INT32_MAX); + aLists.PositionedDescendants()->AppendToTop(color); + } + } + } + + if (doingShortcut) { + BuildDisplayListForSimpleChild(aBuilder, child, aLists); + return; + } + + // dirty rect in child-relative coordinates + NS_ASSERTION(aBuilder->GetCurrentFrame() == this, "Wrong coord space!"); + const nsPoint offset = child->GetOffsetTo(this); + nsRect visible = aBuilder->GetVisibleRect() - offset; + nsRect dirty = aBuilder->GetDirtyRect() - offset; + + nsDisplayListBuilder::OutOfFlowDisplayData* savedOutOfFlowData = nullptr; + if (placeholder) { + if (placeholder->HasAnyStateBits(PLACEHOLDER_FOR_TOPLAYER)) { + // If the out-of-flow frame is in the top layer, the viewport frame + // will paint it. Skip it here. Note that, only out-of-flow frames + // with this property should be skipped, because non-HTML elements + // may stop their children from being out-of-flow. Those frames + // should still be handled in the normal in-flow path. + return; + } + + child = childOrOutOfFlow; + if (aBuilder->IsForPainting()) { + aBuilder->ClearWillChangeBudgetStatus(child); + } + + // If 'child' is a pushed float then it's owned by a block that's not an + // ancestor of the placeholder, and it will be painted by that block and + // should not be painted through the placeholder. Also recheck + // NS_FRAME_TOO_DEEP_IN_FRAME_TREE and NS_FRAME_IS_NONDISPLAY. + static const nsFrameState skipFlags = + (NS_FRAME_IS_PUSHED_FLOAT | NS_FRAME_TOO_DEEP_IN_FRAME_TREE | + NS_FRAME_IS_NONDISPLAY); + if (child->HasAnyStateBits(skipFlags) || nsLayoutUtils::IsPopup(child)) { + return; + } + + MOZ_ASSERT(child->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW)); + savedOutOfFlowData = nsDisplayListBuilder::GetOutOfFlowData(child); + + if (aBuilder->GetIncludeAllOutOfFlows()) { + visible = child->InkOverflowRect(); + dirty = child->InkOverflowRect(); + } else if (savedOutOfFlowData) { + visible = + savedOutOfFlowData->GetVisibleRectForFrame(aBuilder, child, &dirty); + } else { + // The out-of-flow frame did not intersect the dirty area. We may still + // need to traverse into it, since it may contain placeholders we need + // to enter to reach other out-of-flow frames that are visible. + visible.SetEmpty(); + dirty.SetEmpty(); + } + } + + NS_ASSERTION(!child->IsPlaceholderFrame(), + "Should have dealt with placeholders already"); + + if (!DescendIntoChild(aBuilder, child, visible, dirty)) { + DL_LOGV("Skipped frame %p", child); + return; + } + + const bool isSVG = child->HasAnyStateBits(NS_FRAME_SVG_LAYOUT); + + // This flag is raised if the control flow strays off the common path. + // The common path is the most common one of THE COMMON CASE mentioned later. + bool awayFromCommonPath = !isPaintingToWindow; + + // true if this is a real or pseudo stacking context + bool pseudoStackingContext = + aFlags.contains(DisplayChildFlag::ForcePseudoStackingContext); + + if (!pseudoStackingContext && !isSVG && + aFlags.contains(DisplayChildFlag::Inline) && + !child->IsFrameOfType(eLineParticipant)) { + // child is a non-inline frame in an inline context, i.e., + // it acts like inline-block or inline-table. Therefore it is a + // pseudo-stacking-context. + pseudoStackingContext = true; + } + + const nsStyleDisplay* ourDisp = StyleDisplay(); + // Don't paint our children if the theme object is a leaf. + if (IsThemed(ourDisp) && !PresContext()->Theme()->WidgetIsContainer( + ourDisp->EffectiveAppearance())) { + return; + } + + // Since we're now sure that we're adding this frame to the display list + // (which means we're painting it, modulo occlusion), mark it as visible + // within the displayport. + if (isPaintingToWindow && child->TrackingVisibility() && + child->IsVisibleForPainting()) { + child->PresShell()->EnsureFrameInApproximatelyVisibleList(child); + awayFromCommonPath = true; + } + + // Child is composited if it's transformed, partially transparent, or has + // SVG effects or a blend mode.. + const nsStyleDisplay* disp = child->StyleDisplay(); + const nsStyleEffects* effects = child->StyleEffects(); + + const bool isPositioned = disp->IsPositionedStyle(); + const bool isStackingContext = + aFlags.contains(DisplayChildFlag::ForceStackingContext) || + child->IsStackingContext(disp, effects); + + if (pseudoStackingContext || isStackingContext || isPositioned || + placeholder || (!isSVG && disp->IsFloating(child)) || + (isSVG && effects->mClip.IsRect() && IsSVGContentWithCSSClip(child))) { + pseudoStackingContext = true; + awayFromCommonPath = true; + } + + NS_ASSERTION(!isStackingContext || pseudoStackingContext, + "Stacking contexts must also be pseudo-stacking-contexts"); + + nsDisplayListBuilder::AutoBuildingDisplayList buildingForChild( + aBuilder, child, visible, dirty); + + UpdateCurrentHitTestInfo(aBuilder, child); + + DisplayListClipState::AutoClipMultiple clipState(aBuilder); + nsDisplayListBuilder::AutoCurrentActiveScrolledRootSetter asrSetter(aBuilder); + + if (savedOutOfFlowData) { + aBuilder->SetBuildingInvisibleItems(false); + + clipState.SetClipChainForContainingBlockDescendants( + savedOutOfFlowData->mContainingBlockClipChain); + asrSetter.SetCurrentActiveScrolledRoot( + savedOutOfFlowData->mContainingBlockActiveScrolledRoot); + asrSetter.SetCurrentScrollParentId(savedOutOfFlowData->mScrollParentId); + MOZ_ASSERT(awayFromCommonPath, + "It is impossible when savedOutOfFlowData is true"); + } else if (HasAnyStateBits(NS_FRAME_FORCE_DISPLAY_LIST_DESCEND_INTO) && + placeholder) { + NS_ASSERTION(visible.IsEmpty(), "should have empty visible rect"); + // Every item we build from now until we descent into an out of flow that + // does have saved out of flow data should be invisible. This state gets + // restored when AutoBuildingDisplayList gets out of scope. + aBuilder->SetBuildingInvisibleItems(true); + + // If we have nested out-of-flow frames and the outer one isn't visible + // then we won't have stored clip data for it. We can just clear the clip + // instead since we know we won't render anything, and the inner out-of-flow + // frame will setup the correct clip for itself. + clipState.SetClipChainForContainingBlockDescendants(nullptr); + } + + // Setup clipping for the parent's overflow:clip, + // or overflow:hidden on elements that don't support scrolling (and therefore + // don't create nsHTML/XULScrollFrame). This clipping needs to not clip + // anything directly rendered by the parent, only the rendering of its + // children. + // Don't use overflowClip to restrict the dirty rect, since some of the + // descendants may not be clipped by it. Even if we end up with unnecessary + // display items, they'll be pruned during ComputeVisibility. + // + // FIXME(emilio): Why can't we handle this more similarly to `clip` (on the + // parent, rather than on the children)? Would ClipContentDescendants do what + // we want? + if (overflowClipAxes != PhysicalAxes::None) { + ApplyOverflowClipping(aBuilder, parent, overflowClipAxes, clipState); + awayFromCommonPath = true; + } + + nsDisplayList list(aBuilder); + nsDisplayList extraPositionedDescendants(aBuilder); + const ActiveScrolledRoot* wrapListASR; + bool builtContainerItem = false; + if (isStackingContext) { + // True stacking context. + // For stacking contexts, BuildDisplayListForStackingContext handles + // clipping and MarkAbsoluteFramesForDisplayList. + nsDisplayListBuilder::AutoContainerASRTracker contASRTracker(aBuilder); + child->BuildDisplayListForStackingContext(aBuilder, &list, + &builtContainerItem); + wrapListASR = contASRTracker.GetContainerASR(); + if (!aBuilder->IsReusingStackingContextItems() && + aBuilder->GetCaretFrame() == child) { + builtContainerItem = false; + } + } else { + Maybe<nsRect> clipPropClip = + child->GetClipPropClipRect(disp, effects, child->GetSize()); + if (clipPropClip) { + aBuilder->IntersectVisibleRect(*clipPropClip); + aBuilder->IntersectDirtyRect(*clipPropClip); + clipState.ClipContentDescendants(*clipPropClip + + aBuilder->ToReferenceFrame(child)); + awayFromCommonPath = true; + } + + child->MarkAbsoluteFramesForDisplayList(aBuilder); + child->SetBuiltDisplayList(true); + + if (!awayFromCommonPath && + // Some SVG frames might change opacity without invalidating the frame, + // so exclude them from the fast-path. + !child->IsFrameOfType(nsIFrame::eSVG)) { + // The shortcut is available for the child for next time. + child->AddStateBits(NS_FRAME_SIMPLE_DISPLAYLIST); + } + + if (!pseudoStackingContext) { + // THIS IS THE COMMON CASE. + // Not a pseudo or real stacking context. Do the simple thing and + // return early. + aBuilder->AdjustWindowDraggingRegion(child); + aBuilder->Check(); + child->BuildDisplayList(aBuilder, aLists); + aBuilder->Check(); + aBuilder->DisplayCaret(child, aLists.Outlines()); + return; + } + + // A pseudo-stacking context (e.g., a positioned element with z-index auto). + // We allow positioned descendants of the child to escape to our parent + // stacking context's positioned descendant list, because they might be + // z-index:non-auto + nsDisplayListCollection pseudoStack(aBuilder); + + aBuilder->AdjustWindowDraggingRegion(child); + nsDisplayListBuilder::AutoContainerASRTracker contASRTracker(aBuilder); + aBuilder->Check(); + child->BuildDisplayList(aBuilder, pseudoStack); + aBuilder->Check(); + if (aBuilder->DisplayCaret(child, pseudoStack.Outlines())) { + builtContainerItem = false; + } + wrapListASR = contASRTracker.GetContainerASR(); + + list.AppendToTop(pseudoStack.BorderBackground()); + list.AppendToTop(pseudoStack.BlockBorderBackgrounds()); + list.AppendToTop(pseudoStack.Floats()); + list.AppendToTop(pseudoStack.Content()); + list.AppendToTop(pseudoStack.Outlines()); + extraPositionedDescendants.AppendToTop(pseudoStack.PositionedDescendants()); + } + + buildingForChild.RestoreBuildingInvisibleItemsValue(); + + if (!list.IsEmpty()) { + if (isPositioned || isStackingContext) { + // Genuine stacking contexts, and positioned pseudo-stacking-contexts, + // go in this level. + nsDisplayItem* item = WrapInWrapList(aBuilder, child, &list, wrapListASR, + builtContainerItem); + if (isSVG) { + aLists.Content()->AppendToTop(item); + } else { + aLists.PositionedDescendants()->AppendToTop(item); + } + } else if (!isSVG && disp->IsFloating(child)) { + aLists.Floats()->AppendToTop( + WrapInWrapList(aBuilder, child, &list, wrapListASR)); + } else { + aLists.Content()->AppendToTop(&list); + } + } + // We delay placing the positioned descendants of positioned frames to here, + // because in the absence of z-index this is the correct order for them. + // This doesn't affect correctness because the positioned descendants list + // is sorted by z-order and content in BuildDisplayListForStackingContext, + // but it means that sort routine needs to do less work. + aLists.PositionedDescendants()->AppendToTop(&extraPositionedDescendants); +} + +void nsIFrame::MarkAbsoluteFramesForDisplayList( + nsDisplayListBuilder* aBuilder) { + if (IsAbsoluteContainer()) { + aBuilder->MarkFramesForDisplayList( + this, GetAbsoluteContainingBlock()->GetChildList()); + } +} + +nsresult nsIFrame::GetContentForEvent(const WidgetEvent* aEvent, + nsIContent** aContent) { + nsIFrame* f = nsLayoutUtils::GetNonGeneratedAncestor(this); + *aContent = f->GetContent(); + NS_IF_ADDREF(*aContent); + return NS_OK; +} + +void nsIFrame::FireDOMEvent(const nsAString& aDOMEventName, + nsIContent* aContent) { + nsIContent* target = aContent ? aContent : GetContent(); + + if (target) { + RefPtr<AsyncEventDispatcher> asyncDispatcher = new AsyncEventDispatcher( + target, aDOMEventName, CanBubble::eYes, ChromeOnlyDispatch::eNo); + DebugOnly<nsresult> rv = asyncDispatcher->PostDOMEvent(); + NS_ASSERTION(NS_SUCCEEDED(rv), "AsyncEventDispatcher failed to dispatch"); + } +} + +nsresult nsIFrame::HandleEvent(nsPresContext* aPresContext, + WidgetGUIEvent* aEvent, + nsEventStatus* aEventStatus) { + if (aEvent->mMessage == eMouseMove) { + // XXX If the second argument of HandleDrag() is WidgetMouseEvent, + // the implementation becomes simpler. + return HandleDrag(aPresContext, aEvent, aEventStatus); + } + + if ((aEvent->mClass == eMouseEventClass && + aEvent->AsMouseEvent()->mButton == MouseButton::ePrimary) || + aEvent->mClass == eTouchEventClass) { + if (aEvent->mMessage == eMouseDown || aEvent->mMessage == eTouchStart) { + HandlePress(aPresContext, aEvent, aEventStatus); + } else if (aEvent->mMessage == eMouseUp || aEvent->mMessage == eTouchEnd) { + HandleRelease(aPresContext, aEvent, aEventStatus); + } + return NS_OK; + } + + // When middle button is down, we need to just move selection and focus at + // the clicked point. Note that even if middle click paste is not enabled, + // Chrome moves selection at middle mouse button down. So, we should follow + // the behavior for the compatibility. + if (aEvent->mMessage == eMouseDown) { + WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent(); + if (mouseEvent && mouseEvent->mButton == MouseButton::eMiddle) { + if (*aEventStatus == nsEventStatus_eConsumeNoDefault) { + return NS_OK; + } + return MoveCaretToEventPoint(aPresContext, mouseEvent, aEventStatus); + } + } + + return NS_OK; +} + +nsresult nsIFrame::GetDataForTableSelection( + const nsFrameSelection* aFrameSelection, mozilla::PresShell* aPresShell, + WidgetMouseEvent* aMouseEvent, nsIContent** aParentContent, + int32_t* aContentOffset, TableSelectionMode* aTarget) { + if (!aFrameSelection || !aPresShell || !aMouseEvent || !aParentContent || + !aContentOffset || !aTarget) + return NS_ERROR_NULL_POINTER; + + *aParentContent = nullptr; + *aContentOffset = 0; + *aTarget = TableSelectionMode::None; + + int16_t displaySelection = aPresShell->GetSelectionFlags(); + + bool selectingTableCells = aFrameSelection->IsInTableSelectionMode(); + + // DISPLAY_ALL means we're in an editor. + // If already in cell selection mode, + // continue selecting with mouse drag or end on mouse up, + // or when using shift key to extend block of cells + // (Mouse down does normal selection unless Ctrl/Cmd is pressed) + bool doTableSelection = + displaySelection == nsISelectionDisplay::DISPLAY_ALL && + selectingTableCells && + (aMouseEvent->mMessage == eMouseMove || + (aMouseEvent->mMessage == eMouseUp && + aMouseEvent->mButton == MouseButton::ePrimary) || + aMouseEvent->IsShift()); + + if (!doTableSelection) { + // In Browser, special 'table selection' key must be pressed for table + // selection or when just Shift is pressed and we're already in table/cell + // selection mode +#ifdef XP_MACOSX + doTableSelection = aMouseEvent->IsMeta() || + (aMouseEvent->IsShift() && selectingTableCells); +#else + doTableSelection = aMouseEvent->IsControl() || + (aMouseEvent->IsShift() && selectingTableCells); +#endif + } + if (!doTableSelection) return NS_OK; + + // Get the cell frame or table frame (or parent) of the current content node + nsIFrame* frame = this; + bool foundCell = false; + bool foundTable = false; + + // Get the limiting node to stop parent frame search + nsIContent* limiter = aFrameSelection->GetLimiter(); + + // If our content node is an ancestor of the limiting node, + // we should stop the search right now. + if (limiter && limiter->IsInclusiveDescendantOf(GetContent())) return NS_OK; + + // We don't initiate row/col selection from here now, + // but we may in future + // bool selectColumn = false; + // bool selectRow = false; + + while (frame) { + // Check for a table cell by querying to a known CellFrame interface + nsITableCellLayout* cellElement = do_QueryFrame(frame); + if (cellElement) { + foundCell = true; + // TODO: If we want to use proximity to top or left border + // for row and column selection, this is the place to do it + break; + } else { + // If not a cell, check for table + // This will happen when starting frame is the table or child of a table, + // such as a row (we were inbetween cells or in table border) + nsTableWrapperFrame* tableFrame = do_QueryFrame(frame); + if (tableFrame) { + foundTable = true; + // TODO: How can we select row when along left table edge + // or select column when along top edge? + break; + } else { + frame = frame->GetParent(); + // Stop if we have hit the selection's limiting content node + if (frame && frame->GetContent() == limiter) break; + } + } + } + // We aren't in a cell or table + if (!foundCell && !foundTable) return NS_OK; + + nsIContent* tableOrCellContent = frame->GetContent(); + if (!tableOrCellContent) return NS_ERROR_FAILURE; + + nsCOMPtr<nsIContent> parentContent = tableOrCellContent->GetParent(); + if (!parentContent) return NS_ERROR_FAILURE; + + const int32_t offset = + parentContent->ComputeIndexOf_Deprecated(tableOrCellContent); + // Not likely? + if (offset < 0) { + return NS_ERROR_FAILURE; + } + + // Everything is OK -- set the return values + parentContent.forget(aParentContent); + + *aContentOffset = offset; + +#if 0 + if (selectRow) + *aTarget = TableSelectionMode::Row; + else if (selectColumn) + *aTarget = TableSelectionMode::Column; + else +#endif + if (foundCell) { + *aTarget = TableSelectionMode::Cell; + } else if (foundTable) { + *aTarget = TableSelectionMode::Table; + } + + return NS_OK; +} + +static bool IsEditingHost(const nsIFrame* aFrame) { + auto* element = nsGenericHTMLElement::FromNodeOrNull(aFrame->GetContent()); + return element && element->IsEditableRoot(); +} + +static StyleUserSelect UsedUserSelect(const nsIFrame* aFrame) { + if (aFrame->IsGeneratedContentFrame()) { + return StyleUserSelect::None; + } + + // Per https://drafts.csswg.org/css-ui-4/#content-selection: + // + // The used value is the same as the computed value, except: + // + // 1 - on editable elements where the used value is always 'contain' + // regardless of the computed value + // 2 - when the computed value is auto, in which case the used value is one + // of the other values... + // + // See https://github.com/w3c/csswg-drafts/issues/3344 to see why we do this + // at used-value time instead of at computed-value time. + + if (aFrame->IsTextInputFrame() || IsEditingHost(aFrame)) { + // We don't implement 'contain' itself, but we make 'text' behave as + // 'contain' for contenteditable and <input> / <textarea> elements anyway so + // this is ok. + return StyleUserSelect::Text; + } + + auto style = aFrame->Style()->UserSelect(); + if (style != StyleUserSelect::Auto) { + return style; + } + + auto* parent = nsLayoutUtils::GetParentOrPlaceholderFor(aFrame); + return parent ? UsedUserSelect(parent) : StyleUserSelect::Text; +} + +bool nsIFrame::IsSelectable(StyleUserSelect* aSelectStyle) const { + auto style = UsedUserSelect(this); + if (aSelectStyle) { + *aSelectStyle = style; + } + return style != StyleUserSelect::None; +} + +bool nsIFrame::ShouldHaveLineIfEmpty() const { + if (Style()->IsPseudoOrAnonBox() && + Style()->GetPseudoType() != PseudoStyleType::scrolledContent) { + return false; + } + return IsEditingHost(this); +} + +/** + * Handles the Mouse Press Event for the frame + */ +NS_IMETHODIMP +nsIFrame::HandlePress(nsPresContext* aPresContext, WidgetGUIEvent* aEvent, + nsEventStatus* aEventStatus) { + NS_ENSURE_ARG_POINTER(aEventStatus); + if (nsEventStatus_eConsumeNoDefault == *aEventStatus) { + return NS_OK; + } + + NS_ENSURE_ARG_POINTER(aEvent); + if (aEvent->mClass == eTouchEventClass) { + return NS_OK; + } + + return MoveCaretToEventPoint(aPresContext, aEvent->AsMouseEvent(), + aEventStatus); +} + +nsresult nsIFrame::MoveCaretToEventPoint(nsPresContext* aPresContext, + WidgetMouseEvent* aMouseEvent, + nsEventStatus* aEventStatus) { + MOZ_ASSERT(aPresContext); + MOZ_ASSERT(aMouseEvent); + MOZ_ASSERT(aMouseEvent->mMessage == eMouseDown); + MOZ_ASSERT(aMouseEvent->mButton == MouseButton::ePrimary || + aMouseEvent->mButton == MouseButton::eMiddle); + MOZ_ASSERT(aEventStatus); + MOZ_ASSERT(nsEventStatus_eConsumeNoDefault != *aEventStatus); + + mozilla::PresShell* presShell = aPresContext->GetPresShell(); + if (!presShell) { + return NS_ERROR_FAILURE; + } + + // We often get out of sync state issues with mousedown events that + // get interrupted by alerts/dialogs. + // Check with the ESM to see if we should process this one + if (!aPresContext->EventStateManager()->EventStatusOK(aMouseEvent)) { + return NS_OK; + } + + const nsPoint pt = nsLayoutUtils::GetEventCoordinatesRelativeTo( + aMouseEvent, RelativeTo{this}); + + // When not using `alt`, and clicking on a draggable, but non-editable + // element, don't do anything, and let d&d handle the event. + // + // See bug 48876, bug 388659 and bug 55921 for context here. + // + // FIXME(emilio): The .Contains(pt) check looks a bit fishy. When would it be + // false given we're the event target? If it is needed, why not checking the + // actual draggable node rect instead? + if (!aMouseEvent->IsAlt() && GetRectRelativeToSelf().Contains(pt)) { + for (nsIContent* content = mContent; content; + content = content->GetFlattenedTreeParent()) { + if (nsContentUtils::ContentIsDraggable(content) && + !content->IsEditable()) { + return NS_OK; + } + } + } + + // If we are in Navigator and the click is in a draggable node, we don't want + // to start selection because we don't want to interfere with a potential + // drag of said node and steal all its glory. + const bool isEditor = + presShell->GetSelectionFlags() == nsISelectionDisplay::DISPLAY_ALL; + + // Don't do something if it's middle button down event. + const bool isPrimaryButtonDown = + aMouseEvent->mButton == MouseButton::ePrimary; + + // check whether style allows selection + // if not, don't tell selection the mouse event even occurred. + StyleUserSelect selectStyle; + // check for select: none + if (!IsSelectable(&selectStyle)) { + return NS_OK; + } + + if (isPrimaryButtonDown) { + // If the mouse is dragged outside the nearest enclosing scrollable area + // while making a selection, the area will be scrolled. To do this, capture + // the mouse on the nearest scrollable frame. If there isn't a scrollable + // frame, or something else is already capturing the mouse, there's no + // reason to capture. + if (!PresShell::GetCapturingContent()) { + nsIScrollableFrame* scrollFrame = + nsLayoutUtils::GetNearestScrollableFrame( + this, nsLayoutUtils::SCROLLABLE_SAME_DOC | + nsLayoutUtils::SCROLLABLE_INCLUDE_HIDDEN); + if (scrollFrame) { + nsIFrame* capturingFrame = do_QueryFrame(scrollFrame); + PresShell::SetCapturingContent(capturingFrame->GetContent(), + CaptureFlags::IgnoreAllowedState); + } + } + } + + // XXX This is screwy; it really should use the selection frame, not the + // event frame + const nsFrameSelection* frameselection = + selectStyle == StyleUserSelect::Text ? GetConstFrameSelection() + : presShell->ConstFrameSelection(); + + if (!frameselection || frameselection->GetDisplaySelection() == + nsISelectionController::SELECTION_OFF) { + return NS_OK; // nothing to do we cannot affect selection from here + } + +#ifdef XP_MACOSX + // If Control key is pressed on macOS, it should be treated as right click. + // So, don't change selection. + if (aMouseEvent->IsControl()) { + return NS_OK; + } + const bool control = aMouseEvent->IsMeta(); +#else + const bool control = aMouseEvent->IsControl(); +#endif + + RefPtr<nsFrameSelection> fc = const_cast<nsFrameSelection*>(frameselection); + if (isPrimaryButtonDown && aMouseEvent->mClickCount > 1) { + // These methods aren't const but can't actually delete anything, + // so no need for AutoWeakFrame. + fc->SetDragState(true); + return HandleMultiplePress(aPresContext, aMouseEvent, aEventStatus, + control); + } + + ContentOffsets offsets = GetContentOffsetsFromPoint(pt, SKIP_HIDDEN); + + if (!offsets.content) { + return NS_ERROR_FAILURE; + } + + if (aMouseEvent->mMessage == eMouseDown && + aMouseEvent->mButton == MouseButton::eMiddle && + !offsets.content->IsEditable()) { + // However, some users don't like the Chrome compatible behavior of + // middle mouse click. They want to keep selection after starting + // autoscroll. However, the selection change is important for middle + // mouse past. Therefore, we should allow users to take the traditional + // behavior back by themselves unless middle click paste is enabled or + // autoscrolling is disabled. + if (!Preferences::GetBool("middlemouse.paste", false) && + Preferences::GetBool("general.autoScroll", false) && + Preferences::GetBool("general.autoscroll.prevent_to_collapse_selection_" + "by_middle_mouse_down", + false)) { + return NS_OK; + } + } + + if (isPrimaryButtonDown) { + // Let Ctrl/Cmd + left mouse down do table selection instead of drag + // initiation. + nsCOMPtr<nsIContent> parentContent; + int32_t contentOffset; + TableSelectionMode target; + nsresult rv = GetDataForTableSelection( + frameselection, presShell, aMouseEvent, getter_AddRefs(parentContent), + &contentOffset, &target); + if (NS_SUCCEEDED(rv) && parentContent) { + fc->SetDragState(true); + return fc->HandleTableSelection(parentContent, contentOffset, target, + aMouseEvent); + } + } + + fc->SetDelayedCaretData(0); + + if (isPrimaryButtonDown) { + // Check if any part of this frame is selected, and if the user clicked + // inside the selected region, and if it's the left button. If so, we delay + // starting a new selection since the user may be trying to drag the + // selected region to some other app. + + if (GetContent() && GetContent()->IsMaybeSelected()) { + bool inSelection = false; + UniquePtr<SelectionDetails> details = frameselection->LookUpSelection( + offsets.content, 0, offsets.EndOffset(), false); + + // + // If there are any details, check to see if the user clicked + // within any selected region of the frame. + // + + for (SelectionDetails* curDetail = details.get(); curDetail; + curDetail = curDetail->mNext.get()) { + // + // If the user clicked inside a selection, then just + // return without doing anything. We will handle placing + // the caret later on when the mouse is released. We ignore + // the spellcheck, find and url formatting selections. + // + if (curDetail->mSelectionType != SelectionType::eSpellCheck && + curDetail->mSelectionType != SelectionType::eFind && + curDetail->mSelectionType != SelectionType::eURLSecondary && + curDetail->mSelectionType != SelectionType::eURLStrikeout && + curDetail->mSelectionType != SelectionType::eHighlight && + curDetail->mStart <= offsets.StartOffset() && + offsets.EndOffset() <= curDetail->mEnd) { + inSelection = true; + } + } + + if (inSelection) { + fc->SetDragState(false); + fc->SetDelayedCaretData(aMouseEvent); + return NS_OK; + } + } + + fc->SetDragState(true); + } + + // Do not touch any nsFrame members after this point without adding + // weakFrame checks. + const nsFrameSelection::FocusMode focusMode = [&]() { + // If "Shift" and "Ctrl" are both pressed, "Shift" is given precedence. This + // mimics the old behaviour. + if (aMouseEvent->IsShift()) { + // If clicked in a link when focused content is editable, we should + // collapse selection in the link for compatibility with Blink. + if (isEditor) { + for (Element* element : mContent->InclusiveAncestorsOfType<Element>()) { + if (element->IsLink()) { + return nsFrameSelection::FocusMode::kCollapseToNewPoint; + } + } + } + return nsFrameSelection::FocusMode::kExtendSelection; + } + + if (isPrimaryButtonDown && control) { + return nsFrameSelection::FocusMode::kMultiRangeSelection; + } + + return nsFrameSelection::FocusMode::kCollapseToNewPoint; + }(); + + nsresult rv = fc->HandleClick( + MOZ_KnownLive(offsets.content) /* bug 1636889 */, offsets.StartOffset(), + offsets.EndOffset(), focusMode, offsets.associate); + if (NS_FAILED(rv)) { + return rv; + } + + // We don't handle mouse button up if it's middle button. + if (isPrimaryButtonDown && offsets.offset != offsets.secondaryOffset) { + fc->MaintainSelection(); + } + + if (isPrimaryButtonDown && isEditor && !aMouseEvent->IsShift() && + (offsets.EndOffset() - offsets.StartOffset()) == 1) { + // A single node is selected and we aren't extending an existing selection, + // which means the user clicked directly on an object (either + // `user-select: all` or a non-text node without children). Therefore, + // disable selection extension during mouse moves. + // XXX This is a bit hacky; shouldn't editor be able to deal with this? + fc->SetDragState(false); + } + + return NS_OK; +} + +nsresult nsIFrame::SelectByTypeAtPoint(nsPresContext* aPresContext, + const nsPoint& aPoint, + nsSelectionAmount aBeginAmountType, + nsSelectionAmount aEndAmountType, + uint32_t aSelectFlags) { + NS_ENSURE_ARG_POINTER(aPresContext); + + // No point in selecting if selection is turned off + if (DetermineDisplaySelection() == nsISelectionController::SELECTION_OFF) { + return NS_OK; + } + + ContentOffsets offsets = GetContentOffsetsFromPoint(aPoint, SKIP_HIDDEN); + if (!offsets.content) { + return NS_ERROR_FAILURE; + } + + int32_t offset; + nsIFrame* frame = nsFrameSelection::GetFrameForNodeOffset( + offsets.content, offsets.offset, offsets.associate, &offset); + if (!frame) { + return NS_ERROR_FAILURE; + } + return frame->PeekBackwardAndForward(aBeginAmountType, aEndAmountType, offset, + aBeginAmountType != eSelectWord, + aSelectFlags); +} + +/** + * Multiple Mouse Press -- line or paragraph selection -- for the frame. + * Wouldn't it be nice if this didn't have to be hardwired into Frame code? + */ +NS_IMETHODIMP +nsIFrame::HandleMultiplePress(nsPresContext* aPresContext, + WidgetGUIEvent* aEvent, + nsEventStatus* aEventStatus, bool aControlHeld) { + NS_ENSURE_ARG_POINTER(aEvent); + NS_ENSURE_ARG_POINTER(aEventStatus); + + if (nsEventStatus_eConsumeNoDefault == *aEventStatus || + DetermineDisplaySelection() == nsISelectionController::SELECTION_OFF) { + return NS_OK; + } + + // Find out whether we're doing line or paragraph selection. + // If browser.triple_click_selects_paragraph is true, triple-click selects + // paragraph. Otherwise, triple-click selects line, and quadruple-click + // selects paragraph (on platforms that support quadruple-click). + nsSelectionAmount beginAmount, endAmount; + WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent(); + if (!mouseEvent) { + return NS_OK; + } + + if (mouseEvent->mClickCount == 4) { + beginAmount = endAmount = eSelectParagraph; + } else if (mouseEvent->mClickCount == 3) { + if (Preferences::GetBool("browser.triple_click_selects_paragraph")) { + beginAmount = endAmount = eSelectParagraph; + } else { + beginAmount = eSelectBeginLine; + endAmount = eSelectEndLine; + } + } else if (mouseEvent->mClickCount == 2) { + // We only want inline frames; PeekBackwardAndForward dislikes blocks + beginAmount = endAmount = eSelectWord; + } else { + return NS_OK; + } + + nsPoint relPoint = nsLayoutUtils::GetEventCoordinatesRelativeTo( + mouseEvent, RelativeTo{this}); + return SelectByTypeAtPoint(aPresContext, relPoint, beginAmount, endAmount, + (aControlHeld ? SELECT_ACCUMULATE : 0)); +} + +nsresult nsIFrame::PeekBackwardAndForward(nsSelectionAmount aAmountBack, + nsSelectionAmount aAmountForward, + int32_t aStartPos, bool aJumpLines, + uint32_t aSelectFlags) { + nsIFrame* baseFrame = this; + int32_t baseOffset = aStartPos; + nsresult rv; + + PeekOffsetOptions peekOffsetOptions{PeekOffsetOption::ScrollViewStop}; + if (aJumpLines) { + peekOffsetOptions += PeekOffsetOption::JumpLines; + } + + if (aAmountBack == eSelectWord) { + // To avoid selecting the previous word when at start of word, + // first move one character forward. + PeekOffsetStruct pos(eSelectCharacter, eDirNext, aStartPos, nsPoint(0, 0), + peekOffsetOptions); + rv = PeekOffset(&pos); + if (NS_SUCCEEDED(rv)) { + baseFrame = pos.mResultFrame; + baseOffset = pos.mContentOffset; + } + } + + // Search backward for a boundary. + PeekOffsetStruct startpos(aAmountBack, eDirPrevious, baseOffset, + nsPoint(0, 0), peekOffsetOptions); + rv = baseFrame->PeekOffset(&startpos); + if (NS_FAILED(rv)) { + return rv; + } + + // If the backward search stayed within the same frame, search forward from + // that position for the end boundary; but if it crossed out to a sibling or + // ancestor, start from the original position. + if (startpos.mResultFrame == baseFrame) { + baseOffset = startpos.mContentOffset; + } else { + baseFrame = this; + baseOffset = aStartPos; + } + + PeekOffsetStruct endpos(aAmountForward, eDirNext, baseOffset, nsPoint(0, 0), + peekOffsetOptions); + rv = baseFrame->PeekOffset(&endpos); + if (NS_FAILED(rv)) { + return rv; + } + + // Keep frameSelection alive. + RefPtr<nsFrameSelection> frameSelection = GetFrameSelection(); + + const nsFrameSelection::FocusMode focusMode = + (aSelectFlags & SELECT_ACCUMULATE) + ? nsFrameSelection::FocusMode::kMultiRangeSelection + : nsFrameSelection::FocusMode::kCollapseToNewPoint; + rv = frameSelection->HandleClick( + MOZ_KnownLive(startpos.mResultContent) /* bug 1636889 */, + startpos.mContentOffset, startpos.mContentOffset, focusMode, + CARET_ASSOCIATE_AFTER); + if (NS_FAILED(rv)) { + return rv; + } + + rv = frameSelection->HandleClick( + MOZ_KnownLive(endpos.mResultContent) /* bug 1636889 */, + endpos.mContentOffset, endpos.mContentOffset, + nsFrameSelection::FocusMode::kExtendSelection, CARET_ASSOCIATE_BEFORE); + if (NS_FAILED(rv)) { + return rv; + } + if (aAmountBack == eSelectWord) { + frameSelection->SetIsDoubleClickSelection(true); + } + + // maintain selection + return frameSelection->MaintainSelection(aAmountBack); +} + +NS_IMETHODIMP nsIFrame::HandleDrag(nsPresContext* aPresContext, + WidgetGUIEvent* aEvent, + nsEventStatus* aEventStatus) { + MOZ_ASSERT(aEvent->mClass == eMouseEventClass, + "HandleDrag can only handle mouse event"); + + NS_ENSURE_ARG_POINTER(aEventStatus); + + RefPtr<nsFrameSelection> frameselection = GetFrameSelection(); + if (!frameselection) { + return NS_OK; + } + + bool mouseDown = frameselection->GetDragState(); + if (!mouseDown) { + return NS_OK; + } + + nsIFrame* scrollbar = + nsLayoutUtils::GetClosestFrameOfType(this, LayoutFrameType::Scrollbar); + if (!scrollbar) { + // XXX Do we really need to exclude non-selectable content here? + // GetContentOffsetsFromPoint can handle it just fine, although some + // other stuff might not like it. + // NOTE: DetermineDisplaySelection() returns SELECTION_OFF for + // non-selectable frames. + if (DetermineDisplaySelection() == nsISelectionController::SELECTION_OFF) { + return NS_OK; + } + } + + frameselection->StopAutoScrollTimer(); + + // Check if we are dragging in a table cell + nsCOMPtr<nsIContent> parentContent; + int32_t contentOffset; + TableSelectionMode target; + WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent(); + mozilla::PresShell* presShell = aPresContext->PresShell(); + nsresult result; + result = GetDataForTableSelection(frameselection, presShell, mouseEvent, + getter_AddRefs(parentContent), + &contentOffset, &target); + + AutoWeakFrame weakThis = this; + if (NS_SUCCEEDED(result) && parentContent) { + result = frameselection->HandleTableSelection(parentContent, contentOffset, + target, mouseEvent); + if (NS_WARN_IF(NS_FAILED(result))) { + return result; + } + } else { + nsPoint pt = nsLayoutUtils::GetEventCoordinatesRelativeTo(mouseEvent, + RelativeTo{this}); + frameselection->HandleDrag(this, pt); + } + + // The frameselection object notifies selection listeners synchronously above + // which might have killed us. + if (!weakThis.IsAlive()) { + return NS_OK; + } + + // get the nearest scrollframe + nsIScrollableFrame* scrollFrame = nsLayoutUtils::GetNearestScrollableFrame( + this, nsLayoutUtils::SCROLLABLE_SAME_DOC | + nsLayoutUtils::SCROLLABLE_INCLUDE_HIDDEN); + + if (scrollFrame) { + nsIFrame* capturingFrame = scrollFrame->GetScrolledFrame(); + if (capturingFrame) { + nsPoint pt = nsLayoutUtils::GetEventCoordinatesRelativeTo( + mouseEvent, RelativeTo{capturingFrame}); + frameselection->StartAutoScrollTimer(capturingFrame, pt, 30); + } + } + + return NS_OK; +} + +/** + * This static method handles part of the nsIFrame::HandleRelease in a way + * which doesn't rely on the nsFrame object to stay alive. + */ +MOZ_CAN_RUN_SCRIPT_BOUNDARY static nsresult HandleFrameSelection( + nsFrameSelection* aFrameSelection, nsIFrame::ContentOffsets& aOffsets, + bool aHandleTableSel, int32_t aContentOffsetForTableSel, + TableSelectionMode aTargetForTableSel, + nsIContent* aParentContentForTableSel, WidgetGUIEvent* aEvent, + const nsEventStatus* aEventStatus) { + if (!aFrameSelection) { + return NS_OK; + } + + nsresult rv = NS_OK; + + if (nsEventStatus_eConsumeNoDefault != *aEventStatus) { + if (!aHandleTableSel) { + if (!aOffsets.content || !aFrameSelection->HasDelayedCaretData()) { + return NS_ERROR_FAILURE; + } + + // We are doing this to simulate what we would have done on HandlePress. + // We didn't do it there to give the user an opportunity to drag + // the text, but since they didn't drag, we want to place the + // caret. + // However, we'll use the mouse position from the release, since: + // * it's easier + // * that's the normal click position to use (although really, in + // the normal case, small movements that don't count as a drag + // can do selection) + aFrameSelection->SetDragState(true); + + const nsFrameSelection::FocusMode focusMode = + aFrameSelection->IsShiftDownInDelayedCaretData() + ? nsFrameSelection::FocusMode::kExtendSelection + : nsFrameSelection::FocusMode::kCollapseToNewPoint; + rv = aFrameSelection->HandleClick( + MOZ_KnownLive(aOffsets.content) /* bug 1636889 */, + aOffsets.StartOffset(), aOffsets.EndOffset(), focusMode, + aOffsets.associate); + if (NS_FAILED(rv)) { + return rv; + } + } else if (aParentContentForTableSel) { + aFrameSelection->SetDragState(false); + rv = aFrameSelection->HandleTableSelection( + aParentContentForTableSel, aContentOffsetForTableSel, + aTargetForTableSel, aEvent->AsMouseEvent()); + if (NS_FAILED(rv)) { + return rv; + } + } + aFrameSelection->SetDelayedCaretData(0); + } + + aFrameSelection->SetDragState(false); + aFrameSelection->StopAutoScrollTimer(); + + return NS_OK; +} + +NS_IMETHODIMP nsIFrame::HandleRelease(nsPresContext* aPresContext, + WidgetGUIEvent* aEvent, + nsEventStatus* aEventStatus) { + if (aEvent->mClass != eMouseEventClass) { + return NS_OK; + } + + nsIFrame* activeFrame = GetActiveSelectionFrame(aPresContext, this); + + nsCOMPtr<nsIContent> captureContent = PresShell::GetCapturingContent(); + + bool selectionOff = + (DetermineDisplaySelection() == nsISelectionController::SELECTION_OFF); + + RefPtr<nsFrameSelection> frameselection; + ContentOffsets offsets; + nsCOMPtr<nsIContent> parentContent; + int32_t contentOffsetForTableSel = 0; + TableSelectionMode targetForTableSel = TableSelectionMode::None; + bool handleTableSelection = true; + + if (!selectionOff) { + frameselection = GetFrameSelection(); + if (nsEventStatus_eConsumeNoDefault != *aEventStatus && frameselection) { + // Check if the frameselection recorded the mouse going down. + // If not, the user must have clicked in a part of the selection. + // Place the caret before continuing! + + if (frameselection->MouseDownRecorded()) { + nsPoint pt = nsLayoutUtils::GetEventCoordinatesRelativeTo( + aEvent, RelativeTo{this}); + offsets = GetContentOffsetsFromPoint(pt, SKIP_HIDDEN); + handleTableSelection = false; + } else { + GetDataForTableSelection(frameselection, PresShell(), + aEvent->AsMouseEvent(), + getter_AddRefs(parentContent), + &contentOffsetForTableSel, &targetForTableSel); + } + } + } + + // We might be capturing in some other document and the event just happened to + // trickle down here. Make sure that document's frame selection is notified. + // Note, this may cause the current nsFrame object to be deleted, bug 336592. + RefPtr<nsFrameSelection> frameSelection; + if (activeFrame != this && activeFrame->DetermineDisplaySelection() != + nsISelectionController::SELECTION_OFF) { + frameSelection = activeFrame->GetFrameSelection(); + } + + // Also check the selection of the capturing content which might be in a + // different document. + if (!frameSelection && captureContent) { + if (Document* doc = captureContent->GetComposedDoc()) { + mozilla::PresShell* capturingPresShell = doc->GetPresShell(); + if (capturingPresShell && + capturingPresShell != PresContext()->GetPresShell()) { + frameSelection = capturingPresShell->FrameSelection(); + } + } + } + + if (frameSelection) { + AutoWeakFrame wf(this); + frameSelection->SetDragState(false); + frameSelection->StopAutoScrollTimer(); + if (wf.IsAlive()) { + nsIScrollableFrame* scrollFrame = + nsLayoutUtils::GetNearestScrollableFrame( + this, nsLayoutUtils::SCROLLABLE_SAME_DOC | + nsLayoutUtils::SCROLLABLE_INCLUDE_HIDDEN); + if (scrollFrame) { + // Perform any additional scrolling needed to maintain CSS snap point + // requirements when autoscrolling is over. + scrollFrame->ScrollSnap(); + } + } + } + + // Do not call any methods of the current object after this point!!! + // The object is perhaps dead! + + return selectionOff ? NS_OK + : HandleFrameSelection( + frameselection, offsets, handleTableSelection, + contentOffsetForTableSel, targetForTableSel, + parentContent, aEvent, aEventStatus); +} + +struct MOZ_STACK_CLASS FrameContentRange { + FrameContentRange(nsIContent* aContent, int32_t aStart, int32_t aEnd) + : content(aContent), start(aStart), end(aEnd) {} + nsCOMPtr<nsIContent> content; + int32_t start; + int32_t end; +}; + +// Retrieve the content offsets of a frame +static FrameContentRange GetRangeForFrame(const nsIFrame* aFrame) { + nsIContent* content = aFrame->GetContent(); + if (!content) { + NS_WARNING("Frame has no content"); + return FrameContentRange(nullptr, -1, -1); + } + + LayoutFrameType type = aFrame->Type(); + if (type == LayoutFrameType::Text) { + auto [offset, offsetEnd] = aFrame->GetOffsets(); + return FrameContentRange(content, offset, offsetEnd); + } + + if (type == LayoutFrameType::Br) { + nsIContent* parent = content->GetParent(); + const int32_t beginOffset = parent->ComputeIndexOf_Deprecated(content); + return FrameContentRange(parent, beginOffset, beginOffset); + } + + while (content->IsRootOfNativeAnonymousSubtree()) { + content = content->GetParent(); + } + + nsIContent* parent = content->GetParent(); + if (aFrame->IsBlockOutside() || !parent) { + return FrameContentRange(content, 0, content->GetChildCount()); + } + + // TODO(emilio): Revise this in presence of Shadow DOM / display: contents, + // it's likely that we don't want to just walk the light tree, and we need to + // change the representation of FrameContentRange. + const int32_t index = parent->ComputeIndexOf_Deprecated(content); + MOZ_ASSERT(index >= 0); + return FrameContentRange(parent, index, index + 1); +} + +// The FrameTarget represents the closest frame to a point that can be selected +// The frame is the frame represented, frameEdge says whether one end of the +// frame is the result (in which case different handling is needed), and +// afterFrame says which end is represented if frameEdge is true +struct FrameTarget { + explicit operator bool() const { return !!frame; } + + nsIFrame* frame = nullptr; + bool frameEdge = false; + bool afterFrame = false; +}; + +// See function implementation for information +static FrameTarget GetSelectionClosestFrame(nsIFrame* aFrame, + const nsPoint& aPoint, + uint32_t aFlags); + +static bool SelfIsSelectable(nsIFrame* aFrame, uint32_t aFlags) { + if ((aFlags & nsIFrame::SKIP_HIDDEN) && + !aFrame->StyleVisibility()->IsVisible()) { + return false; + } + return !aFrame->IsGeneratedContentFrame() && + aFrame->Style()->UserSelect() != StyleUserSelect::None; +} + +static bool SelectionDescendToKids(nsIFrame* aFrame) { + // If we are only near (not directly over) then don't traverse + // frames with independent selection (e.g. text and list controls, see bug + // 268497). Note that this prevents any of the users of this method from + // entering form controls. + // XXX We might want some way to allow using the up-arrow to go into a form + // control, but the focus didn't work right anyway; it'd probably be enough + // if the left and right arrows could enter textboxes (which I don't believe + // they can at the moment) + if (aFrame->IsTextInputFrame() || aFrame->IsListControlFrame()) { + MOZ_ASSERT(aFrame->HasAnyStateBits(NS_FRAME_INDEPENDENT_SELECTION)); + return false; + } + + // Failure in this assertion means a new type of frame forms the root of an + // NS_FRAME_INDEPENDENT_SELECTION subtree. In such case, the condition above + // should be changed to handle it. + MOZ_ASSERT_IF( + aFrame->HasAnyStateBits(NS_FRAME_INDEPENDENT_SELECTION), + aFrame->GetParent()->HasAnyStateBits(NS_FRAME_INDEPENDENT_SELECTION)); + + if (aFrame->IsGeneratedContentFrame()) { + return false; + } + + auto style = aFrame->Style()->UserSelect(); + return style != StyleUserSelect::All && style != StyleUserSelect::None; +} + +static FrameTarget GetSelectionClosestFrameForChild(nsIFrame* aChild, + const nsPoint& aPoint, + uint32_t aFlags) { + nsIFrame* parent = aChild->GetParent(); + if (SelectionDescendToKids(aChild)) { + nsPoint pt = aPoint - aChild->GetOffsetTo(parent); + return GetSelectionClosestFrame(aChild, pt, aFlags); + } + return FrameTarget{aChild, false, false}; +} + +// When the cursor needs to be at the beginning of a block, it shouldn't be +// before the first child. A click on a block whose first child is a block +// should put the cursor in the child. The cursor shouldn't be between the +// blocks, because that's not where it's expected. +// Note that this method is guaranteed to succeed. +static FrameTarget DrillDownToSelectionFrame(nsIFrame* aFrame, bool aEndFrame, + uint32_t aFlags) { + if (SelectionDescendToKids(aFrame)) { + nsIFrame* result = nullptr; + nsIFrame* frame = aFrame->PrincipalChildList().FirstChild(); + if (!aEndFrame) { + while (frame && (!SelfIsSelectable(frame, aFlags) || frame->IsEmpty())) + frame = frame->GetNextSibling(); + if (frame) result = frame; + } else { + // Because the frame tree is singly linked, to find the last frame, + // we have to iterate through all the frames + // XXX I have a feeling this could be slow for long blocks, although + // I can't find any slowdowns + while (frame) { + if (!frame->IsEmpty() && SelfIsSelectable(frame, aFlags)) + result = frame; + frame = frame->GetNextSibling(); + } + } + if (result) return DrillDownToSelectionFrame(result, aEndFrame, aFlags); + } + // If the current frame has no targetable children, target the current frame + return FrameTarget{aFrame, true, aEndFrame}; +} + +// This method finds the closest valid FrameTarget on a given line; if there is +// no valid FrameTarget on the line, it returns a null FrameTarget +static FrameTarget GetSelectionClosestFrameForLine( + nsBlockFrame* aParent, nsBlockFrame::LineIterator aLine, + const nsPoint& aPoint, uint32_t aFlags) { + // Account for end of lines (any iterator from the block is valid) + if (aLine == aParent->LinesEnd()) + return DrillDownToSelectionFrame(aParent, true, aFlags); + nsIFrame* frame = aLine->mFirstChild; + nsIFrame* closestFromIStart = nullptr; + nsIFrame* closestFromIEnd = nullptr; + nscoord closestIStart = aLine->IStart(), closestIEnd = aLine->IEnd(); + WritingMode wm = aLine->mWritingMode; + LogicalPoint pt(wm, aPoint, aLine->mContainerSize); + bool canSkipBr = false; + bool lastFrameWasEditable = false; + for (int32_t n = aLine->GetChildCount(); n; + --n, frame = frame->GetNextSibling()) { + // Skip brFrames. Can only skip if the line contains at least + // one selectable and non-empty frame before. Also, avoid skipping brs if + // the previous thing had a different editableness than us, since then we + // may end up not being able to select after it if the br is the last thing + // on the line. + if (!SelfIsSelectable(frame, aFlags) || frame->IsEmpty() || + (canSkipBr && frame->IsBrFrame() && + lastFrameWasEditable == frame->GetContent()->IsEditable())) { + continue; + } + canSkipBr = true; + lastFrameWasEditable = + frame->GetContent() && frame->GetContent()->IsEditable(); + LogicalRect frameRect = + LogicalRect(wm, frame->GetRect(), aLine->mContainerSize); + if (pt.I(wm) >= frameRect.IStart(wm)) { + if (pt.I(wm) < frameRect.IEnd(wm)) { + return GetSelectionClosestFrameForChild(frame, aPoint, aFlags); + } + if (frameRect.IEnd(wm) >= closestIStart) { + closestFromIStart = frame; + closestIStart = frameRect.IEnd(wm); + } + } else { + if (frameRect.IStart(wm) <= closestIEnd) { + closestFromIEnd = frame; + closestIEnd = frameRect.IStart(wm); + } + } + } + if (!closestFromIStart && !closestFromIEnd) { + // We should only get here if there are no selectable frames on a line + // XXX Do we need more elaborate handling here? + return FrameTarget(); + } + if (closestFromIStart && + (!closestFromIEnd || + (abs(pt.I(wm) - closestIStart) <= abs(pt.I(wm) - closestIEnd)))) { + return GetSelectionClosestFrameForChild(closestFromIStart, aPoint, aFlags); + } + return GetSelectionClosestFrameForChild(closestFromIEnd, aPoint, aFlags); +} + +// This method is for the special handling we do for block frames; they're +// special because they represent paragraphs and because they are organized +// into lines, which have bounds that are not stored elsewhere in the +// frame tree. Returns a null FrameTarget for frames which are not +// blocks or blocks with no lines except editable one. +static FrameTarget GetSelectionClosestFrameForBlock(nsIFrame* aFrame, + const nsPoint& aPoint, + uint32_t aFlags) { + nsBlockFrame* bf = do_QueryFrame(aFrame); + if (!bf) { + return FrameTarget(); + } + + // This code searches for the correct line + nsBlockFrame::LineIterator end = bf->LinesEnd(); + nsBlockFrame::LineIterator curLine = bf->LinesBegin(); + nsBlockFrame::LineIterator closestLine = end; + + if (curLine != end) { + // Convert aPoint into a LogicalPoint in the writing-mode of this block + WritingMode wm = curLine->mWritingMode; + LogicalPoint pt(wm, aPoint, curLine->mContainerSize); + do { + // Check to see if our point lies within the line's block-direction bounds + nscoord BCoord = pt.B(wm) - curLine->BStart(); + nscoord BSize = curLine->BSize(); + if (BCoord >= 0 && BCoord < BSize) { + closestLine = curLine; + break; // We found the line; stop looking + } + if (BCoord < 0) break; + ++curLine; + } while (curLine != end); + + if (closestLine == end) { + nsBlockFrame::LineIterator prevLine = curLine.prev(); + nsBlockFrame::LineIterator nextLine = curLine; + // Avoid empty lines + while (nextLine != end && nextLine->IsEmpty()) ++nextLine; + while (prevLine != end && prevLine->IsEmpty()) --prevLine; + + // This hidden pref dictates whether a point above or below all lines + // comes up with a line or the beginning or end of the frame; 0 on + // Windows, 1 on other platforms by default at the writing of this code + int32_t dragOutOfFrame = + Preferences::GetInt("browser.drag_out_of_frame_style"); + + if (prevLine == end) { + if (dragOutOfFrame == 1 || nextLine == end) + return DrillDownToSelectionFrame(aFrame, false, aFlags); + closestLine = nextLine; + } else if (nextLine == end) { + if (dragOutOfFrame == 1) + return DrillDownToSelectionFrame(aFrame, true, aFlags); + closestLine = prevLine; + } else { // Figure out which line is closer + if (pt.B(wm) - prevLine->BEnd() < nextLine->BStart() - pt.B(wm)) + closestLine = prevLine; + else + closestLine = nextLine; + } + } + } + + do { + if (auto target = + GetSelectionClosestFrameForLine(bf, closestLine, aPoint, aFlags)) { + return target; + } + ++closestLine; + } while (closestLine != end); + + // Fall back to just targeting the last targetable place + return DrillDownToSelectionFrame(aFrame, true, aFlags); +} + +// Use frame edge for grid, flex, table, and non-editable images. Choose the +// edge based on the point position past the frame rect. If past the middle, +// caret should be at end, otherwise at start. This behavior matches Blink. +// +// TODO(emilio): Can we use this code path for other replaced elements other +// than images? Or even all other frames? We only get there when we didn't find +// selectable children... At least one XUL test fails if we make this apply to +// XUL labels. Also, editable images need _not_ to use the frame edge, see +// below. +static bool UseFrameEdge(nsIFrame* aFrame) { + if (aFrame->IsFlexOrGridContainer() || aFrame->IsTableFrame()) { + return true; + } + const nsImageFrame* image = do_QueryFrame(aFrame); + if (image && !aFrame->GetContent()->IsEditable()) { + // Editable images are a special-case because editing relies on clicking on + // an editable image selecting it, for it to show resizers. + return true; + } + return false; +} + +static FrameTarget LastResortFrameTargetForFrame(nsIFrame* aFrame, + const nsPoint& aPoint) { + if (!UseFrameEdge(aFrame)) { + return {aFrame, false, false}; + } + const auto& rect = aFrame->GetRectRelativeToSelf(); + nscoord reference; + nscoord middle; + if (aFrame->GetWritingMode().IsVertical()) { + reference = aPoint.y; + middle = rect.Height() / 2; + } else { + reference = aPoint.x; + middle = rect.Width() / 2; + } + const bool afterFrame = reference > middle; + return {aFrame, true, afterFrame}; +} + +// GetSelectionClosestFrame is the helper function that calculates the closest +// frame to the given point. +// It doesn't completely account for offset styles, so needs to be used in +// restricted environments. +// Cannot handle overlapping frames correctly, so it should receive the output +// of GetFrameForPoint +// Guaranteed to return a valid FrameTarget. +// aPoint is relative to aFrame. +static FrameTarget GetSelectionClosestFrame(nsIFrame* aFrame, + const nsPoint& aPoint, + uint32_t aFlags) { + // Handle blocks; if the frame isn't a block, the method fails + if (auto target = GetSelectionClosestFrameForBlock(aFrame, aPoint, aFlags)) { + return target; + } + + if (nsIFrame* kid = aFrame->PrincipalChildList().FirstChild()) { + // Go through all the child frames to find the closest one + nsIFrame::FrameWithDistance closest = {nullptr, nscoord_MAX, nscoord_MAX}; + for (; kid; kid = kid->GetNextSibling()) { + if (!SelfIsSelectable(kid, aFlags) || kid->IsEmpty()) continue; + + kid->FindCloserFrameForSelection(aPoint, &closest); + } + if (closest.mFrame) { + if (closest.mFrame->IsInSVGTextSubtree()) + return FrameTarget{closest.mFrame, false, false}; + return GetSelectionClosestFrameForChild(closest.mFrame, aPoint, aFlags); + } + } + + return LastResortFrameTargetForFrame(aFrame, aPoint); +} + +static nsIFrame::ContentOffsets OffsetsForSingleFrame(nsIFrame* aFrame, + const nsPoint& aPoint) { + nsIFrame::ContentOffsets offsets; + FrameContentRange range = GetRangeForFrame(aFrame); + offsets.content = range.content; + // If there are continuations (meaning it's not one rectangle), this is the + // best this function can do + if (aFrame->GetNextContinuation() || aFrame->GetPrevContinuation()) { + offsets.offset = range.start; + offsets.secondaryOffset = range.end; + offsets.associate = CARET_ASSOCIATE_AFTER; + return offsets; + } + + // Figure out whether the offsets should be over, after, or before the frame + nsRect rect(nsPoint(0, 0), aFrame->GetSize()); + + bool isBlock = !aFrame->StyleDisplay()->IsInlineFlow(); + bool isRtl = (aFrame->StyleVisibility()->mDirection == StyleDirection::Rtl); + if ((isBlock && rect.y < aPoint.y) || + (!isBlock && ((isRtl && rect.x + rect.width / 2 > aPoint.x) || + (!isRtl && rect.x + rect.width / 2 < aPoint.x)))) { + offsets.offset = range.end; + if (rect.Contains(aPoint)) + offsets.secondaryOffset = range.start; + else + offsets.secondaryOffset = range.end; + } else { + offsets.offset = range.start; + if (rect.Contains(aPoint)) + offsets.secondaryOffset = range.end; + else + offsets.secondaryOffset = range.start; + } + offsets.associate = offsets.offset == range.start ? CARET_ASSOCIATE_AFTER + : CARET_ASSOCIATE_BEFORE; + return offsets; +} + +static nsIFrame* AdjustFrameForSelectionStyles(nsIFrame* aFrame) { + nsIFrame* adjustedFrame = aFrame; + for (nsIFrame* frame = aFrame; frame; frame = frame->GetParent()) { + // These are the conditions that make all children not able to handle + // a cursor. + auto userSelect = frame->Style()->UserSelect(); + if (userSelect != StyleUserSelect::Auto && + userSelect != StyleUserSelect::All) { + break; + } + if (userSelect == StyleUserSelect::All || + frame->IsGeneratedContentFrame()) { + adjustedFrame = frame; + } + } + return adjustedFrame; +} + +nsIFrame::ContentOffsets nsIFrame::GetContentOffsetsFromPoint( + const nsPoint& aPoint, uint32_t aFlags) { + nsIFrame* adjustedFrame; + if (aFlags & IGNORE_SELECTION_STYLE) { + adjustedFrame = this; + } else { + // This section of code deals with special selection styles. Note that + // -moz-all exists, even though it doesn't need to be explicitly handled. + // + // The offset is forced not to end up in generated content; content offsets + // cannot represent content outside of the document's content tree. + + adjustedFrame = AdjustFrameForSelectionStyles(this); + + // `user-select: all` needs special handling, because clicking on it should + // lead to the whole frame being selected. + if (adjustedFrame->Style()->UserSelect() == StyleUserSelect::All) { + nsPoint adjustedPoint = aPoint + GetOffsetTo(adjustedFrame); + return OffsetsForSingleFrame(adjustedFrame, adjustedPoint); + } + + // For other cases, try to find a closest frame starting from the parent of + // the unselectable frame + if (adjustedFrame != this) { + adjustedFrame = adjustedFrame->GetParent(); + } + } + + nsPoint adjustedPoint = aPoint + GetOffsetTo(adjustedFrame); + + FrameTarget closest = + GetSelectionClosestFrame(adjustedFrame, adjustedPoint, aFlags); + + // If the correct offset is at one end of a frame, use offset-based + // calculation method + if (closest.frameEdge) { + ContentOffsets offsets; + FrameContentRange range = GetRangeForFrame(closest.frame); + offsets.content = range.content; + if (closest.afterFrame) + offsets.offset = range.end; + else + offsets.offset = range.start; + offsets.secondaryOffset = offsets.offset; + offsets.associate = offsets.offset == range.start ? CARET_ASSOCIATE_AFTER + : CARET_ASSOCIATE_BEFORE; + return offsets; + } + + nsPoint pt; + if (closest.frame != this) { + if (closest.frame->IsInSVGTextSubtree()) { + pt = nsLayoutUtils::TransformAncestorPointToFrame( + RelativeTo{closest.frame}, aPoint, RelativeTo{this}); + } else { + pt = aPoint - closest.frame->GetOffsetTo(this); + } + } else { + pt = aPoint; + } + return closest.frame->CalcContentOffsetsFromFramePoint(pt); + + // XXX should I add some kind of offset standardization? + // consider <b>xxxxx</b><i>zzzzz</i>; should any click between the last + // x and first z put the cursor in the same logical position in addition + // to the same visual position? +} + +nsIFrame::ContentOffsets nsIFrame::CalcContentOffsetsFromFramePoint( + const nsPoint& aPoint) { + return OffsetsForSingleFrame(this, aPoint); +} + +bool nsIFrame::AssociateImage(const StyleImage& aImage) { + imgRequestProxy* req = aImage.GetImageRequest(); + if (!req) { + return false; + } + + mozilla::css::ImageLoader* loader = + PresContext()->Document()->StyleImageLoader(); + + loader->AssociateRequestToFrame(req, this); + return true; +} + +void nsIFrame::DisassociateImage(const StyleImage& aImage) { + imgRequestProxy* req = aImage.GetImageRequest(); + if (!req) { + return; + } + + mozilla::css::ImageLoader* loader = + PresContext()->Document()->StyleImageLoader(); + + loader->DisassociateRequestFromFrame(req, this); +} + +StyleImageRendering nsIFrame::UsedImageRendering() const { + ComputedStyle* style; + if (IsCanvasFrame()) { + // XXXdholbert Maybe we should use FindCanvasBackground here (instead of + // FindBackground), since we're inside an IsCanvasFrame check? Though then + // we'd also have to copypaste or abstract-away the multi-part root-frame + // lookup that the canvas-flavored API requires. + style = nsCSSRendering::FindBackground(this); + } else { + style = Style(); + } + return style->StyleVisibility()->mImageRendering; +} + +// The touch-action CSS property applies to: all elements except: non-replaced +// inline elements, table rows, row groups, table columns, and column groups. +StyleTouchAction nsIFrame::UsedTouchAction() const { + if (IsFrameOfType(eLineParticipant)) { + return StyleTouchAction::AUTO; + } + auto& disp = *StyleDisplay(); + if (disp.IsInternalTableStyleExceptCell()) { + return StyleTouchAction::AUTO; + } + return disp.mTouchAction; +} + +Maybe<nsIFrame::Cursor> nsIFrame::GetCursor(const nsPoint&) { + StyleCursorKind kind = StyleUI()->Cursor().keyword; + if (kind == StyleCursorKind::Auto) { + // If this is editable, I-beam cursor is better for most elements. + kind = (mContent && mContent->IsEditable()) ? StyleCursorKind::Text + : StyleCursorKind::Default; + } + if (kind == StyleCursorKind::Text && GetWritingMode().IsVertical()) { + // Per CSS UI spec, UA may treat value 'text' as + // 'vertical-text' for vertical text. + kind = StyleCursorKind::VerticalText; + } + + return Some(Cursor{kind, AllowCustomCursorImage::Yes}); +} + +// Resize and incremental reflow + +/* virtual */ +void nsIFrame::MarkIntrinsicISizesDirty() { + // If we're a flex item, clear our flex-item-specific cached measurements + // (which likely depended on our now-stale intrinsic isize). + if (IsFlexItem()) { + nsFlexContainerFrame::MarkCachedFlexMeasurementsDirty(this); + } + + if (HasAnyStateBits(NS_FRAME_FONT_INFLATION_FLOW_ROOT)) { + nsFontInflationData::MarkFontInflationDataTextDirty(this); + } + + if (StaticPrefs::layout_css_grid_item_baxis_measurement_enabled()) { + RemoveProperty(nsGridContainerFrame::CachedBAxisMeasurement::Prop()); + } +} + +void nsIFrame::MarkSubtreeDirty() { + if (HasAnyStateBits(NS_FRAME_IS_DIRTY)) { + return; + } + // Unconditionally mark given frame dirty. + AddStateBits(NS_FRAME_IS_DIRTY); + + // Mark all descendants dirty, unless: + // - Already dirty. + // - TableColGroup + // - XULBox + AutoTArray<nsIFrame*, 32> stack; + for (const auto& childLists : ChildLists()) { + for (nsIFrame* kid : childLists.mList) { + stack.AppendElement(kid); + } + } + while (!stack.IsEmpty()) { + nsIFrame* f = stack.PopLastElement(); + if (f->HasAnyStateBits(NS_FRAME_IS_DIRTY) || f->IsTableColGroupFrame()) { + continue; + } + + f->AddStateBits(NS_FRAME_IS_DIRTY); + + for (const auto& childLists : f->ChildLists()) { + for (nsIFrame* kid : childLists.mList) { + stack.AppendElement(kid); + } + } + } +} + +/* virtual */ +nscoord nsIFrame::GetMinISize(gfxContext* aRenderingContext) { + nscoord result = 0; + DISPLAY_MIN_INLINE_SIZE(this, result); + return result; +} + +/* virtual */ +nscoord nsIFrame::GetPrefISize(gfxContext* aRenderingContext) { + nscoord result = 0; + DISPLAY_PREF_INLINE_SIZE(this, result); + return result; +} + +/* virtual */ +void nsIFrame::AddInlineMinISize(gfxContext* aRenderingContext, + nsIFrame::InlineMinISizeData* aData) { + nscoord isize = nsLayoutUtils::IntrinsicForContainer( + aRenderingContext, this, IntrinsicISizeType::MinISize); + aData->DefaultAddInlineMinISize(this, isize); +} + +/* virtual */ +void nsIFrame::AddInlinePrefISize(gfxContext* aRenderingContext, + nsIFrame::InlinePrefISizeData* aData) { + nscoord isize = nsLayoutUtils::IntrinsicForContainer( + aRenderingContext, this, IntrinsicISizeType::PrefISize); + aData->DefaultAddInlinePrefISize(isize); +} + +void nsIFrame::InlineMinISizeData::DefaultAddInlineMinISize(nsIFrame* aFrame, + nscoord aISize, + bool aAllowBreak) { + auto parent = aFrame->GetParent(); + MOZ_ASSERT(parent, "Must have a parent if we get here!"); + const bool mayBreak = aAllowBreak && !aFrame->CanContinueTextRun() && + !parent->Style()->ShouldSuppressLineBreak() && + parent->StyleText()->WhiteSpaceCanWrap(parent); + if (mayBreak) { + OptionallyBreak(); + } + mTrailingWhitespace = 0; + mSkipWhitespace = false; + mCurrentLine += aISize; + mAtStartOfLine = false; + if (mayBreak) { + OptionallyBreak(); + } +} + +void nsIFrame::InlinePrefISizeData::DefaultAddInlinePrefISize(nscoord aISize) { + mCurrentLine = NSCoordSaturatingAdd(mCurrentLine, aISize); + mTrailingWhitespace = 0; + mSkipWhitespace = false; + mLineIsEmpty = false; +} + +void nsIFrame::InlineMinISizeData::ForceBreak() { + mCurrentLine -= mTrailingWhitespace; + mPrevLines = std::max(mPrevLines, mCurrentLine); + mCurrentLine = mTrailingWhitespace = 0; + + for (uint32_t i = 0, i_end = mFloats.Length(); i != i_end; ++i) { + nscoord float_min = mFloats[i].Width(); + if (float_min > mPrevLines) mPrevLines = float_min; + } + mFloats.Clear(); + mSkipWhitespace = true; +} + +void nsIFrame::InlineMinISizeData::OptionallyBreak(nscoord aHyphenWidth) { + // If we can fit more content into a smaller width by staying on this + // line (because we're still at a negative offset due to negative + // text-indent or negative margin), don't break. Otherwise, do the + // same as ForceBreak. it doesn't really matter when we accumulate + // floats. + if (mCurrentLine + aHyphenWidth < 0 || mAtStartOfLine) return; + mCurrentLine += aHyphenWidth; + ForceBreak(); +} + +void nsIFrame::InlinePrefISizeData::ForceBreak(StyleClear aClearType) { + // If this force break is not clearing any float, we can leave all the + // floats to the next force break. + if (!mFloats.IsEmpty() && aClearType != StyleClear::None) { + // preferred widths accumulated for floats that have already + // been cleared past + nscoord floats_done = 0, + // preferred widths accumulated for floats that have not yet + // been cleared past + floats_cur_left = 0, floats_cur_right = 0; + + for (const FloatInfo& floatInfo : mFloats) { + const nsStyleDisplay* floatDisp = floatInfo.Frame()->StyleDisplay(); + StyleClear clearType = floatDisp->mClear; + if (clearType == StyleClear::Left || clearType == StyleClear::Right || + clearType == StyleClear::Both) { + nscoord floats_cur = + NSCoordSaturatingAdd(floats_cur_left, floats_cur_right); + if (floats_cur > floats_done) { + floats_done = floats_cur; + } + if (clearType != StyleClear::Right) { + floats_cur_left = 0; + } + if (clearType != StyleClear::Left) { + floats_cur_right = 0; + } + } + + StyleFloat floatStyle = floatDisp->mFloat; + nscoord& floats_cur = + floatStyle == StyleFloat::Left ? floats_cur_left : floats_cur_right; + nscoord floatWidth = floatInfo.Width(); + // Negative-width floats don't change the available space so they + // shouldn't change our intrinsic line width either. + floats_cur = NSCoordSaturatingAdd(floats_cur, std::max(0, floatWidth)); + } + + nscoord floats_cur = + NSCoordSaturatingAdd(floats_cur_left, floats_cur_right); + if (floats_cur > floats_done) floats_done = floats_cur; + + mCurrentLine = NSCoordSaturatingAdd(mCurrentLine, floats_done); + + if (aClearType == StyleClear::Both) { + mFloats.Clear(); + } else { + // If the break type does not clear all floats, it means there may + // be some floats whose isize should contribute to the intrinsic + // isize of the next line. The code here scans the current mFloats + // and keeps floats which are not cleared by this break. Note that + // floats may be cleared directly or indirectly. See below. + nsTArray<FloatInfo> newFloats; + MOZ_ASSERT( + aClearType == StyleClear::Left || aClearType == StyleClear::Right, + "Other values should have been handled in other branches"); + StyleFloat clearFloatType = + aClearType == StyleClear::Left ? StyleFloat::Left : StyleFloat::Right; + // Iterate the array in reverse so that we can stop when there are + // no longer any floats we need to keep. See below. + for (FloatInfo& floatInfo : Reversed(mFloats)) { + const nsStyleDisplay* floatDisp = floatInfo.Frame()->StyleDisplay(); + if (floatDisp->mFloat != clearFloatType) { + newFloats.AppendElement(floatInfo); + } else { + // This is a float on the side that this break directly clears + // which means we're not keeping it in mFloats. However, if + // this float clears floats on the opposite side (via a value + // of either 'both' or one of 'left'/'right'), any remaining + // (earlier) floats on that side would be indirectly cleared + // as well. Thus, we should break out of this loop and stop + // considering earlier floats to be kept in mFloats. + StyleClear clearType = floatDisp->mClear; + if (clearType != aClearType && clearType != StyleClear::None) { + break; + } + } + } + newFloats.Reverse(); + mFloats = std::move(newFloats); + } + } + + mCurrentLine = + NSCoordSaturatingSubtract(mCurrentLine, mTrailingWhitespace, nscoord_MAX); + mPrevLines = std::max(mPrevLines, mCurrentLine); + mCurrentLine = mTrailingWhitespace = 0; + mSkipWhitespace = true; + mLineIsEmpty = true; +} + +static nscoord ResolveMargin(const LengthPercentageOrAuto& aStyle, + nscoord aPercentageBasis) { + if (aStyle.IsAuto()) { + return nscoord(0); + } + return nsLayoutUtils::ResolveToLength<false>(aStyle.AsLengthPercentage(), + aPercentageBasis); +} + +static nscoord ResolvePadding(const LengthPercentage& aStyle, + nscoord aPercentageBasis) { + return nsLayoutUtils::ResolveToLength<true>(aStyle, aPercentageBasis); +} + +static nsIFrame::IntrinsicSizeOffsetData IntrinsicSizeOffsets( + nsIFrame* aFrame, nscoord aPercentageBasis, bool aForISize) { + nsIFrame::IntrinsicSizeOffsetData result; + WritingMode wm = aFrame->GetWritingMode(); + const auto& margin = aFrame->StyleMargin()->mMargin; + bool verticalAxis = aForISize == wm.IsVertical(); + if (verticalAxis) { + result.margin += ResolveMargin(margin.Get(eSideTop), aPercentageBasis); + result.margin += ResolveMargin(margin.Get(eSideBottom), aPercentageBasis); + } else { + result.margin += ResolveMargin(margin.Get(eSideLeft), aPercentageBasis); + result.margin += ResolveMargin(margin.Get(eSideRight), aPercentageBasis); + } + + const auto& padding = aFrame->StylePadding()->mPadding; + if (verticalAxis) { + result.padding += ResolvePadding(padding.Get(eSideTop), aPercentageBasis); + result.padding += + ResolvePadding(padding.Get(eSideBottom), aPercentageBasis); + } else { + result.padding += ResolvePadding(padding.Get(eSideLeft), aPercentageBasis); + result.padding += ResolvePadding(padding.Get(eSideRight), aPercentageBasis); + } + + const nsStyleBorder* styleBorder = aFrame->StyleBorder(); + if (verticalAxis) { + result.border += styleBorder->GetComputedBorderWidth(eSideTop); + result.border += styleBorder->GetComputedBorderWidth(eSideBottom); + } else { + result.border += styleBorder->GetComputedBorderWidth(eSideLeft); + result.border += styleBorder->GetComputedBorderWidth(eSideRight); + } + + const nsStyleDisplay* disp = aFrame->StyleDisplay(); + if (aFrame->IsThemed(disp)) { + nsPresContext* presContext = aFrame->PresContext(); + + LayoutDeviceIntMargin border = presContext->Theme()->GetWidgetBorder( + presContext->DeviceContext(), aFrame, disp->EffectiveAppearance()); + result.border = presContext->DevPixelsToAppUnits( + verticalAxis ? border.TopBottom() : border.LeftRight()); + + LayoutDeviceIntMargin padding; + if (presContext->Theme()->GetWidgetPadding( + presContext->DeviceContext(), aFrame, disp->EffectiveAppearance(), + &padding)) { + result.padding = presContext->DevPixelsToAppUnits( + verticalAxis ? padding.TopBottom() : padding.LeftRight()); + } + } + return result; +} + +/* virtual */ nsIFrame::IntrinsicSizeOffsetData nsIFrame::IntrinsicISizeOffsets( + nscoord aPercentageBasis) { + return IntrinsicSizeOffsets(this, aPercentageBasis, true); +} + +nsIFrame::IntrinsicSizeOffsetData nsIFrame::IntrinsicBSizeOffsets( + nscoord aPercentageBasis) { + return IntrinsicSizeOffsets(this, aPercentageBasis, false); +} + +/* virtual */ +IntrinsicSize nsIFrame::GetIntrinsicSize() { + return IntrinsicSize(); // default is width/height set to eStyleUnit_None +} + +AspectRatio nsIFrame::GetAspectRatio() const { + // Per spec, 'aspect-ratio' property applies to all elements except inline + // boxes and internal ruby or table boxes. + // https://drafts.csswg.org/css-sizing-4/#aspect-ratio + // For those frame types that don't support aspect-ratio, they must not have + // the natural ratio, so this early return is fine. + if (!IsFrameOfType(eSupportsAspectRatio)) { + return AspectRatio(); + } + + const StyleAspectRatio& aspectRatio = StylePosition()->mAspectRatio; + // If aspect-ratio is zero or infinite, it's a degenerate ratio and behaves + // as auto. + // https://drafts.csswg.org/css-sizing-4/#valdef-aspect-ratio-ratio + if (!aspectRatio.BehavesAsAuto()) { + // Non-auto. Return the preferred aspect ratio from the aspect-ratio style. + return aspectRatio.ratio.AsRatio().ToLayoutRatio(UseBoxSizing::Yes); + } + + // The rest of the cases are when aspect-ratio has 'auto'. + if (auto intrinsicRatio = GetIntrinsicRatio()) { + return intrinsicRatio; + } + + if (aspectRatio.HasRatio()) { + // If it's a degenerate ratio, this returns 0. Just the same as the auto + // case. + return aspectRatio.ratio.AsRatio().ToLayoutRatio(UseBoxSizing::No); + } + + return AspectRatio(); +} + +/* virtual */ +AspectRatio nsIFrame::GetIntrinsicRatio() const { return AspectRatio(); } + +static bool ShouldApplyAutomaticMinimumOnInlineAxis( + WritingMode aWM, const nsStyleDisplay* aDisplay, + const nsStylePosition* aPosition) { + // Apply the automatic minimum size for aspect ratio: + // Note: The replaced elements shouldn't be here, so we only check the scroll + // container. + // https://drafts.csswg.org/css-sizing-4/#aspect-ratio-minimum + return !aDisplay->IsScrollableOverflow() && aPosition->MinISize(aWM).IsAuto(); +} + +struct MinMaxSize { + nscoord mMinSize = 0; + nscoord mMaxSize = NS_UNCONSTRAINEDSIZE; + + nscoord ClampSizeToMinAndMax(nscoord aSize) const { + return NS_CSS_MINMAX(aSize, mMinSize, mMaxSize); + } +}; +static MinMaxSize ComputeTransferredMinMaxInlineSize( + const WritingMode aWM, const AspectRatio& aAspectRatio, + const MinMaxSize& aMinMaxBSize, const LogicalSize& aBoxSizingAdjustment) { + // Note: the spec mentions that + // 1. This transferred minimum is capped by any definite preferred or maximum + // size in the destination axis. + // 2. This transferred maximum is floored by any definite preferred or minimum + // size in the destination axis + // + // https://drafts.csswg.org/css-sizing-4/#aspect-ratio + // + // The spec requires us to clamp these by the specified size (it calls it the + // preferred size). However, we actually don't need to worry about that, + // because we only use this if the inline size is indefinite. + // + // We do not need to clamp the transferred minimum and maximum as long as we + // always apply the transferred min/max size before the explicit min/max size, + // the result will be identical. + + MinMaxSize transferredISize; + + if (aMinMaxBSize.mMinSize > 0) { + transferredISize.mMinSize = aAspectRatio.ComputeRatioDependentSize( + LogicalAxis::eLogicalAxisInline, aWM, aMinMaxBSize.mMinSize, + aBoxSizingAdjustment); + } + + if (aMinMaxBSize.mMaxSize != NS_UNCONSTRAINEDSIZE) { + transferredISize.mMaxSize = aAspectRatio.ComputeRatioDependentSize( + LogicalAxis::eLogicalAxisInline, aWM, aMinMaxBSize.mMaxSize, + aBoxSizingAdjustment); + } + + // Minimum size wins over maximum size. + transferredISize.mMaxSize = + std::max(transferredISize.mMinSize, transferredISize.mMaxSize); + return transferredISize; +} + +/* virtual */ +nsIFrame::SizeComputationResult nsIFrame::ComputeSize( + gfxContext* aRenderingContext, WritingMode aWM, const LogicalSize& aCBSize, + nscoord aAvailableISize, const LogicalSize& aMargin, + const LogicalSize& aBorderPadding, const StyleSizeOverrides& aSizeOverrides, + ComputeSizeFlags aFlags) { + MOZ_ASSERT(!GetIntrinsicRatio(), + "Please override this method and call " + "nsContainerFrame::ComputeSizeWithIntrinsicDimensions instead."); + LogicalSize result = + ComputeAutoSize(aRenderingContext, aWM, aCBSize, aAvailableISize, aMargin, + aBorderPadding, aSizeOverrides, aFlags); + const nsStylePosition* stylePos = StylePosition(); + const nsStyleDisplay* disp = StyleDisplay(); + auto aspectRatioUsage = AspectRatioUsage::None; + + const auto boxSizingAdjust = stylePos->mBoxSizing == StyleBoxSizing::Border + ? aBorderPadding + : LogicalSize(aWM); + nscoord boxSizingToMarginEdgeISize = aMargin.ISize(aWM) + + aBorderPadding.ISize(aWM) - + boxSizingAdjust.ISize(aWM); + + const auto& styleISize = aSizeOverrides.mStyleISize + ? *aSizeOverrides.mStyleISize + : stylePos->ISize(aWM); + const auto& styleBSize = aSizeOverrides.mStyleBSize + ? *aSizeOverrides.mStyleBSize + : stylePos->BSize(aWM); + const auto& aspectRatio = aSizeOverrides.mAspectRatio + ? *aSizeOverrides.mAspectRatio + : GetAspectRatio(); + + auto parentFrame = GetParent(); + auto alignCB = parentFrame; + bool isGridItem = IsGridItem(); + if (parentFrame && parentFrame->IsTableWrapperFrame() && IsTableFrame()) { + // An inner table frame is sized as a grid item if its table wrapper is, + // because they actually have the same CB (the wrapper's CB). + // @see ReflowInput::InitCBReflowInput + auto tableWrapper = GetParent(); + auto grandParent = tableWrapper->GetParent(); + isGridItem = grandParent->IsGridContainerFrame() && + !tableWrapper->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW); + if (isGridItem) { + // When resolving justify/align-self below, we want to use the grid + // container's justify/align-items value and WritingMode. + alignCB = grandParent; + } + } + const bool isFlexItem = + IsFlexItem() && !parentFrame->HasAnyStateBits( + NS_STATE_FLEX_IS_EMULATING_LEGACY_WEBKIT_BOX); + // This variable only gets set (and used) if isFlexItem is true. It + // indicates which axis (in this frame's own WM) corresponds to its + // flex container's main axis. + LogicalAxis flexMainAxis = + eLogicalAxisInline; // (init to make valgrind happy) + if (isFlexItem) { + flexMainAxis = nsFlexContainerFrame::IsItemInlineAxisMainAxis(this) + ? eLogicalAxisInline + : eLogicalAxisBlock; + } + + const bool isOrthogonal = aWM.IsOrthogonalTo(alignCB->GetWritingMode()); + const bool isAutoISize = styleISize.IsAuto(); + const bool isAutoBSize = + nsLayoutUtils::IsAutoBSize(styleBSize, aCBSize.BSize(aWM)); + // Compute inline-axis size + if (!isAutoISize) { + auto iSizeResult = ComputeISizeValue( + aRenderingContext, aWM, aCBSize, boxSizingAdjust, + boxSizingToMarginEdgeISize, styleISize, aSizeOverrides, aFlags); + result.ISize(aWM) = iSizeResult.mISize; + aspectRatioUsage = iSizeResult.mAspectRatioUsage; + } else if (MOZ_UNLIKELY(isGridItem) && !IsTrueOverflowContainer()) { + // 'auto' inline-size for grid-level box - fill the CB for 'stretch' / + // 'normal' and clamp it to the CB if requested: + bool stretch = false; + bool mayUseAspectRatio = aspectRatio && !isAutoBSize; + if (!aFlags.contains(ComputeSizeFlag::ShrinkWrap) && + !StyleMargin()->HasInlineAxisAuto(aWM) && + !alignCB->IsMasonry(isOrthogonal ? eLogicalAxisBlock + : eLogicalAxisInline)) { + auto inlineAxisAlignment = + isOrthogonal ? StylePosition()->UsedAlignSelf(alignCB->Style())._0 + : StylePosition()->UsedJustifySelf(alignCB->Style())._0; + stretch = inlineAxisAlignment == StyleAlignFlags::STRETCH || + (inlineAxisAlignment == StyleAlignFlags::NORMAL && + !mayUseAspectRatio); + } + + // Apply the preferred aspect ratio for alignments other than *stretch* and + // *normal without aspect ratio*. + // The spec says all other values should size the items as fit-content, and + // the intrinsic size should respect the preferred aspect ratio, so we also + // apply aspect ratio for all other values. + // https://drafts.csswg.org/css-grid/#grid-item-sizing + if (!stretch && mayUseAspectRatio) { + // Note: we don't need to handle aspect ratio for inline axis if both + // width/height are auto. The default ratio-dependent axis is block axis + // in this case, so we can simply get the block size from the non-auto + // |styleBSize|. + auto bSize = nsLayoutUtils::ComputeBSizeValue( + aCBSize.BSize(aWM), boxSizingAdjust.BSize(aWM), + styleBSize.AsLengthPercentage()); + result.ISize(aWM) = aspectRatio.ComputeRatioDependentSize( + LogicalAxis::eLogicalAxisInline, aWM, bSize, boxSizingAdjust); + aspectRatioUsage = AspectRatioUsage::ToComputeISize; + } + + if (stretch || aFlags.contains(ComputeSizeFlag::IClampMarginBoxMinSize)) { + auto iSizeToFillCB = + std::max(nscoord(0), aCBSize.ISize(aWM) - aBorderPadding.ISize(aWM) - + aMargin.ISize(aWM)); + if (stretch || result.ISize(aWM) > iSizeToFillCB) { + result.ISize(aWM) = iSizeToFillCB; + } + } + } else if (aspectRatio && !isAutoBSize) { + auto bSize = nsLayoutUtils::ComputeBSizeValue( + aCBSize.BSize(aWM), boxSizingAdjust.BSize(aWM), + styleBSize.AsLengthPercentage()); + result.ISize(aWM) = aspectRatio.ComputeRatioDependentSize( + LogicalAxis::eLogicalAxisInline, aWM, bSize, boxSizingAdjust); + aspectRatioUsage = AspectRatioUsage::ToComputeISize; + } + + // Calculate and apply transferred min & max size contraints. + // https://drafts.csswg.org/css-sizing-4/#aspect-ratio-size-transfers + // + // Note: The basic principle is that sizing constraints transfer through the + // aspect-ratio to the other side to preserve the aspect ratio to the extent + // that they can without violating any sizes specified explicitly on that + // affected axis. + // + // FIXME: The spec words may not be correct, so we may have to update this + // tentative solution once this spec issue gets resolved. Here, we clamp the + // flex base size by the transferred min and max sizes, and don't include + // the transferred min & max sizes into its used min & max sizes. So this + // lets us match other browsers' current behaviors. + // https://github.com/w3c/csswg-drafts/issues/6071 + // + // Note: This may make more sense if we clamp the flex base size in + // FlexItem::ResolveFlexBaseSizeFromAspectRatio(). However, the result should + // be identical. FlexItem::ResolveFlexBaseSizeFromAspectRatio() only handles + // the case of the definite cross size, and the definite cross size is clamped + // by the min & max cross sizes below in this function. This means its flex + // base size has been clamped by the transferred min & max size already after + // generating the flex items. So here we make the code more general for both + // definite cross size and indefinite cross size. + const bool isDefiniteISize = styleISize.IsLengthPercentage(); + const auto& minBSizeCoord = stylePos->MinBSize(aWM); + const auto& maxBSizeCoord = stylePos->MaxBSize(aWM); + const bool isAutoMinBSize = + nsLayoutUtils::IsAutoBSize(minBSizeCoord, aCBSize.BSize(aWM)); + const bool isAutoMaxBSize = + nsLayoutUtils::IsAutoBSize(maxBSizeCoord, aCBSize.BSize(aWM)); + if (aspectRatio && !isDefiniteISize) { + const MinMaxSize minMaxBSize{ + isAutoMinBSize ? 0 + : nsLayoutUtils::ComputeBSizeValue( + aCBSize.BSize(aWM), boxSizingAdjust.BSize(aWM), + minBSizeCoord.AsLengthPercentage()), + isAutoMaxBSize ? NS_UNCONSTRAINEDSIZE + : nsLayoutUtils::ComputeBSizeValue( + aCBSize.BSize(aWM), boxSizingAdjust.BSize(aWM), + maxBSizeCoord.AsLengthPercentage())}; + MinMaxSize transferredMinMaxISize = ComputeTransferredMinMaxInlineSize( + aWM, aspectRatio, minMaxBSize, boxSizingAdjust); + + result.ISize(aWM) = + transferredMinMaxISize.ClampSizeToMinAndMax(result.ISize(aWM)); + } + + // Flex items ignore their min & max sizing properties in their + // flex container's main-axis. (Those properties get applied later in + // the flexbox algorithm.) + const bool isFlexItemInlineAxisMainAxis = + isFlexItem && flexMainAxis == eLogicalAxisInline; + const auto& maxISizeCoord = stylePos->MaxISize(aWM); + nscoord maxISize = NS_UNCONSTRAINEDSIZE; + if (!maxISizeCoord.IsNone() && !isFlexItemInlineAxisMainAxis) { + maxISize = ComputeISizeValue(aRenderingContext, aWM, aCBSize, + boxSizingAdjust, boxSizingToMarginEdgeISize, + maxISizeCoord, aSizeOverrides, aFlags) + .mISize; + result.ISize(aWM) = std::min(maxISize, result.ISize(aWM)); + } + + const auto& minISizeCoord = stylePos->MinISize(aWM); + nscoord minISize; + if (!minISizeCoord.IsAuto() && !isFlexItemInlineAxisMainAxis) { + minISize = ComputeISizeValue(aRenderingContext, aWM, aCBSize, + boxSizingAdjust, boxSizingToMarginEdgeISize, + minISizeCoord, aSizeOverrides, aFlags) + .mISize; + } else if (MOZ_UNLIKELY( + aFlags.contains(ComputeSizeFlag::IApplyAutoMinSize))) { + // This implements "Implied Minimum Size of Grid Items". + // https://drafts.csswg.org/css-grid/#min-size-auto + minISize = std::min(maxISize, GetMinISize(aRenderingContext)); + if (styleISize.IsLengthPercentage()) { + minISize = std::min(minISize, result.ISize(aWM)); + } else if (aFlags.contains(ComputeSizeFlag::IClampMarginBoxMinSize)) { + // "if the grid item spans only grid tracks that have a fixed max track + // sizing function, its automatic minimum size in that dimension is + // further clamped to less than or equal to the size necessary to fit + // its margin box within the resulting grid area (flooring at zero)" + // https://drafts.csswg.org/css-grid/#min-size-auto + auto maxMinISize = + std::max(nscoord(0), aCBSize.ISize(aWM) - aBorderPadding.ISize(aWM) - + aMargin.ISize(aWM)); + minISize = std::min(minISize, maxMinISize); + } + } else if (aspectRatioUsage == AspectRatioUsage::ToComputeISize && + ShouldApplyAutomaticMinimumOnInlineAxis(aWM, disp, stylePos)) { + // This means we successfully applied aspect-ratio and now need to check + // if we need to apply the implied minimum size: + // https://drafts.csswg.org/css-sizing-4/#aspect-ratio-minimum + MOZ_ASSERT(!IsFrameOfType(eReplacedSizing), + "aspect-ratio minimums should not apply to replaced elements"); + // The inline size computed by aspect-ratio shouldn't less than the content + // size. + minISize = GetMinISize(aRenderingContext); + } else { + // Treat "min-width: auto" as 0. + // NOTE: Technically, "auto" is supposed to behave like "min-content" on + // flex items. However, we don't need to worry about that here, because + // flex items' min-sizes are intentionally ignored until the flex + // container explicitly considers them during space distribution. + minISize = 0; + } + result.ISize(aWM) = std::max(minISize, result.ISize(aWM)); + + // Compute block-axis size + // (but not if we have auto bsize -- then, we'll just stick with the bsize + // that we already calculated in the initial ComputeAutoSize() call. However, + // if we have a valid preferred aspect ratio, we still have to compute the + // block size because aspect ratio affects the intrinsic content size.) + if (!isAutoBSize) { + result.BSize(aWM) = nsLayoutUtils::ComputeBSizeValue( + aCBSize.BSize(aWM), boxSizingAdjust.BSize(aWM), + styleBSize.AsLengthPercentage()); + } else if (MOZ_UNLIKELY(isGridItem) && styleBSize.IsAuto() && + !aFlags.contains(ComputeSizeFlag::IsGridMeasuringReflow) && + !IsTrueOverflowContainer() && + !alignCB->IsMasonry(isOrthogonal ? eLogicalAxisInline + : eLogicalAxisBlock)) { + auto cbSize = aCBSize.BSize(aWM); + if (cbSize != NS_UNCONSTRAINEDSIZE) { + // 'auto' block-size for grid-level box - fill the CB for 'stretch' / + // 'normal' and clamp it to the CB if requested: + bool stretch = false; + bool mayUseAspectRatio = + aspectRatio && result.ISize(aWM) != NS_UNCONSTRAINEDSIZE; + if (!StyleMargin()->HasBlockAxisAuto(aWM)) { + auto blockAxisAlignment = + isOrthogonal ? StylePosition()->UsedJustifySelf(alignCB->Style())._0 + : StylePosition()->UsedAlignSelf(alignCB->Style())._0; + stretch = blockAxisAlignment == StyleAlignFlags::STRETCH || + (blockAxisAlignment == StyleAlignFlags::NORMAL && + !mayUseAspectRatio); + } + + // Apply the preferred aspect ratio for alignments other than *stretch* + // and *normal without aspect ratio*. + // The spec says all other values should size the items as fit-content, + // and the intrinsic size should respect the preferred aspect ratio, so + // we also apply aspect ratio for all other values. + // https://drafts.csswg.org/css-grid/#grid-item-sizing + if (!stretch && mayUseAspectRatio) { + result.BSize(aWM) = aspectRatio.ComputeRatioDependentSize( + LogicalAxis::eLogicalAxisBlock, aWM, result.ISize(aWM), + boxSizingAdjust); + MOZ_ASSERT(aspectRatioUsage == AspectRatioUsage::None); + aspectRatioUsage = AspectRatioUsage::ToComputeBSize; + } + + if (stretch || aFlags.contains(ComputeSizeFlag::BClampMarginBoxMinSize)) { + auto bSizeToFillCB = + std::max(nscoord(0), + cbSize - aBorderPadding.BSize(aWM) - aMargin.BSize(aWM)); + if (stretch || (result.BSize(aWM) != NS_UNCONSTRAINEDSIZE && + result.BSize(aWM) > bSizeToFillCB)) { + result.BSize(aWM) = bSizeToFillCB; + } + } + } + } else if (aspectRatio) { + // If both inline and block dimensions are auto, the block axis is the + // ratio-dependent axis by default. + // If we have a super large inline size, aspect-ratio should still be + // applied (so aspectRatioUsage flag is set as expected). That's why we + // apply aspect-ratio unconditionally for auto block size here. + result.BSize(aWM) = aspectRatio.ComputeRatioDependentSize( + LogicalAxis::eLogicalAxisBlock, aWM, result.ISize(aWM), + boxSizingAdjust); + MOZ_ASSERT(aspectRatioUsage == AspectRatioUsage::None); + aspectRatioUsage = AspectRatioUsage::ToComputeBSize; + } + + if (result.BSize(aWM) != NS_UNCONSTRAINEDSIZE) { + const bool isFlexItemBlockAxisMainAxis = + isFlexItem && flexMainAxis == eLogicalAxisBlock; + if (!isAutoMaxBSize && !isFlexItemBlockAxisMainAxis) { + nscoord maxBSize = nsLayoutUtils::ComputeBSizeValue( + aCBSize.BSize(aWM), boxSizingAdjust.BSize(aWM), + maxBSizeCoord.AsLengthPercentage()); + result.BSize(aWM) = std::min(maxBSize, result.BSize(aWM)); + } + + if (!isAutoMinBSize && !isFlexItemBlockAxisMainAxis) { + nscoord minBSize = nsLayoutUtils::ComputeBSizeValue( + aCBSize.BSize(aWM), boxSizingAdjust.BSize(aWM), + minBSizeCoord.AsLengthPercentage()); + result.BSize(aWM) = std::max(minBSize, result.BSize(aWM)); + } + } + + if (IsThemed(disp)) { + nsPresContext* pc = PresContext(); + const LayoutDeviceIntSize widget = pc->Theme()->GetMinimumWidgetSize( + pc, this, disp->EffectiveAppearance()); + + // Convert themed widget's physical dimensions to logical coords + LogicalSize size(aWM, LayoutDeviceIntSize::ToAppUnits( + widget, pc->AppUnitsPerDevPixel())); + + // GetMinimumWidgetSize() returns border-box; we need content-box. + size -= aBorderPadding; + + if (size.BSize(aWM) > result.BSize(aWM)) { + result.BSize(aWM) = size.BSize(aWM); + } + if (size.ISize(aWM) > result.ISize(aWM)) { + result.ISize(aWM) = size.ISize(aWM); + } + } + + result.ISize(aWM) = std::max(0, result.ISize(aWM)); + result.BSize(aWM) = std::max(0, result.BSize(aWM)); + + return {result, aspectRatioUsage}; +} + +nsRect nsIFrame::ComputeTightBounds(DrawTarget* aDrawTarget) const { + return InkOverflowRect(); +} + +/* virtual */ +nsresult nsIFrame::GetPrefWidthTightBounds(gfxContext* aContext, nscoord* aX, + nscoord* aXMost) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +/* virtual */ +LogicalSize nsIFrame::ComputeAutoSize( + gfxContext* aRenderingContext, WritingMode aWM, + const mozilla::LogicalSize& aCBSize, nscoord aAvailableISize, + const mozilla::LogicalSize& aMargin, + const mozilla::LogicalSize& aBorderPadding, + const StyleSizeOverrides& aSizeOverrides, ComputeSizeFlags aFlags) { + // Use basic shrink-wrapping as a default implementation. + LogicalSize result(aWM, 0xdeadbeef, NS_UNCONSTRAINEDSIZE); + + // don't bother setting it if the result won't be used + const auto& styleISize = aSizeOverrides.mStyleISize + ? *aSizeOverrides.mStyleISize + : StylePosition()->ISize(aWM); + if (styleISize.IsAuto()) { + nscoord availBased = + aAvailableISize - aMargin.ISize(aWM) - aBorderPadding.ISize(aWM); + result.ISize(aWM) = ShrinkISizeToFit(aRenderingContext, availBased, aFlags); + } + return result; +} + +nscoord nsIFrame::ShrinkISizeToFit(gfxContext* aRenderingContext, + nscoord aISizeInCB, + ComputeSizeFlags aFlags) { + // If we're a container for font size inflation, then shrink + // wrapping inside of us should not apply font size inflation. + AutoMaybeDisableFontInflation an(this); + + nscoord result; + nscoord minISize = GetMinISize(aRenderingContext); + if (minISize > aISizeInCB) { + const bool clamp = aFlags.contains(ComputeSizeFlag::IClampMarginBoxMinSize); + result = MOZ_UNLIKELY(clamp) ? aISizeInCB : minISize; + } else { + nscoord prefISize = GetPrefISize(aRenderingContext); + if (prefISize > aISizeInCB) { + result = aISizeInCB; + } else { + result = prefISize; + } + } + return result; +} + +Maybe<nscoord> nsIFrame::ComputeInlineSizeFromAspectRatio( + WritingMode aWM, const LogicalSize& aCBSize, + const LogicalSize& aContentEdgeToBoxSizing, + const StyleSizeOverrides& aSizeOverrides, ComputeSizeFlags aFlags) const { + // FIXME: Bug 1670151: Use GetAspectRatio() to cover replaced elements (and + // then we can drop the check of eSupportsAspectRatio). + const AspectRatio aspectRatio = + aSizeOverrides.mAspectRatio + ? *aSizeOverrides.mAspectRatio + : StylePosition()->mAspectRatio.ToLayoutRatio(); + if (!IsFrameOfType(eSupportsAspectRatio) || !aspectRatio) { + return Nothing(); + } + + const StyleSize& styleBSize = aSizeOverrides.mStyleBSize + ? *aSizeOverrides.mStyleBSize + : StylePosition()->BSize(aWM); + if (nsLayoutUtils::IsAutoBSize(styleBSize, aCBSize.BSize(aWM))) { + return Nothing(); + } + + MOZ_ASSERT(styleBSize.IsLengthPercentage()); + nscoord bSize = nsLayoutUtils::ComputeBSizeValue( + aCBSize.BSize(aWM), aContentEdgeToBoxSizing.BSize(aWM), + styleBSize.AsLengthPercentage()); + return Some(aspectRatio.ComputeRatioDependentSize( + LogicalAxis::eLogicalAxisInline, aWM, bSize, aContentEdgeToBoxSizing)); +} + +nsIFrame::ISizeComputationResult nsIFrame::ComputeISizeValue( + gfxContext* aRenderingContext, const WritingMode aWM, + const LogicalSize& aContainingBlockSize, + const LogicalSize& aContentEdgeToBoxSizing, nscoord aBoxSizingToMarginEdge, + ExtremumLength aSize, Maybe<nscoord> aAvailableISizeOverride, + const StyleSizeOverrides& aSizeOverrides, ComputeSizeFlags aFlags) { + // If 'this' is a container for font size inflation, then shrink + // wrapping inside of it should not apply font size inflation. + AutoMaybeDisableFontInflation an(this); + // If we have an aspect-ratio and a definite block size, we resolve the + // min-content and max-content size by the aspect-ratio and the block size. + // https://github.com/w3c/csswg-drafts/issues/5032 + Maybe<nscoord> intrinsicSizeFromAspectRatio = + aSize == ExtremumLength::MozAvailable + ? Nothing() + : ComputeInlineSizeFromAspectRatio(aWM, aContainingBlockSize, + aContentEdgeToBoxSizing, + aSizeOverrides, aFlags); + nscoord result; + switch (aSize) { + case ExtremumLength::MaxContent: + result = intrinsicSizeFromAspectRatio ? *intrinsicSizeFromAspectRatio + : GetPrefISize(aRenderingContext); + NS_ASSERTION(result >= 0, "inline-size less than zero"); + return {result, intrinsicSizeFromAspectRatio + ? AspectRatioUsage::ToComputeISize + : AspectRatioUsage::None}; + case ExtremumLength::MinContent: + result = intrinsicSizeFromAspectRatio ? *intrinsicSizeFromAspectRatio + : GetMinISize(aRenderingContext); + NS_ASSERTION(result >= 0, "inline-size less than zero"); + if (MOZ_UNLIKELY( + aFlags.contains(ComputeSizeFlag::IClampMarginBoxMinSize))) { + auto available = + aContainingBlockSize.ISize(aWM) - + (aBoxSizingToMarginEdge + aContentEdgeToBoxSizing.ISize(aWM)); + result = std::min(available, result); + } + return {result, intrinsicSizeFromAspectRatio + ? AspectRatioUsage::ToComputeISize + : AspectRatioUsage::None}; + case ExtremumLength::FitContentFunction: + case ExtremumLength::FitContent: { + nscoord pref = NS_UNCONSTRAINEDSIZE; + nscoord min = 0; + if (intrinsicSizeFromAspectRatio) { + // The min-content and max-content size are identical and equal to the + // size computed from the block size and the aspect ratio. + pref = min = *intrinsicSizeFromAspectRatio; + } else { + pref = GetPrefISize(aRenderingContext); + min = GetMinISize(aRenderingContext); + } + + nscoord fill = aAvailableISizeOverride + ? *aAvailableISizeOverride + : aContainingBlockSize.ISize(aWM) - + (aBoxSizingToMarginEdge + + aContentEdgeToBoxSizing.ISize(aWM)); + + if (MOZ_UNLIKELY( + aFlags.contains(ComputeSizeFlag::IClampMarginBoxMinSize))) { + min = std::min(min, fill); + } + result = std::max(min, std::min(pref, fill)); + NS_ASSERTION(result >= 0, "inline-size less than zero"); + return {result}; + } + case ExtremumLength::MozAvailable: + return {aContainingBlockSize.ISize(aWM) - + (aBoxSizingToMarginEdge + aContentEdgeToBoxSizing.ISize(aWM))}; + } + MOZ_ASSERT_UNREACHABLE("Unknown extremum length?"); + return {}; +} + +nscoord nsIFrame::ComputeISizeValue(const WritingMode aWM, + const LogicalSize& aContainingBlockSize, + const LogicalSize& aContentEdgeToBoxSizing, + const LengthPercentage& aSize) { + LAYOUT_WARN_IF_FALSE( + aContainingBlockSize.ISize(aWM) != NS_UNCONSTRAINEDSIZE, + "have unconstrained inline-size; this should only result from " + "very large sizes, not attempts at intrinsic inline-size " + "calculation"); + NS_ASSERTION(aContainingBlockSize.ISize(aWM) >= 0, + "inline-size less than zero"); + + nscoord result = aSize.Resolve(aContainingBlockSize.ISize(aWM)); + // The result of a calc() expression might be less than 0; we + // should clamp at runtime (below). (Percentages and coords that + // are less than 0 have already been dropped by the parser.) + result -= aContentEdgeToBoxSizing.ISize(aWM); + return std::max(0, result); +} + +void nsIFrame::DidReflow(nsPresContext* aPresContext, + const ReflowInput* aReflowInput) { + NS_FRAME_TRACE(NS_FRAME_TRACE_CALLS, ("nsIFrame::DidReflow")); + + if (IsHiddenByContentVisibilityOfInFlowParentForLayout()) { + RemoveStateBits(NS_FRAME_IN_REFLOW | NS_FRAME_FIRST_REFLOW); + return; + } + + SVGObserverUtils::InvalidateDirectRenderingObservers( + this, SVGObserverUtils::INVALIDATE_REFLOW); + + RemoveStateBits(NS_FRAME_IN_REFLOW | NS_FRAME_FIRST_REFLOW | + NS_FRAME_IS_DIRTY | NS_FRAME_HAS_DIRTY_CHILDREN); + + // Clear bits that were used in ReflowInput::InitResizeFlags (see + // comment there for why we can't clear it there). + SetHasBSizeChange(false); + SetHasPaddingChange(false); + + // Notify the percent bsize observer if there is a percent bsize. + // The observer may be able to initiate another reflow with a computed + // bsize. This happens in the case where a table cell has no computed + // bsize but can fabricate one when the cell bsize is known. + if (aReflowInput && aReflowInput->mPercentBSizeObserver && !GetPrevInFlow()) { + const auto& bsize = + aReflowInput->mStylePosition->BSize(aReflowInput->GetWritingMode()); + if (bsize.HasPercent()) { + aReflowInput->mPercentBSizeObserver->NotifyPercentBSize(*aReflowInput); + } + } + + aPresContext->ReflowedFrame(); + +#ifdef ACCESSIBILITY + if (nsAccessibilityService* accService = GetAccService()) { + accService->NotifyOfPossibleBoundsChange(PresShell(), mContent); + } +#endif +} + +void nsIFrame::FinishReflowWithAbsoluteFrames(nsPresContext* aPresContext, + ReflowOutput& aDesiredSize, + const ReflowInput& aReflowInput, + nsReflowStatus& aStatus, + bool aConstrainBSize) { + ReflowAbsoluteFrames(aPresContext, aDesiredSize, aReflowInput, aStatus, + aConstrainBSize); + + FinishAndStoreOverflow(&aDesiredSize, aReflowInput.mStyleDisplay); +} + +void nsIFrame::ReflowAbsoluteFrames(nsPresContext* aPresContext, + ReflowOutput& aDesiredSize, + const ReflowInput& aReflowInput, + nsReflowStatus& aStatus, + bool aConstrainBSize) { + if (HasAbsolutelyPositionedChildren()) { + nsAbsoluteContainingBlock* absoluteContainer = GetAbsoluteContainingBlock(); + + // Let the absolutely positioned container reflow any absolutely positioned + // child frames that need to be reflowed + + // The containing block for the abs pos kids is formed by our padding edge. + nsMargin usedBorder = GetUsedBorder(); + nscoord containingBlockWidth = + std::max(0, aDesiredSize.Width() - usedBorder.LeftRight()); + nscoord containingBlockHeight = + std::max(0, aDesiredSize.Height() - usedBorder.TopBottom()); + nsContainerFrame* container = do_QueryFrame(this); + NS_ASSERTION(container, + "Abs-pos children only supported on container frames for now"); + + nsRect containingBlock(0, 0, containingBlockWidth, containingBlockHeight); + AbsPosReflowFlags flags = + AbsPosReflowFlags::CBWidthAndHeightChanged; // XXX could be optimized + if (aConstrainBSize) { + flags |= AbsPosReflowFlags::ConstrainHeight; + } + absoluteContainer->Reflow(container, aPresContext, aReflowInput, aStatus, + containingBlock, flags, + &aDesiredSize.mOverflowAreas); + } +} + +/* virtual */ +bool nsIFrame::CanContinueTextRun() const { + // By default, a frame will *not* allow a text run to be continued + // through it. + return false; +} + +void nsIFrame::Reflow(nsPresContext* aPresContext, ReflowOutput& aDesiredSize, + const ReflowInput& aReflowInput, + nsReflowStatus& aStatus) { + MarkInReflow(); + DO_GLOBAL_REFLOW_COUNT("nsFrame"); + MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!"); + aDesiredSize.ClearSize(); +} + +bool nsIFrame::IsContentDisabled() const { + // FIXME(emilio): Doing this via CSS means callers must ensure the style is up + // to date, and they don't! + if (StyleUI()->UserInput() == StyleUserInput::None) { + return true; + } + + auto* element = nsGenericHTMLElement::FromNodeOrNull(GetContent()); + return element && element->IsDisabled(); +} + +bool nsIFrame::IsContentRelevant() const { + MOZ_ASSERT(StyleDisplay()->ContentVisibility(*this) == + StyleContentVisibility::Auto); + + auto* element = Element::FromNodeOrNull(GetContent()); + MOZ_ASSERT(element); + + Maybe<ContentRelevancy> relevancy = element->GetContentRelevancy(); + if (relevancy.isSome()) { + return !relevancy->isEmpty(); + } + + // If there is no relevancy set, then this frame still has not received had + // the initial visibility callback call. In that case, only rely on whether + // or not it is inside a top layer element which will never change for this + // frame and allows proper rendering of the top layer. + return IsDescendantOfTopLayerElement(); +} + +bool nsIFrame::HidesContent( + const EnumSet<IncludeContentVisibility>& aInclude) const { + auto effectiveContentVisibility = StyleDisplay()->ContentVisibility(*this); + if (aInclude.contains(IncludeContentVisibility::Hidden) && + effectiveContentVisibility == StyleContentVisibility::Hidden) { + return true; + } + + if (aInclude.contains(IncludeContentVisibility::Auto) && + effectiveContentVisibility == StyleContentVisibility::Auto) { + return !IsContentRelevant(); + } + + return false; +} + +bool nsIFrame::HidesContentForLayout() const { + return HidesContent() && !PresShell()->IsForcingLayoutForHiddenContent(this); +} + +bool nsIFrame::IsHiddenByContentVisibilityOfInFlowParentForLayout() const { + const auto* parent = GetInFlowParent(); + return parent && parent->HidesContentForLayout() && + !(Style()->IsAnonBox() && !IsFrameOfType(nsIFrame::eLineParticipant)); +} + +bool nsIFrame::IsHiddenByContentVisibilityOnAnyAncestor( + const EnumSet<IncludeContentVisibility>& aInclude) const { + if (!StaticPrefs::layout_css_content_visibility_enabled()) { + return false; + } + + bool isAnonymousBlock = + Style()->IsAnonBox() && !IsFrameOfType(nsIFrame::eLineParticipant); + for (nsIFrame* cur = GetInFlowParent(); cur; cur = cur->GetInFlowParent()) { + if (!isAnonymousBlock && cur->HidesContent(aInclude)) { + return true; + } + + // Anonymous boxes are not hidden by the content-visibility of their first + // non-anonymous ancestor, but can be hidden by ancestors further up the + // tree. + isAnonymousBlock = false; + } + + return false; +} + +bool nsIFrame::HasSelectionInSubtree() { + if (IsSelected()) { + return true; + } + + RefPtr<nsFrameSelection> frameSelection = GetFrameSelection(); + if (!frameSelection) { + return false; + } + + const Selection* selection = + frameSelection->GetSelection(SelectionType::eNormal); + if (!selection) { + return false; + } + + for (uint32_t i = 0; i < selection->RangeCount(); i++) { + auto* range = selection->GetRangeAt(i); + MOZ_ASSERT(range); + + const auto* commonAncestorNode = + range->GetRegisteredClosestCommonInclusiveAncestor(); + if (commonAncestorNode && + commonAncestorNode->IsInclusiveDescendantOf(GetContent())) { + return true; + } + } + + return false; +} + +bool nsIFrame::IsDescendantOfTopLayerElement() const { + if (!GetContent()) { + return false; + } + + nsTArray<dom::Element*> topLayer = PresContext()->Document()->GetTopLayer(); + for (auto* element : topLayer) { + if (GetContent()->IsInclusiveFlatTreeDescendantOf(element)) { + return true; + } + } + + return false; +} + +void nsIFrame::UpdateIsRelevantContent( + const ContentRelevancy& aRelevancyToUpdate) { + MOZ_ASSERT(StyleDisplay()->ContentVisibility(*this) == + StyleContentVisibility::Auto); + + auto* element = Element::FromNodeOrNull(GetContent()); + MOZ_ASSERT(element); + + ContentRelevancy newRelevancy; + Maybe<ContentRelevancy> oldRelevancy = element->GetContentRelevancy(); + if (oldRelevancy.isSome()) { + newRelevancy = *oldRelevancy; + } + + auto setRelevancyValue = [&](ContentRelevancyReason reason, bool value) { + if (value) { + newRelevancy += reason; + } else { + newRelevancy -= reason; + } + }; + + if (!oldRelevancy || + aRelevancyToUpdate.contains(ContentRelevancyReason::Visible)) { + Maybe<bool> visible = element->GetVisibleForContentVisibility(); + if (visible.isSome()) { + setRelevancyValue(ContentRelevancyReason::Visible, *visible); + } + } + + if (!oldRelevancy || + aRelevancyToUpdate.contains(ContentRelevancyReason::FocusInSubtree)) { + setRelevancyValue(ContentRelevancyReason::FocusInSubtree, + element->State().HasAtLeastOneOfStates( + ElementState::FOCUS_WITHIN | ElementState::FOCUS)); + } + + if (!oldRelevancy || + aRelevancyToUpdate.contains(ContentRelevancyReason::Selected)) { + setRelevancyValue(ContentRelevancyReason::Selected, + HasSelectionInSubtree()); + } + + bool overallRelevancyChanged = + !oldRelevancy || oldRelevancy->isEmpty() != newRelevancy.isEmpty(); + if (!oldRelevancy || *oldRelevancy != newRelevancy) { + element->SetContentRelevancy(newRelevancy); + } + + if (!overallRelevancyChanged) { + return; + } + + HandleLastRememberedSize(); + PresShell()->FrameNeedsReflow( + this, IntrinsicDirty::FrameAncestorsAndDescendants, NS_FRAME_IS_DIRTY); + InvalidateFrame(); + + ContentVisibilityAutoStateChangeEventInit init; + init.mSkipped = newRelevancy.isEmpty(); + RefPtr<ContentVisibilityAutoStateChangeEvent> event = + ContentVisibilityAutoStateChangeEvent::Constructor( + element, u"contentvisibilityautostatechange"_ns, init); + + // Per + // https://drafts.csswg.org/css-contain/#content-visibility-auto-state-changed + // "This event is dispatched by posting a task at the time when the state + // change occurs." + RefPtr<AsyncEventDispatcher> asyncDispatcher = + new AsyncEventDispatcher(element, event.get()); + DebugOnly<nsresult> rv = asyncDispatcher->PostDOMEvent(); + NS_ASSERTION(NS_SUCCEEDED(rv), "AsyncEventDispatcher failed to dispatch"); +} + +nsresult nsIFrame::CharacterDataChanged(const CharacterDataChangeInfo&) { + MOZ_ASSERT_UNREACHABLE("should only be called for text frames"); + return NS_OK; +} + +nsresult nsIFrame::AttributeChanged(int32_t aNameSpaceID, nsAtom* aAttribute, + int32_t aModType) { + return NS_OK; +} + +// Flow member functions + +nsIFrame* nsIFrame::GetPrevContinuation() const { return nullptr; } + +void nsIFrame::SetPrevContinuation(nsIFrame* aPrevContinuation) { + MOZ_ASSERT(false, "not splittable"); +} + +nsIFrame* nsIFrame::GetNextContinuation() const { return nullptr; } + +void nsIFrame::SetNextContinuation(nsIFrame*) { + MOZ_ASSERT(false, "not splittable"); +} + +nsIFrame* nsIFrame::GetPrevInFlow() const { return nullptr; } + +void nsIFrame::SetPrevInFlow(nsIFrame* aPrevInFlow) { + MOZ_ASSERT(false, "not splittable"); +} + +nsIFrame* nsIFrame::GetNextInFlow() const { return nullptr; } + +void nsIFrame::SetNextInFlow(nsIFrame*) { MOZ_ASSERT(false, "not splittable"); } + +nsIFrame* nsIFrame::GetTailContinuation() { + nsIFrame* frame = this; + while (frame->HasAnyStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER)) { + frame = frame->GetPrevContinuation(); + NS_ASSERTION(frame, "first continuation can't be overflow container"); + } + for (nsIFrame* next = frame->GetNextContinuation(); + next && !next->HasAnyStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER); + next = frame->GetNextContinuation()) { + frame = next; + } + + MOZ_ASSERT(frame, "illegal state in continuation chain."); + return frame; +} + +// Associated view object +void nsIFrame::SetView(nsView* aView) { + if (aView) { + aView->SetFrame(this); + +#ifdef DEBUG + LayoutFrameType frameType = Type(); + NS_ASSERTION(frameType == LayoutFrameType::SubDocument || + frameType == LayoutFrameType::ListControl || + frameType == LayoutFrameType::Viewport || + frameType == LayoutFrameType::MenuPopup, + "Only specific frame types can have an nsView"); +#endif + + // Store the view on the frame. + SetViewInternal(aView); + + // Set the frame state bit that says the frame has a view + AddStateBits(NS_FRAME_HAS_VIEW); + + // Let all of the ancestors know they have a descendant with a view. + for (nsIFrame* f = GetParent(); + f && !f->HasAnyStateBits(NS_FRAME_HAS_CHILD_WITH_VIEW); + f = f->GetParent()) + f->AddStateBits(NS_FRAME_HAS_CHILD_WITH_VIEW); + } else { + MOZ_ASSERT_UNREACHABLE("Destroying a view while the frame is alive?"); + RemoveStateBits(NS_FRAME_HAS_VIEW); + SetViewInternal(nullptr); + } +} + +// Find the first geometric parent that has a view +nsIFrame* nsIFrame::GetAncestorWithView() const { + for (nsIFrame* f = GetParent(); nullptr != f; f = f->GetParent()) { + if (f->HasView()) { + return f; + } + } + return nullptr; +} + +template <nsPoint (nsIFrame::*PositionGetter)() const> +static nsPoint OffsetCalculator(const nsIFrame* aThis, const nsIFrame* aOther) { + MOZ_ASSERT(aOther, "Must have frame for destination coordinate system!"); + + NS_ASSERTION(aThis->PresContext() == aOther->PresContext(), + "GetOffsetTo called on frames in different documents"); + + nsPoint offset(0, 0); + const nsIFrame* f; + for (f = aThis; f != aOther && f; f = f->GetParent()) { + offset += (f->*PositionGetter)(); + } + + if (f != aOther) { + // Looks like aOther wasn't an ancestor of |this|. So now we have + // the root-frame-relative position of |this| in |offset|. Convert back + // to the coordinates of aOther + while (aOther) { + offset -= (aOther->*PositionGetter)(); + aOther = aOther->GetParent(); + } + } + + return offset; +} + +nsPoint nsIFrame::GetOffsetTo(const nsIFrame* aOther) const { + return OffsetCalculator<&nsIFrame::GetPosition>(this, aOther); +} + +nsPoint nsIFrame::GetOffsetToIgnoringScrolling(const nsIFrame* aOther) const { + return OffsetCalculator<&nsIFrame::GetPositionIgnoringScrolling>(this, + aOther); +} + +nsPoint nsIFrame::GetOffsetToCrossDoc(const nsIFrame* aOther) const { + return GetOffsetToCrossDoc(aOther, PresContext()->AppUnitsPerDevPixel()); +} + +nsPoint nsIFrame::GetOffsetToCrossDoc(const nsIFrame* aOther, + const int32_t aAPD) const { + MOZ_ASSERT(aOther, "Must have frame for destination coordinate system!"); + NS_ASSERTION(PresContext()->GetRootPresContext() == + aOther->PresContext()->GetRootPresContext(), + "trying to get the offset between frames in different document " + "hierarchies?"); + if (PresContext()->GetRootPresContext() != + aOther->PresContext()->GetRootPresContext()) { + // crash right away, we are almost certainly going to crash anyway. + MOZ_CRASH( + "trying to get the offset between frames in different " + "document hierarchies?"); + } + + const nsIFrame* root = nullptr; + // offset will hold the final offset + // docOffset holds the currently accumulated offset at the current APD, it + // will be converted and added to offset when the current APD changes. + nsPoint offset(0, 0), docOffset(0, 0); + const nsIFrame* f = this; + int32_t currAPD = PresContext()->AppUnitsPerDevPixel(); + while (f && f != aOther) { + docOffset += f->GetPosition(); + nsIFrame* parent = f->GetParent(); + if (parent) { + f = parent; + } else { + nsPoint newOffset(0, 0); + root = f; + f = nsLayoutUtils::GetCrossDocParentFrameInProcess(f, &newOffset); + int32_t newAPD = f ? f->PresContext()->AppUnitsPerDevPixel() : 0; + if (!f || newAPD != currAPD) { + // Convert docOffset to the right APD and add it to offset. + offset += docOffset.ScaleToOtherAppUnits(currAPD, aAPD); + docOffset.x = docOffset.y = 0; + } + currAPD = newAPD; + docOffset += newOffset; + } + } + if (f == aOther) { + offset += docOffset.ScaleToOtherAppUnits(currAPD, aAPD); + } else { + // Looks like aOther wasn't an ancestor of |this|. So now we have + // the root-document-relative position of |this| in |offset|. Subtract the + // root-document-relative position of |aOther| from |offset|. + // This call won't try to recurse again because root is an ancestor of + // aOther. + nsPoint negOffset = aOther->GetOffsetToCrossDoc(root, aAPD); + offset -= negOffset; + } + + return offset; +} + +CSSIntRect nsIFrame::GetScreenRect() const { + return CSSIntRect::FromAppUnitsToNearest(GetScreenRectInAppUnits()); +} + +nsRect nsIFrame::GetScreenRectInAppUnits() const { + nsPresContext* presContext = PresContext(); + nsIFrame* rootFrame = presContext->PresShell()->GetRootFrame(); + nsPoint rootScreenPos(0, 0); + nsPoint rootFrameOffsetInParent(0, 0); + nsIFrame* rootFrameParent = nsLayoutUtils::GetCrossDocParentFrameInProcess( + rootFrame, &rootFrameOffsetInParent); + if (rootFrameParent) { + nsRect parentScreenRectAppUnits = + rootFrameParent->GetScreenRectInAppUnits(); + nsPresContext* parentPresContext = rootFrameParent->PresContext(); + double parentScale = double(presContext->AppUnitsPerDevPixel()) / + parentPresContext->AppUnitsPerDevPixel(); + nsPoint rootPt = + parentScreenRectAppUnits.TopLeft() + rootFrameOffsetInParent; + rootScreenPos.x = NS_round(parentScale * rootPt.x); + rootScreenPos.y = NS_round(parentScale * rootPt.y); + } else { + nsCOMPtr<nsIWidget> rootWidget = + presContext->PresShell()->GetViewManager()->GetRootWidget(); + if (rootWidget) { + LayoutDeviceIntPoint rootDevPx = rootWidget->WidgetToScreenOffset(); + rootScreenPos.x = presContext->DevPixelsToAppUnits(rootDevPx.x); + rootScreenPos.y = presContext->DevPixelsToAppUnits(rootDevPx.y); + } + } + + return nsRect(rootScreenPos + GetOffsetTo(rootFrame), GetSize()); +} + +// Returns the offset from this frame to the closest geometric parent that +// has a view. Also returns the containing view or null in case of error +void nsIFrame::GetOffsetFromView(nsPoint& aOffset, nsView** aView) const { + MOZ_ASSERT(nullptr != aView, "null OUT parameter pointer"); + nsIFrame* frame = const_cast<nsIFrame*>(this); + + *aView = nullptr; + aOffset.MoveTo(0, 0); + do { + aOffset += frame->GetPosition(); + frame = frame->GetParent(); + } while (frame && !frame->HasView()); + + if (frame) { + *aView = frame->GetView(); + } +} + +nsIWidget* nsIFrame::GetNearestWidget() const { + return GetClosestView()->GetNearestWidget(nullptr); +} + +nsIWidget* nsIFrame::GetNearestWidget(nsPoint& aOffset) const { + nsPoint offsetToView; + nsPoint offsetToWidget; + nsIWidget* widget = + GetClosestView(&offsetToView)->GetNearestWidget(&offsetToWidget); + aOffset = offsetToView + offsetToWidget; + return widget; +} + +Matrix4x4Flagged nsIFrame::GetTransformMatrix(ViewportType aViewportType, + RelativeTo aStopAtAncestor, + nsIFrame** aOutAncestor, + uint32_t aFlags) const { + MOZ_ASSERT(aOutAncestor, "Need a place to put the ancestor!"); + + /* If we're transformed, we want to hand back the combination + * transform/translate matrix that will apply our current transform, then + * shift us to our parent. + */ + const bool isTransformed = IsTransformed(); + const nsIFrame* zoomedContentRoot = nullptr; + if (aStopAtAncestor.mViewportType == ViewportType::Visual) { + zoomedContentRoot = ViewportUtils::IsZoomedContentRoot(this); + if (zoomedContentRoot) { + MOZ_ASSERT(aViewportType != ViewportType::Visual); + } + } + + if (isTransformed || zoomedContentRoot) { + Matrix4x4 result; + int32_t scaleFactor = + ((aFlags & IN_CSS_UNITS) ? AppUnitsPerCSSPixel() + : PresContext()->AppUnitsPerDevPixel()); + + /* Compute the delta to the parent, which we need because we are converting + * coordinates to our parent. + */ + if (isTransformed) { + NS_ASSERTION(nsLayoutUtils::GetCrossDocParentFrameInProcess(this), + "Cannot transform the viewport frame!"); + + result = result * nsDisplayTransform::GetResultingTransformMatrix( + this, nsPoint(0, 0), scaleFactor, + nsDisplayTransform::INCLUDE_PERSPECTIVE | + nsDisplayTransform::OFFSET_BY_ORIGIN); + } + + // The offset from a zoomed content root to its parent (e.g. from + // a canvas frame to a scroll frame) is in layout coordinates, so + // apply it before applying any layout-to-visual transform. + *aOutAncestor = nsLayoutUtils::GetCrossDocParentFrameInProcess(this); + nsPoint delta = GetOffsetToCrossDoc(*aOutAncestor); + /* Combine the raw transform with a translation to our parent. */ + result.PostTranslate(NSAppUnitsToFloatPixels(delta.x, scaleFactor), + NSAppUnitsToFloatPixels(delta.y, scaleFactor), 0.0f); + + if (zoomedContentRoot) { + Matrix4x4 layoutToVisual; + ScrollableLayerGuid::ViewID targetScrollId = + nsLayoutUtils::FindOrCreateIDFor(zoomedContentRoot->GetContent()); + if (aFlags & nsIFrame::IN_CSS_UNITS) { + layoutToVisual = + ViewportUtils::GetVisualToLayoutTransform(targetScrollId) + .Inverse() + .ToUnknownMatrix(); + } else { + layoutToVisual = + ViewportUtils::GetVisualToLayoutTransform<LayoutDevicePixel>( + targetScrollId) + .Inverse() + .ToUnknownMatrix(); + } + result = result * layoutToVisual; + } + + return result; + } + + *aOutAncestor = nsLayoutUtils::GetCrossDocParentFrameInProcess(this); + + /* Otherwise, we're not transformed. In that case, we'll walk up the frame + * tree until we either hit the root frame or something that may be + * transformed. We'll then change coordinates into that frame, since we're + * guaranteed that nothing in-between can be transformed. First, however, + * we have to check to see if we have a parent. If not, we'll set the + * outparam to null (indicating that there's nothing left) and will hand back + * the identity matrix. + */ + if (!*aOutAncestor) return Matrix4x4(); + + /* Keep iterating while the frame can't possibly be transformed. */ + const nsIFrame* current = this; + auto shouldStopAt = [](const nsIFrame* aCurrent, nsIFrame* aAncestor, + uint32_t aFlags) { + return aAncestor->IsTransformed() || nsLayoutUtils::IsPopup(aAncestor) || + ViewportUtils::IsZoomedContentRoot(aAncestor) || + ((aFlags & STOP_AT_STACKING_CONTEXT_AND_DISPLAY_PORT) && + (aAncestor->IsStackingContext() || + DisplayPortUtils::FrameHasDisplayPort(aAncestor, aCurrent))); + }; + while (*aOutAncestor != aStopAtAncestor.mFrame && + !shouldStopAt(current, *aOutAncestor, aFlags)) { + /* If no parent, stop iterating. Otherwise, update the ancestor. */ + nsIFrame* parent = + nsLayoutUtils::GetCrossDocParentFrameInProcess(*aOutAncestor); + if (!parent) break; + + current = *aOutAncestor; + *aOutAncestor = parent; + } + + NS_ASSERTION(*aOutAncestor, "Somehow ended up with a null ancestor...?"); + + /* Translate from this frame to our ancestor, if it exists. That's the + * entire transform, so we're done. + */ + nsPoint delta = GetOffsetToCrossDoc(*aOutAncestor); + int32_t scaleFactor = + ((aFlags & IN_CSS_UNITS) ? AppUnitsPerCSSPixel() + : PresContext()->AppUnitsPerDevPixel()); + return Matrix4x4::Translation(NSAppUnitsToFloatPixels(delta.x, scaleFactor), + NSAppUnitsToFloatPixels(delta.y, scaleFactor), + 0.0f); +} + +static void InvalidateRenderingObservers(nsIFrame* aDisplayRoot, + nsIFrame* aFrame, + bool aFrameChanged = true) { + MOZ_ASSERT(aDisplayRoot == nsLayoutUtils::GetDisplayRootFrame(aFrame)); + SVGObserverUtils::InvalidateDirectRenderingObservers(aFrame); + nsIFrame* parent = aFrame; + while (parent != aDisplayRoot && + (parent = nsLayoutUtils::GetCrossDocParentFrameInProcess(parent)) && + !parent->HasAnyStateBits(NS_FRAME_DESCENDANT_NEEDS_PAINT)) { + SVGObserverUtils::InvalidateDirectRenderingObservers(parent); + } + + if (!aFrameChanged) { + return; + } + + aFrame->MarkNeedsDisplayItemRebuild(); +} + +static void SchedulePaintInternal( + nsIFrame* aDisplayRoot, nsIFrame* aFrame, + nsIFrame::PaintType aType = nsIFrame::PAINT_DEFAULT) { + MOZ_ASSERT(aDisplayRoot == nsLayoutUtils::GetDisplayRootFrame(aFrame)); + nsPresContext* pres = aDisplayRoot->PresContext()->GetRootPresContext(); + + // No need to schedule a paint for an external document since they aren't + // painted directly. + if (!pres || (pres->Document() && pres->Document()->IsResourceDoc())) { + return; + } + if (!pres->GetContainerWeak()) { + NS_WARNING("Shouldn't call SchedulePaint in a detached pres context"); + return; + } + + pres->PresShell()->ScheduleViewManagerFlush(); + + if (aType == nsIFrame::PAINT_DEFAULT) { + aDisplayRoot->AddStateBits(NS_FRAME_UPDATE_LAYER_TREE); + } +} + +static void InvalidateFrameInternal(nsIFrame* aFrame, bool aHasDisplayItem, + bool aRebuildDisplayItems) { + if (aHasDisplayItem) { + aFrame->AddStateBits(NS_FRAME_NEEDS_PAINT); + } + + if (aRebuildDisplayItems) { + aFrame->MarkNeedsDisplayItemRebuild(); + } + SVGObserverUtils::InvalidateDirectRenderingObservers(aFrame); + bool needsSchedulePaint = false; + if (nsLayoutUtils::IsPopup(aFrame)) { + needsSchedulePaint = true; + } else { + nsIFrame* parent = nsLayoutUtils::GetCrossDocParentFrameInProcess(aFrame); + while (parent && + !parent->HasAnyStateBits(NS_FRAME_DESCENDANT_NEEDS_PAINT)) { + if (aHasDisplayItem && !parent->HasAnyStateBits(NS_FRAME_IS_NONDISPLAY)) { + parent->AddStateBits(NS_FRAME_DESCENDANT_NEEDS_PAINT); + } + SVGObserverUtils::InvalidateDirectRenderingObservers(parent); + + // If we're inside a popup, then we need to make sure that we + // call schedule paint so that the NS_FRAME_UPDATE_LAYER_TREE + // flag gets added to the popup display root frame. + if (nsLayoutUtils::IsPopup(parent)) { + needsSchedulePaint = true; + break; + } + parent = nsLayoutUtils::GetCrossDocParentFrameInProcess(parent); + } + if (!parent) { + needsSchedulePaint = true; + } + } + if (!aHasDisplayItem) { + return; + } + if (needsSchedulePaint) { + nsIFrame* displayRoot = nsLayoutUtils::GetDisplayRootFrame(aFrame); + SchedulePaintInternal(displayRoot, aFrame); + } + if (aFrame->HasAnyStateBits(NS_FRAME_HAS_INVALID_RECT)) { + aFrame->RemoveProperty(nsIFrame::InvalidationRect()); + aFrame->RemoveStateBits(NS_FRAME_HAS_INVALID_RECT); + } +} + +void nsIFrame::InvalidateFrameSubtree(bool aRebuildDisplayItems /* = true */) { + InvalidateFrame(0, aRebuildDisplayItems); + + if (HasAnyStateBits(NS_FRAME_ALL_DESCENDANTS_NEED_PAINT)) { + return; + } + + AddStateBits(NS_FRAME_ALL_DESCENDANTS_NEED_PAINT); + + for (const auto& childList : CrossDocChildLists()) { + for (nsIFrame* child : childList.mList) { + // Don't explicitly rebuild display items for our descendants, + // since we should be marked and it implicitly includes all + // descendants. + child->InvalidateFrameSubtree(false); + } + } +} + +void nsIFrame::ClearInvalidationStateBits() { + if (HasAnyStateBits(NS_FRAME_DESCENDANT_NEEDS_PAINT)) { + for (const auto& childList : CrossDocChildLists()) { + for (nsIFrame* child : childList.mList) { + child->ClearInvalidationStateBits(); + } + } + } + + RemoveStateBits(NS_FRAME_NEEDS_PAINT | NS_FRAME_DESCENDANT_NEEDS_PAINT | + NS_FRAME_ALL_DESCENDANTS_NEED_PAINT); +} + +bool HasRetainedDataFor(const nsIFrame* aFrame, uint32_t aDisplayItemKey) { + if (RefPtr<WebRenderUserData> data = + GetWebRenderUserData<WebRenderFallbackData>(aFrame, + aDisplayItemKey)) { + return true; + } + + return false; +} + +void nsIFrame::InvalidateFrame(uint32_t aDisplayItemKey, + bool aRebuildDisplayItems /* = true */) { + bool hasDisplayItem = + !aDisplayItemKey || HasRetainedDataFor(this, aDisplayItemKey); + InvalidateFrameInternal(this, hasDisplayItem, aRebuildDisplayItems); +} + +void nsIFrame::InvalidateFrameWithRect(const nsRect& aRect, + uint32_t aDisplayItemKey, + bool aRebuildDisplayItems /* = true */) { + if (aRect.IsEmpty()) { + return; + } + bool hasDisplayItem = + !aDisplayItemKey || HasRetainedDataFor(this, aDisplayItemKey); + bool alreadyInvalid = false; + if (!HasAnyStateBits(NS_FRAME_NEEDS_PAINT)) { + InvalidateFrameInternal(this, hasDisplayItem, aRebuildDisplayItems); + } else { + alreadyInvalid = true; + } + + if (!hasDisplayItem) { + return; + } + + nsRect* rect; + if (HasAnyStateBits(NS_FRAME_HAS_INVALID_RECT)) { + rect = GetProperty(InvalidationRect()); + MOZ_ASSERT(rect); + } else { + if (alreadyInvalid) { + return; + } + rect = new nsRect(); + AddProperty(InvalidationRect(), rect); + AddStateBits(NS_FRAME_HAS_INVALID_RECT); + } + + *rect = rect->Union(aRect); +} + +/*static*/ +uint8_t nsIFrame::sLayerIsPrerenderedDataKey; + +bool nsIFrame::IsInvalid(nsRect& aRect) { + if (!HasAnyStateBits(NS_FRAME_NEEDS_PAINT)) { + return false; + } + + if (HasAnyStateBits(NS_FRAME_HAS_INVALID_RECT)) { + nsRect* rect = GetProperty(InvalidationRect()); + NS_ASSERTION( + rect, "Must have an invalid rect if NS_FRAME_HAS_INVALID_RECT is set!"); + aRect = *rect; + } else { + aRect.SetEmpty(); + } + return true; +} + +void nsIFrame::SchedulePaint(PaintType aType, bool aFrameChanged) { + if (PresShell()->IsPaintingSuppressed()) { + // We can't have any display items yet, and when we unsuppress we will + // invalidate the root frame. + return; + } + nsIFrame* displayRoot = nsLayoutUtils::GetDisplayRootFrame(this); + InvalidateRenderingObservers(displayRoot, this, aFrameChanged); + SchedulePaintInternal(displayRoot, this, aType); +} + +void nsIFrame::SchedulePaintWithoutInvalidatingObservers(PaintType aType) { + nsIFrame* displayRoot = nsLayoutUtils::GetDisplayRootFrame(this); + SchedulePaintInternal(displayRoot, this, aType); +} + +void nsIFrame::InvalidateLayer(DisplayItemType aDisplayItemKey, + const nsIntRect* aDamageRect, + const nsRect* aFrameDamageRect, + uint32_t aFlags /* = 0 */) { + NS_ASSERTION(aDisplayItemKey > DisplayItemType::TYPE_ZERO, "Need a key"); + + nsIFrame* displayRoot = nsLayoutUtils::GetDisplayRootFrame(this); + InvalidateRenderingObservers(displayRoot, this, false); + + // Check if frame supports WebRender's async update + if ((aFlags & UPDATE_IS_ASYNC) && + WebRenderUserData::SupportsAsyncUpdate(this)) { + // WebRender does not use layer, then return nullptr. + return; + } + + if (aFrameDamageRect && aFrameDamageRect->IsEmpty()) { + return; + } + + // In the bug 930056, dialer app startup but not shown on the + // screen because sometimes we don't have any retainned data + // for remote type displayitem and thus Repaint event is not + // triggered. So, always invalidate in this case. + DisplayItemType displayItemKey = aDisplayItemKey; + if (aDisplayItemKey == DisplayItemType::TYPE_REMOTE) { + displayItemKey = DisplayItemType::TYPE_ZERO; + } + + if (aFrameDamageRect) { + InvalidateFrameWithRect(*aFrameDamageRect, + static_cast<uint32_t>(displayItemKey)); + } else { + InvalidateFrame(static_cast<uint32_t>(displayItemKey)); + } +} + +static nsRect ComputeEffectsRect(nsIFrame* aFrame, const nsRect& aOverflowRect, + const nsSize& aNewSize) { + nsRect r = aOverflowRect; + + if (aFrame->HasAnyStateBits(NS_FRAME_SVG_LAYOUT)) { + // For SVG frames, we only need to account for filters. + // TODO: We could also take account of clipPath and mask to reduce the + // ink overflow, but that's not essential. + if (aFrame->StyleEffects()->HasFilters()) { + SetOrUpdateRectValuedProperty(aFrame, nsIFrame::PreEffectsBBoxProperty(), + r); + r = SVGUtils::GetPostFilterInkOverflowRect(aFrame, aOverflowRect); + } + return r; + } + + // box-shadow + r.UnionRect(r, nsLayoutUtils::GetBoxShadowRectForFrame(aFrame, aNewSize)); + + // border-image-outset. + // We need to include border-image-outset because it can cause the + // border image to be drawn beyond the border box. + + // (1) It's important we not check whether there's a border-image + // since the style hint for a change in border image doesn't cause + // reflow, and that's probably more important than optimizing the + // overflow areas for the silly case of border-image-outset without + // border-image + // (2) It's important that we not check whether the border-image + // is actually loaded, since that would require us to reflow when + // the image loads. + const nsStyleBorder* styleBorder = aFrame->StyleBorder(); + nsMargin outsetMargin = styleBorder->GetImageOutset(); + + if (outsetMargin != nsMargin(0, 0, 0, 0)) { + nsRect outsetRect(nsPoint(0, 0), aNewSize); + outsetRect.Inflate(outsetMargin); + r.UnionRect(r, outsetRect); + } + + // Note that we don't remove the outlineInnerRect if a frame loses outline + // style. That would require an extra property lookup for every frame, + // or a new frame state bit to track whether a property had been stored, + // or something like that. It's not worth doing that here. At most it's + // only one heap-allocated rect per frame and it will be cleaned up when + // the frame dies. + + if (SVGIntegrationUtils::UsingOverflowAffectingEffects(aFrame)) { + SetOrUpdateRectValuedProperty(aFrame, nsIFrame::PreEffectsBBoxProperty(), + r); + r = SVGIntegrationUtils::ComputePostEffectsInkOverflowRect(aFrame, r); + } + + return r; +} + +void nsIFrame::SetPosition(const nsPoint& aPt) { + if (mRect.TopLeft() == aPt) { + return; + } + mRect.MoveTo(aPt); + MarkNeedsDisplayItemRebuild(); +#ifdef ACCESSIBILITY + if (nsAccessibilityService* accService = GetAccService()) { + accService->NotifyOfPossibleBoundsChange(PresShell(), mContent); + } +#endif +} + +void nsIFrame::MovePositionBy(const nsPoint& aTranslation) { + nsPoint position = GetNormalPosition() + aTranslation; + + const nsMargin* computedOffsets = nullptr; + if (IsRelativelyOrStickyPositioned()) { + computedOffsets = GetProperty(nsIFrame::ComputedOffsetProperty()); + } + ReflowInput::ApplyRelativePositioning( + this, computedOffsets ? *computedOffsets : nsMargin(), &position); + SetPosition(position); +} + +nsRect nsIFrame::GetNormalRect() const { + // It might be faster to first check + // StyleDisplay()->IsRelativelyPositionedStyle(). + bool hasProperty; + nsPoint normalPosition = GetProperty(NormalPositionProperty(), &hasProperty); + if (hasProperty) { + return nsRect(normalPosition, GetSize()); + } + return GetRect(); +} + +nsRect nsIFrame::GetBoundingClientRect() { + return nsLayoutUtils::GetAllInFlowRectsUnion( + this, nsLayoutUtils::GetContainingBlockForClientRect(this), + nsLayoutUtils::RECTS_ACCOUNT_FOR_TRANSFORMS); +} + +nsPoint nsIFrame::GetPositionIgnoringScrolling() const { + return GetParent() ? GetParent()->GetPositionOfChildIgnoringScrolling(this) + : GetPosition(); +} + +nsRect nsIFrame::GetOverflowRect(OverflowType aType) const { + // Note that in some cases the overflow area might not have been + // updated (yet) to reflect any outline set on the frame or the area + // of child frames. That's OK because any reflow that updates these + // areas will invalidate the appropriate area, so any (mis)uses of + // this method will be fixed up. + + if (mOverflow.mType == OverflowStorageType::Large) { + // there is an overflow rect, and it's not stored as deltas but as + // a separately-allocated rect + return GetOverflowAreasProperty()->Overflow(aType); + } + + if (aType == OverflowType::Ink && + mOverflow.mType != OverflowStorageType::None) { + return InkOverflowFromDeltas(); + } + + return GetRectRelativeToSelf(); +} + +OverflowAreas nsIFrame::GetOverflowAreas() const { + if (mOverflow.mType == OverflowStorageType::Large) { + // there is an overflow rect, and it's not stored as deltas but as + // a separately-allocated rect + return *GetOverflowAreasProperty(); + } + + return OverflowAreas(InkOverflowFromDeltas(), + nsRect(nsPoint(0, 0), GetSize())); +} + +OverflowAreas nsIFrame::GetOverflowAreasRelativeToSelf() const { + if (IsTransformed()) { + if (OverflowAreas* preTransformOverflows = + GetProperty(PreTransformOverflowAreasProperty())) { + return *preTransformOverflows; + } + } + return GetOverflowAreas(); +} + +OverflowAreas nsIFrame::GetOverflowAreasRelativeToParent() const { + return GetOverflowAreas() + GetPosition(); +} + +OverflowAreas nsIFrame::GetActualAndNormalOverflowAreasRelativeToParent() + const { + if (MOZ_LIKELY(!IsRelativelyOrStickyPositioned())) { + return GetOverflowAreasRelativeToParent(); + } + + const OverflowAreas overflows = GetOverflowAreas(); + OverflowAreas actualAndNormalOverflows = overflows + GetPosition(); + actualAndNormalOverflows.UnionWith(overflows + GetNormalPosition()); + return actualAndNormalOverflows; +} + +nsRect nsIFrame::ScrollableOverflowRectRelativeToParent() const { + return ScrollableOverflowRect() + GetPosition(); +} + +nsRect nsIFrame::InkOverflowRectRelativeToParent() const { + return InkOverflowRect() + GetPosition(); +} + +nsRect nsIFrame::ScrollableOverflowRectRelativeToSelf() const { + if (IsTransformed()) { + if (OverflowAreas* preTransformOverflows = + GetProperty(PreTransformOverflowAreasProperty())) { + return preTransformOverflows->ScrollableOverflow(); + } + } + return ScrollableOverflowRect(); +} + +nsRect nsIFrame::InkOverflowRectRelativeToSelf() const { + if (IsTransformed()) { + if (OverflowAreas* preTransformOverflows = + GetProperty(PreTransformOverflowAreasProperty())) { + return preTransformOverflows->InkOverflow(); + } + } + return InkOverflowRect(); +} + +nsRect nsIFrame::PreEffectsInkOverflowRect() const { + nsRect* r = GetProperty(nsIFrame::PreEffectsBBoxProperty()); + return r ? *r : InkOverflowRectRelativeToSelf(); +} + +bool nsIFrame::UpdateOverflow() { + MOZ_ASSERT(FrameMaintainsOverflow(), + "Non-display SVG do not maintain ink overflow rects"); + + nsRect rect(nsPoint(0, 0), GetSize()); + OverflowAreas overflowAreas(rect, rect); + + if (!ComputeCustomOverflow(overflowAreas)) { + // If updating overflow wasn't supported by this frame, then it should + // have scheduled any necessary reflows. We can return false to say nothing + // changed, and wait for reflow to correct it. + return false; + } + + UnionChildOverflow(overflowAreas); + + if (FinishAndStoreOverflow(overflowAreas, GetSize())) { + if (nsView* view = GetView()) { + // Make sure the frame's view is properly sized. + nsViewManager* vm = view->GetViewManager(); + vm->ResizeView(view, overflowAreas.InkOverflow(), true); + } + + return true; + } + + // Frames that combine their 3d transform with their ancestors + // only compute a pre-transform overflow rect, and then contribute + // to the normal overflow rect of the preserve-3d root. Always return + // true here so that we propagate changes up to the root for final + // calculation. + return Combines3DTransformWithAncestors(); +} + +/* virtual */ +bool nsIFrame::ComputeCustomOverflow(OverflowAreas& aOverflowAreas) { + return true; +} + +bool nsIFrame::DoesClipChildrenInBothAxes() const { + nsIScrollableFrame* sf = do_QueryFrame(this); + const nsStyleDisplay* display = StyleDisplay(); + return sf || (display->mOverflowX == StyleOverflow::Clip && + display->mOverflowY == StyleOverflow::Clip); +} + +/* virtual */ +void nsIFrame::UnionChildOverflow(OverflowAreas& aOverflowAreas) { + if (!DoesClipChildrenInBothAxes()) { + nsLayoutUtils::UnionChildOverflow(this, aOverflowAreas); + } +} + +// Return true if this form control element's preferred size property (but not +// percentage max size property) contains a percentage value that should be +// resolved against zero when calculating its min-content contribution in the +// corresponding axis. +// +// For proper replaced elements, the percentage value in both their max size +// property or preferred size property should be resolved against zero. This is +// handled in IsPercentageResolvedAgainstZero(). +inline static bool FormControlShrinksForPercentSize(const nsIFrame* aFrame) { + if (!aFrame->IsFrameOfType(nsIFrame::eReplaced)) { + // Quick test to reject most frames. + return false; + } + + LayoutFrameType fType = aFrame->Type(); + if (fType == LayoutFrameType::Meter || fType == LayoutFrameType::Progress || + fType == LayoutFrameType::Range) { + // progress, meter and range do have this shrinking behavior + // FIXME: Maybe these should be nsIFormControlFrame? + return true; + } + + if (!static_cast<nsIFormControlFrame*>(do_QueryFrame(aFrame))) { + // Not a form control. This includes fieldsets, which do not + // shrink. + return false; + } + + if (fType == LayoutFrameType::GfxButtonControl || + fType == LayoutFrameType::HTMLButtonControl) { + // Buttons don't have this shrinking behavior. (Note that color + // inputs do, even though they inherit from button, so we can't use + // do_QueryFrame here.) + return false; + } + + return true; +} + +bool nsIFrame::IsPercentageResolvedAgainstZero( + const StyleSize& aStyleSize, const StyleMaxSize& aStyleMaxSize) const { + const bool sizeHasPercent = aStyleSize.HasPercent(); + return ((sizeHasPercent || aStyleMaxSize.HasPercent()) && + IsFrameOfType(nsIFrame::eReplacedSizing)) || + (sizeHasPercent && FormControlShrinksForPercentSize(this)); +} + +// Summary of the Cyclic-Percentage Intrinsic Size Contribution Rules: +// +// Element Type | Replaced | Non-replaced +// Contribution Type | min-content max-content | min-content max-content +// --------------------------------------------------------------------------- +// min size | zero zero | zero zero +// max & preferred size | zero initial | initial initial +// +// https://drafts.csswg.org/css-sizing-3/#cyclic-percentage-contribution +bool nsIFrame::IsPercentageResolvedAgainstZero(const LengthPercentage& aSize, + SizeProperty aProperty) const { + // Early return to avoid calling the virtual function, IsFrameOfType(). + if (aProperty == SizeProperty::MinSize) { + return true; + } + + const bool hasPercentOnReplaced = + aSize.HasPercent() && IsFrameOfType(nsIFrame::eReplacedSizing); + if (aProperty == SizeProperty::MaxSize) { + return hasPercentOnReplaced; + } + + MOZ_ASSERT(aProperty == SizeProperty::Size); + return hasPercentOnReplaced || + (aSize.HasPercent() && FormControlShrinksForPercentSize(this)); +} + +bool nsIFrame::IsBlockWrapper() const { + auto pseudoType = Style()->GetPseudoType(); + return pseudoType == PseudoStyleType::mozBlockInsideInlineWrapper || + pseudoType == PseudoStyleType::buttonContent || + pseudoType == PseudoStyleType::cellContent || + pseudoType == PseudoStyleType::columnSpanWrapper; +} + +bool nsIFrame::IsBlockFrameOrSubclass() const { + const nsBlockFrame* thisAsBlock = do_QueryFrame(this); + return !!thisAsBlock; +} + +bool nsIFrame::IsImageFrameOrSubclass() const { + const nsImageFrame* asImage = do_QueryFrame(this); + return !!asImage; +} + +bool nsIFrame::IsSubgrid() const { + return IsGridContainerFrame() && + static_cast<const nsGridContainerFrame*>(this)->IsSubgrid(); +} + +static nsIFrame* GetNearestBlockContainer(nsIFrame* frame) { + while (!frame->IsBlockContainer()) { + frame = frame->GetParent(); + NS_ASSERTION( + frame, + "How come we got to the root frame without seeing a containing block?"); + } + return frame; +} + +bool nsIFrame::IsBlockContainer() const { + // The block wrappers we use to wrap blocks inside inlines aren't + // described in the CSS spec. We need to make them not be containing + // blocks. + // Since the parent of such a block is either a normal block or + // another such pseudo, this shouldn't cause anything bad to happen. + // Also the anonymous blocks inside table cells are not containing blocks. + // + // If we ever start skipping table row groups from being containing blocks, + // you need to remove the StickyScrollContainer hack referencing bug 1421660. + return !IsFrameOfType(nsIFrame::eLineParticipant) && !IsBlockWrapper() && + !IsSubgrid() && + // Table rows are not containing blocks either + !IsTableRowFrame(); +} + +nsIFrame* nsIFrame::GetContainingBlock( + uint32_t aFlags, const nsStyleDisplay* aStyleDisplay) const { + MOZ_ASSERT(aStyleDisplay == StyleDisplay()); + + // Keep this in sync with MightBeContainingBlockFor in ReflowInput.cpp. + + if (!GetParent()) { + return nullptr; + } + // MathML frames might have absolute positioning style, but they would + // still be in-flow. So we have to check to make sure that the frame + // is really out-of-flow too. + nsIFrame* f; + if (IsAbsolutelyPositioned(aStyleDisplay)) { + f = GetParent(); // the parent is always the containing block + } else { + f = GetNearestBlockContainer(GetParent()); + } + + if (aFlags & SKIP_SCROLLED_FRAME && f && + f->Style()->GetPseudoType() == PseudoStyleType::scrolledContent) { + f = f->GetParent(); + } + return f; +} + +#ifdef DEBUG_FRAME_DUMP + +Maybe<uint32_t> nsIFrame::ContentIndexInContainer(const nsIFrame* aFrame) { + if (nsIContent* content = aFrame->GetContent()) { + return content->ComputeIndexInParentContent(); + } + return Nothing(); +} + +nsAutoCString nsIFrame::ListTag() const { + nsAutoString tmp; + GetFrameName(tmp); + + nsAutoCString tag; + tag += NS_ConvertUTF16toUTF8(tmp); + tag += nsPrintfCString("@%p", static_cast<const void*>(this)); + return tag; +} + +std::string nsIFrame::ConvertToString(const LogicalRect& aRect, + const WritingMode aWM, ListFlags aFlags) { + if (aFlags.contains(ListFlag::DisplayInCSSPixels)) { + // Abuse CSSRect to store all LogicalRect's dimensions in CSS pixels. + return ToString(mozilla::CSSRect(CSSPixel::FromAppUnits(aRect.IStart(aWM)), + CSSPixel::FromAppUnits(aRect.BStart(aWM)), + CSSPixel::FromAppUnits(aRect.ISize(aWM)), + CSSPixel::FromAppUnits(aRect.BSize(aWM)))); + } + return ToString(aRect); +} + +std::string nsIFrame::ConvertToString(const LogicalSize& aSize, + const WritingMode aWM, ListFlags aFlags) { + if (aFlags.contains(ListFlag::DisplayInCSSPixels)) { + // Abuse CSSSize to store all LogicalSize's dimensions in CSS pixels. + return ToString(CSSSize(CSSPixel::FromAppUnits(aSize.ISize(aWM)), + CSSPixel::FromAppUnits(aSize.BSize(aWM)))); + } + return ToString(aSize); +} + +// Debugging +void nsIFrame::ListGeneric(nsACString& aTo, const char* aPrefix, + ListFlags aFlags) const { + aTo += aPrefix; + aTo += ListTag(); + if (HasView()) { + aTo += nsPrintfCString(" [view=%p]", static_cast<void*>(GetView())); + } + if (GetParent()) { + aTo += nsPrintfCString(" parent=%p", static_cast<void*>(GetParent())); + } + if (GetNextSibling()) { + aTo += nsPrintfCString(" next=%p", static_cast<void*>(GetNextSibling())); + } + if (GetPrevContinuation()) { + bool fluid = GetPrevInFlow() == GetPrevContinuation(); + aTo += nsPrintfCString(" prev-%s=%p", fluid ? "in-flow" : "continuation", + static_cast<void*>(GetPrevContinuation())); + } + if (GetNextContinuation()) { + bool fluid = GetNextInFlow() == GetNextContinuation(); + aTo += nsPrintfCString(" next-%s=%p", fluid ? "in-flow" : "continuation", + static_cast<void*>(GetNextContinuation())); + } + if (const nsAtom* const autoPageValue = + GetProperty(AutoPageValueProperty())) { + aTo += " AutoPage="; + aTo += nsAtomCString(autoPageValue); + } + if (const nsIFrame::PageValues* const pageValues = + GetProperty(PageValuesProperty())) { + aTo += " PageValues={"; + if (pageValues->mStartPageValue) { + aTo += nsAtomCString(pageValues->mStartPageValue); + } else { + aTo += "<null>"; + } + aTo += ", "; + if (pageValues->mEndPageValue) { + aTo += nsAtomCString(pageValues->mEndPageValue); + } else { + aTo += "<null>"; + } + aTo += "}"; + } + void* IBsibling = GetProperty(IBSplitSibling()); + if (IBsibling) { + aTo += nsPrintfCString(" IBSplitSibling=%p", IBsibling); + } + void* IBprevsibling = GetProperty(IBSplitPrevSibling()); + if (IBprevsibling) { + aTo += nsPrintfCString(" IBSplitPrevSibling=%p", IBprevsibling); + } + if (nsLayoutUtils::FontSizeInflationEnabled(PresContext())) { + if (HasAnyStateBits(NS_FRAME_FONT_INFLATION_FLOW_ROOT)) { + aTo += nsPrintfCString(" FFR"); + if (nsFontInflationData* data = + nsFontInflationData::FindFontInflationDataFor(this)) { + aTo += nsPrintfCString( + ",enabled=%s,UIS=%s", data->InflationEnabled() ? "yes" : "no", + ConvertToString(data->UsableISize(), aFlags).c_str()); + } + } + if (HasAnyStateBits(NS_FRAME_FONT_INFLATION_CONTAINER)) { + aTo += nsPrintfCString(" FIC"); + } + aTo += nsPrintfCString(" FI=%f", nsLayoutUtils::FontSizeInflationFor(this)); + } + aTo += nsPrintfCString(" %s", ConvertToString(mRect, aFlags).c_str()); + + mozilla::WritingMode wm = GetWritingMode(); + if (wm.IsVertical() || wm.IsBidiRTL()) { + aTo += + nsPrintfCString(" wm=%s logical-size=(%s)", ToString(wm).c_str(), + ConvertToString(GetLogicalSize(), wm, aFlags).c_str()); + } + + nsIFrame* parent = GetParent(); + if (parent) { + WritingMode pWM = parent->GetWritingMode(); + if (pWM.IsVertical() || pWM.IsBidiRTL()) { + nsSize containerSize = parent->mRect.Size(); + LogicalRect lr(pWM, mRect, containerSize); + aTo += nsPrintfCString(" parent-wm=%s cs=(%s) logical-rect=%s", + ToString(pWM).c_str(), + ConvertToString(containerSize, aFlags).c_str(), + ConvertToString(lr, pWM, aFlags).c_str()); + } + } + nsIFrame* f = const_cast<nsIFrame*>(this); + if (f->HasOverflowAreas()) { + nsRect io = f->InkOverflowRect(); + if (!io.IsEqualEdges(mRect)) { + aTo += nsPrintfCString(" ink-overflow=%s", + ConvertToString(io, aFlags).c_str()); + } + nsRect so = f->ScrollableOverflowRect(); + if (!so.IsEqualEdges(mRect)) { + aTo += nsPrintfCString(" scr-overflow=%s", + ConvertToString(so, aFlags).c_str()); + } + } + if (OverflowAreas* preTransformOverflows = + f->GetProperty(PreTransformOverflowAreasProperty())) { + nsRect io = preTransformOverflows->InkOverflow(); + if (!io.IsEqualEdges(mRect) && + (!f->HasOverflowAreas() || !io.IsEqualEdges(f->InkOverflowRect()))) { + aTo += nsPrintfCString(" pre-transform-ink-overflow=%s", + ConvertToString(io, aFlags).c_str()); + } + nsRect so = preTransformOverflows->ScrollableOverflow(); + if (!so.IsEqualEdges(mRect) && + (!f->HasOverflowAreas() || + !so.IsEqualEdges(f->ScrollableOverflowRect()))) { + aTo += nsPrintfCString(" pre-transform-scr-overflow=%s", + ConvertToString(so, aFlags).c_str()); + } + } + bool hasNormalPosition; + nsPoint normalPosition = GetNormalPosition(&hasNormalPosition); + if (hasNormalPosition) { + aTo += nsPrintfCString(" normal-position=%s", + ConvertToString(normalPosition, aFlags).c_str()); + } + if (HasProperty(BidiDataProperty())) { + FrameBidiData bidi = GetBidiData(); + aTo += nsPrintfCString(" bidi(%d,%d,%d)", bidi.baseLevel.Value(), + bidi.embeddingLevel.Value(), + bidi.precedingControl.Value()); + } + if (IsTransformed()) { + aTo += nsPrintfCString(" transformed"); + } + if (ChildrenHavePerspective()) { + aTo += nsPrintfCString(" perspective"); + } + if (Extend3DContext()) { + aTo += nsPrintfCString(" extend-3d"); + } + if (Combines3DTransformWithAncestors()) { + aTo += nsPrintfCString(" combines-3d-transform-with-ancestors"); + } + if (mContent) { + aTo += nsPrintfCString(" [content=%p]", static_cast<void*>(mContent)); + } + aTo += nsPrintfCString(" [cs=%p", static_cast<void*>(mComputedStyle)); + if (mComputedStyle) { + auto pseudoType = mComputedStyle->GetPseudoType(); + aTo += ToString(pseudoType).c_str(); + } + aTo += "]"; + + if (IsFrameModified()) { + aTo += nsPrintfCString(" modified"); + } + + if (HasModifiedDescendants()) { + aTo += nsPrintfCString(" has-modified-descendants"); + } +} + +void nsIFrame::List(FILE* out, const char* aPrefix, ListFlags aFlags) const { + nsCString str; + ListGeneric(str, aPrefix, aFlags); + fprintf_stderr(out, "%s\n", str.get()); +} + +void nsIFrame::ListTextRuns(FILE* out) const { + nsTHashSet<const void*> seen; + ListTextRuns(out, seen); +} + +void nsIFrame::ListTextRuns(FILE* out, nsTHashSet<const void*>& aSeen) const { + for (const auto& childList : ChildLists()) { + for (const nsIFrame* kid : childList.mList) { + kid->ListTextRuns(out, aSeen); + } + } +} + +void nsIFrame::ListMatchedRules(FILE* out, const char* aPrefix) const { + nsTArray<const StyleLockedStyleRule*> rawRuleList; + Servo_ComputedValues_GetStyleRuleList(mComputedStyle, &rawRuleList); + for (const StyleLockedStyleRule* rawRule : rawRuleList) { + nsAutoCString ruleText; + Servo_StyleRule_GetCssText(rawRule, &ruleText); + fprintf_stderr(out, "%s%s\n", aPrefix, ruleText.get()); + } +} + +void nsIFrame::ListWithMatchedRules(FILE* out, const char* aPrefix) const { + fprintf_stderr(out, "%s%s\n", aPrefix, ListTag().get()); + + nsCString rulePrefix; + rulePrefix += aPrefix; + rulePrefix += " "; + ListMatchedRules(out, rulePrefix.get()); +} + +nsresult nsIFrame::GetFrameName(nsAString& aResult) const { + return MakeFrameName(u"Frame"_ns, aResult); +} + +nsresult nsIFrame::MakeFrameName(const nsAString& aType, + nsAString& aResult) const { + aResult = aType; + if (mContent && !mContent->IsText()) { + nsAutoString buf; + mContent->NodeInfo()->NameAtom()->ToString(buf); + if (nsAtom* id = mContent->GetID()) { + buf.AppendLiteral(" id="); + buf.Append(nsDependentAtomString(id)); + } + if (IsSubDocumentFrame()) { + nsAutoString src; + mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::src, src); + buf.AppendLiteral(" src="); + buf.Append(src); + } + aResult.Append('('); + aResult.Append(buf); + aResult.Append(')'); + } + aResult.Append('('); + Maybe<uint32_t> index = ContentIndexInContainer(this); + if (index.isSome()) { + aResult.AppendInt(*index); + } else { + aResult.AppendInt(-1); + } + aResult.Append(')'); + return NS_OK; +} + +void nsIFrame::DumpFrameTree() const { + PresShell()->GetRootFrame()->List(stderr); +} + +void nsIFrame::DumpFrameTreeInCSSPixels() const { + PresShell()->GetRootFrame()->List(stderr, "", ListFlag::DisplayInCSSPixels); +} + +void nsIFrame::DumpFrameTreeLimited() const { List(stderr); } +void nsIFrame::DumpFrameTreeLimitedInCSSPixels() const { + List(stderr, "", ListFlag::DisplayInCSSPixels); +} + +#endif + +bool nsIFrame::IsVisibleForPainting() const { + return StyleVisibility()->IsVisible(); +} + +bool nsIFrame::IsVisibleOrCollapsedForPainting() const { + return StyleVisibility()->IsVisibleOrCollapsed(); +} + +/* virtual */ +bool nsIFrame::IsEmpty() { + return IsHiddenByContentVisibilityOfInFlowParentForLayout(); +} + +bool nsIFrame::CachedIsEmpty() { + MOZ_ASSERT(!HasAnyStateBits(NS_FRAME_IS_DIRTY) || + IsHiddenByContentVisibilityOfInFlowParentForLayout(), + "Must only be called on reflowed lines or those hidden by " + "content-visibility."); + return IsEmpty(); +} + +/* virtual */ +bool nsIFrame::IsSelfEmpty() { + return IsHiddenByContentVisibilityOfInFlowParentForLayout(); +} + +nsresult nsIFrame::GetSelectionController(nsPresContext* aPresContext, + nsISelectionController** aSelCon) { + if (!aPresContext || !aSelCon) return NS_ERROR_INVALID_ARG; + + nsIFrame* frame = this; + while (frame && frame->HasAnyStateBits(NS_FRAME_INDEPENDENT_SELECTION)) { + nsITextControlFrame* tcf = do_QueryFrame(frame); + if (tcf) { + return tcf->GetOwnedSelectionController(aSelCon); + } + frame = frame->GetParent(); + } + + *aSelCon = do_AddRef(aPresContext->PresShell()).take(); + return NS_OK; +} + +already_AddRefed<nsFrameSelection> nsIFrame::GetFrameSelection() { + RefPtr<nsFrameSelection> fs = + const_cast<nsFrameSelection*>(GetConstFrameSelection()); + return fs.forget(); +} + +const nsFrameSelection* nsIFrame::GetConstFrameSelection() const { + nsIFrame* frame = const_cast<nsIFrame*>(this); + while (frame && frame->HasAnyStateBits(NS_FRAME_INDEPENDENT_SELECTION)) { + nsITextControlFrame* tcf = do_QueryFrame(frame); + if (tcf) { + return tcf->GetOwnedFrameSelection(); + } + frame = frame->GetParent(); + } + + return PresShell()->ConstFrameSelection(); +} + +bool nsIFrame::IsFrameSelected() const { + NS_ASSERTION(!GetContent() || GetContent()->IsMaybeSelected(), + "use the public IsSelected() instead"); + return GetContent()->IsSelected(0, GetContent()->GetChildCount()); +} + +nsresult nsIFrame::GetPointFromOffset(int32_t inOffset, nsPoint* outPoint) { + MOZ_ASSERT(outPoint != nullptr, "Null parameter"); + nsRect contentRect = GetContentRectRelativeToSelf(); + nsPoint pt = contentRect.TopLeft(); + if (mContent) { + nsIContent* newContent = mContent->GetParent(); + if (newContent) { + const int32_t newOffset = newContent->ComputeIndexOf_Deprecated(mContent); + + // Find the direction of the frame from the EmbeddingLevelProperty, + // which is the resolved bidi level set in + // nsBidiPresUtils::ResolveParagraph (odd levels = right-to-left). + // If the embedding level isn't set, just use the CSS direction + // property. + bool hasBidiData; + FrameBidiData bidiData = GetProperty(BidiDataProperty(), &hasBidiData); + bool isRTL = hasBidiData + ? bidiData.embeddingLevel.IsRTL() + : StyleVisibility()->mDirection == StyleDirection::Rtl; + if ((!isRTL && inOffset > newOffset) || + (isRTL && inOffset <= newOffset)) { + pt = contentRect.TopRight(); + } + } + } + *outPoint = pt; + return NS_OK; +} + +nsresult nsIFrame::GetCharacterRectsInRange(int32_t aInOffset, int32_t aLength, + nsTArray<nsRect>& aOutRect) { + /* no text */ + return NS_ERROR_FAILURE; +} + +nsresult nsIFrame::GetChildFrameContainingOffset(int32_t inContentOffset, + bool inHint, + int32_t* outFrameContentOffset, + nsIFrame** outChildFrame) { + MOZ_ASSERT(outChildFrame && outFrameContentOffset, "Null parameter"); + *outFrameContentOffset = (int32_t)inHint; + // the best frame to reflect any given offset would be a visible frame if + // possible i.e. we are looking for a valid frame to place the blinking caret + nsRect rect = GetRect(); + if (!rect.width || !rect.height) { + // if we have a 0 width or height then lets look for another frame that + // possibly has the same content. If we have no frames in flow then just + // let us return 'this' frame + nsIFrame* nextFlow = GetNextInFlow(); + if (nextFlow) + return nextFlow->GetChildFrameContainingOffset( + inContentOffset, inHint, outFrameContentOffset, outChildFrame); + } + *outChildFrame = this; + return NS_OK; +} + +// +// What I've pieced together about this routine: +// Starting with a block frame (from which a line frame can be gotten) +// and a line number, drill down and get the first/last selectable +// frame on that line, depending on aPos->mDirection. +// aOutSideLimit != 0 means ignore aLineStart, instead work from +// the end (if > 0) or beginning (if < 0). +// +static nsresult GetNextPrevLineFromBlockFrame(PeekOffsetStruct* aPos, + nsIFrame* aBlockFrame, + int32_t aLineStart, + int8_t aOutSideLimit) { + MOZ_ASSERT(aPos); + MOZ_ASSERT(aBlockFrame); + + nsPresContext* pc = aBlockFrame->PresContext(); + + // magic numbers: aLineStart will be -1 for end of block, 0 will be start of + // block. + + aPos->mResultFrame = nullptr; + aPos->mResultContent = nullptr; + aPos->mAttach = aPos->mDirection == eDirNext ? CARET_ASSOCIATE_AFTER + : CARET_ASSOCIATE_BEFORE; + + AutoAssertNoDomMutations guard; + nsILineIterator* it = aBlockFrame->GetLineIterator(); + if (!it) { + return NS_ERROR_FAILURE; + } + int32_t searchingLine = aLineStart; + int32_t countLines = it->GetNumLines(); + if (aOutSideLimit > 0) { // start at end + searchingLine = countLines; + } else if (aOutSideLimit < 0) { // start at beginning + searchingLine = -1; //"next" will be 0 + } else if ((aPos->mDirection == eDirPrevious && searchingLine == 0) || + (aPos->mDirection == eDirNext && + searchingLine >= (countLines - 1))) { + // Not found. + return NS_ERROR_FAILURE; + } + nsIFrame* resultFrame = nullptr; + nsIFrame* farStoppingFrame = nullptr; // we keep searching until we find a + // "this" frame then we go to next line + nsIFrame* nearStoppingFrame = nullptr; // if we are backing up from edge, + // stop here + nsIFrame* firstFrame; + nsIFrame* lastFrame; + bool isBeforeFirstFrame, isAfterLastFrame; + bool found = false; + + nsresult result = NS_OK; + while (!found) { + if (aPos->mDirection == eDirPrevious) + searchingLine--; + else + searchingLine++; + if ((aPos->mDirection == eDirPrevious && searchingLine < 0) || + (aPos->mDirection == eDirNext && searchingLine >= countLines)) { + // we need to jump to new block frame. + return NS_ERROR_FAILURE; + } + auto line = it->GetLine(searchingLine).unwrap(); + if (!line.mNumFramesOnLine) { + continue; + } + lastFrame = firstFrame = line.mFirstFrameOnLine; + for (int32_t lineFrameCount = line.mNumFramesOnLine; lineFrameCount > 1; + lineFrameCount--) { + lastFrame = lastFrame->GetNextSibling(); + if (!lastFrame) { + NS_ERROR("GetLine promised more frames than could be found"); + return NS_ERROR_FAILURE; + } + } + nsIFrame::GetLastLeaf(&lastFrame); + + if (aPos->mDirection == eDirNext) { + nearStoppingFrame = firstFrame; + farStoppingFrame = lastFrame; + } else { + nearStoppingFrame = lastFrame; + farStoppingFrame = firstFrame; + } + nsPoint offset; + nsView* view; // used for call of get offset from view + aBlockFrame->GetOffsetFromView(offset, &view); + nsPoint newDesiredPos = + aPos->mDesiredCaretPos - + offset; // get desired position into blockframe coords + result = it->FindFrameAt(searchingLine, newDesiredPos, &resultFrame, + &isBeforeFirstFrame, &isAfterLastFrame); + if (NS_FAILED(result)) { + continue; + } + + if (resultFrame) { + // check to see if this is ANOTHER blockframe inside the other one if so + // then call into its lines + if (resultFrame->CanProvideLineIterator()) { + aPos->mResultFrame = resultFrame; + return NS_OK; + } + // resultFrame is not a block frame + result = NS_ERROR_FAILURE; + + nsCOMPtr<nsIFrameEnumerator> frameTraversal; + result = NS_NewFrameTraversal( + getter_AddRefs(frameTraversal), pc, resultFrame, ePostOrder, + false, // aVisual + aPos->mOptions.contains(PeekOffsetOption::ScrollViewStop), + false, // aFollowOOFs + false // aSkipPopupChecks + ); + if (NS_FAILED(result)) { + return result; + } + + auto FoundValidFrame = [aPos](const nsIFrame::ContentOffsets& aOffsets, + const nsIFrame* aFrame) { + if (!aOffsets.content) { + return false; + } + if (!aFrame->IsSelectable(nullptr)) { + return false; + } + if (aPos->mOptions.contains(PeekOffsetOption::ForceEditableRegion) && + !aOffsets.content->IsEditable()) { + return false; + } + return true; + }; + + nsIFrame* storeOldResultFrame = resultFrame; + while (!found) { + nsPoint point; + nsRect tempRect = resultFrame->GetRect(); + nsPoint offset; + nsView* view; // used for call of get offset from view + resultFrame->GetOffsetFromView(offset, &view); + if (!view) { + return NS_ERROR_FAILURE; + } + if (resultFrame->GetWritingMode().IsVertical()) { + point.y = aPos->mDesiredCaretPos.y; + point.x = tempRect.width + offset.x; + } else { + point.y = tempRect.height + offset.y; + point.x = aPos->mDesiredCaretPos.x; + } + + if (!resultFrame->HasView()) { + nsView* view; + nsPoint offset; + resultFrame->GetOffsetFromView(offset, &view); + nsIFrame::ContentOffsets offsets = + resultFrame->GetContentOffsetsFromPoint(point - offset); + aPos->mResultContent = offsets.content; + aPos->mContentOffset = offsets.offset; + aPos->mAttach = offsets.associate; + if (FoundValidFrame(offsets, resultFrame)) { + found = true; + break; + } + } + + if (aPos->mDirection == eDirPrevious && + resultFrame == farStoppingFrame) { + break; + } + if (aPos->mDirection == eDirNext && resultFrame == nearStoppingFrame) { + break; + } + // always try previous on THAT line if that fails go the other way + resultFrame = frameTraversal->Traverse(/* aForward = */ false); + if (!resultFrame) { + return NS_ERROR_FAILURE; + } + } + + if (!found) { + resultFrame = storeOldResultFrame; + + result = NS_NewFrameTraversal( + getter_AddRefs(frameTraversal), pc, resultFrame, eLeaf, + false, // aVisual + aPos->mOptions.contains(PeekOffsetOption::ScrollViewStop), + false, // aFollowOOFs + false // aSkipPopupChecks + ); + } + while (!found) { + nsPoint point = aPos->mDesiredCaretPos; + nsView* view; + nsPoint offset; + resultFrame->GetOffsetFromView(offset, &view); + nsIFrame::ContentOffsets offsets = + resultFrame->GetContentOffsetsFromPoint(point - offset); + aPos->mResultContent = offsets.content; + aPos->mContentOffset = offsets.offset; + aPos->mAttach = offsets.associate; + if (FoundValidFrame(offsets, resultFrame)) { + found = true; + if (resultFrame == farStoppingFrame) + aPos->mAttach = CARET_ASSOCIATE_BEFORE; + else + aPos->mAttach = CARET_ASSOCIATE_AFTER; + break; + } + if (aPos->mDirection == eDirPrevious && + (resultFrame == nearStoppingFrame)) + break; + if (aPos->mDirection == eDirNext && (resultFrame == farStoppingFrame)) + break; + // previous didnt work now we try "next" + nsIFrame* tempFrame = frameTraversal->Traverse(/* aForward = */ true); + if (!tempFrame) break; + resultFrame = tempFrame; + } + aPos->mResultFrame = resultFrame; + } else { + // we need to jump to new block frame. + aPos->mAmount = eSelectLine; + aPos->mStartOffset = 0; + aPos->mAttach = aPos->mDirection == eDirNext ? CARET_ASSOCIATE_BEFORE + : CARET_ASSOCIATE_AFTER; + if (aPos->mDirection == eDirPrevious) + aPos->mStartOffset = -1; // start from end + return aBlockFrame->PeekOffset(aPos); + } + } + return NS_OK; +} + +nsIFrame::CaretPosition nsIFrame::GetExtremeCaretPosition(bool aStart) { + CaretPosition result; + + FrameTarget targetFrame = DrillDownToSelectionFrame(this, !aStart, 0); + FrameContentRange range = GetRangeForFrame(targetFrame.frame); + result.mResultContent = range.content; + result.mContentOffset = aStart ? range.start : range.end; + return result; +} + +// If this is a preformatted text frame, see if it ends with a newline +static nsContentAndOffset FindLineBreakInText(nsIFrame* aFrame, + nsDirection aDirection) { + nsContentAndOffset result; + + if (aFrame->IsGeneratedContentFrame() || + !aFrame->HasSignificantTerminalNewline()) { + return result; + } + + int32_t endOffset = aFrame->GetOffsets().second; + result.mContent = aFrame->GetContent(); + result.mOffset = endOffset - (aDirection == eDirPrevious ? 0 : 1); + return result; +} + +// Find the first (or last) descendant of the given frame +// which is either a block-level frame or a BRFrame, or some other kind of break +// which stops the line. +static nsContentAndOffset FindLineBreakingFrame(nsIFrame* aFrame, + nsDirection aDirection) { + nsContentAndOffset result; + + if (aFrame->IsGeneratedContentFrame()) { + return result; + } + + // Treat form controls as inline leaves + // XXX we really need a way to determine whether a frame is inline-level + if (static_cast<nsIFormControlFrame*>(do_QueryFrame(aFrame))) { + return result; + } + + // Check the frame itself + // Fall through block-in-inline split frames because their mContent is + // the content of the inline frames they were created from. The + // first/last child of such frames is the real block frame we're + // looking for. + if ((aFrame->IsBlockOutside() && + !aFrame->HasAnyStateBits(NS_FRAME_PART_OF_IBSPLIT)) || + aFrame->IsBrFrame()) { + nsIContent* content = aFrame->GetContent(); + result.mContent = content->GetParent(); + // In some cases (bug 310589, bug 370174) we end up here with a null + // content. This probably shouldn't ever happen, but since it sometimes + // does, we want to avoid crashing here. + NS_ASSERTION(result.mContent, "Unexpected orphan content"); + if (result.mContent) { + result.mOffset = result.mContent->ComputeIndexOf_Deprecated(content) + + (aDirection == eDirPrevious ? 1 : 0); + } + return result; + } + + result = FindLineBreakInText(aFrame, aDirection); + if (result.mContent) { + return result; + } + + // Iterate over children and call ourselves recursively + if (aDirection == eDirPrevious) { + nsIFrame* child = aFrame->PrincipalChildList().LastChild(); + while (child && !result.mContent) { + result = FindLineBreakingFrame(child, aDirection); + child = child->GetPrevSibling(); + } + } else { // eDirNext + nsIFrame* child = aFrame->PrincipalChildList().FirstChild(); + while (child && !result.mContent) { + result = FindLineBreakingFrame(child, aDirection); + child = child->GetNextSibling(); + } + } + return result; +} + +nsresult nsIFrame::PeekOffsetForParagraph(PeekOffsetStruct* aPos) { + nsIFrame* frame = this; + nsContentAndOffset blockFrameOrBR; + blockFrameOrBR.mContent = nullptr; + bool reachedLimit = frame->IsBlockOutside() || IsEditingHost(frame); + + auto traverse = [&aPos](nsIFrame* current) { + return aPos->mDirection == eDirPrevious ? current->GetPrevSibling() + : current->GetNextSibling(); + }; + + // Go through containing frames until reaching a block frame. + // In each step, search the previous (or next) siblings for the closest + // "stop frame" (a block frame or a BRFrame). + // If found, set it to be the selection boundary and abort. + while (!reachedLimit) { + nsIFrame* parent = frame->GetParent(); + // Treat a frame associated with the root content as if it were a block + // frame. + if (!frame->mContent || !frame->mContent->GetParent()) { + reachedLimit = true; + break; + } + + if (aPos->mDirection == eDirNext) { + // Try to find our own line-break before looking at our siblings. + blockFrameOrBR = FindLineBreakInText(frame, eDirNext); + } + + nsIFrame* sibling = traverse(frame); + while (sibling && !blockFrameOrBR.mContent) { + blockFrameOrBR = FindLineBreakingFrame(sibling, aPos->mDirection); + sibling = traverse(sibling); + } + if (blockFrameOrBR.mContent) { + aPos->mResultContent = blockFrameOrBR.mContent; + aPos->mContentOffset = blockFrameOrBR.mOffset; + break; + } + frame = parent; + reachedLimit = frame && (frame->IsBlockOutside() || IsEditingHost(frame)); + } + + if (reachedLimit) { // no "stop frame" found + aPos->mResultContent = frame->GetContent(); + if (aPos->mDirection == eDirPrevious) { + aPos->mContentOffset = 0; + } else if (aPos->mResultContent) { + aPos->mContentOffset = aPos->mResultContent->GetChildCount(); + } + } + return NS_OK; +} + +// Determine movement direction relative to frame +static bool IsMovingInFrameDirection(const nsIFrame* frame, + nsDirection aDirection, bool aVisual) { + bool isReverseDirection = + aVisual && nsBidiPresUtils::IsReversedDirectionFrame(frame); + return aDirection == (isReverseDirection ? eDirPrevious : eDirNext); +} + +// Determines "are we looking for a boundary between whitespace and +// non-whitespace (in the direction we're moving in)". It is true when moving +// forward and looking for a beginning of a word, or when moving backwards and +// looking for an end of a word. +static bool ShouldWordSelectionEatSpace(const PeekOffsetStruct& aPos) { + if (aPos.mWordMovementType != eDefaultBehavior) { + // aPos->mWordMovementType possible values: + // eEndWord: eat the space if we're moving backwards + // eStartWord: eat the space if we're moving forwards + return (aPos.mWordMovementType == eEndWord) == + (aPos.mDirection == eDirPrevious); + } + // Use the hidden preference which is based on operating system + // behavior. This pref only affects whether moving forward by word + // should go to the end of this word or start of the next word. When + // going backwards, the start of the word is always used, on every + // operating system. + return aPos.mDirection == eDirNext && + StaticPrefs::layout_word_select_eat_space_to_next_word(); +} + +enum class OffsetIsAtLineEdge : bool { No, Yes }; + +static void SetPeekResultFromFrame(PeekOffsetStruct& aPos, nsIFrame* aFrame, + int32_t aOffset, + OffsetIsAtLineEdge aAtLineEdge) { + FrameContentRange range = GetRangeForFrame(aFrame); + aPos.mResultFrame = aFrame; + aPos.mResultContent = range.content; + // Output offset is relative to content, not frame + aPos.mContentOffset = + aOffset < 0 ? range.end + aOffset + 1 : range.start + aOffset; + if (aAtLineEdge == OffsetIsAtLineEdge::Yes) { + aPos.mAttach = aPos.mContentOffset == range.start ? CARET_ASSOCIATE_AFTER + : CARET_ASSOCIATE_BEFORE; + } +} + +void nsIFrame::SelectablePeekReport::TransferTo(PeekOffsetStruct& aPos) const { + return SetPeekResultFromFrame(aPos, mFrame, mOffset, OffsetIsAtLineEdge::No); +} + +nsIFrame::SelectablePeekReport::SelectablePeekReport( + const mozilla::GenericErrorResult<nsresult>&& aErr) { + MOZ_ASSERT(NS_FAILED(aErr.operator nsresult())); + // Return an empty report +} + +nsresult nsIFrame::PeekOffsetForCharacter(PeekOffsetStruct* aPos, + int32_t aOffset) { + SelectablePeekReport current{this, aOffset}; + + nsIFrame::FrameSearchResult peekSearchState = CONTINUE; + + while (peekSearchState != FOUND) { + const bool movingInFrameDirection = IsMovingInFrameDirection( + current.mFrame, aPos->mDirection, + aPos->mOptions.contains(PeekOffsetOption::Visual)); + + if (current.mJumpedLine) { + // If we jumped lines, it's as if we found a character, but we still need + // to eat non-renderable content on the new line. + peekSearchState = current.PeekOffsetNoAmount(movingInFrameDirection); + } else { + PeekOffsetCharacterOptions options; + options.mRespectClusters = aPos->mAmount == eSelectCluster; + peekSearchState = + current.PeekOffsetCharacter(movingInFrameDirection, options); + } + + current.mMovedOverNonSelectableText |= + peekSearchState == CONTINUE_UNSELECTABLE; + + if (peekSearchState != FOUND) { + SelectablePeekReport next = current.mFrame->GetFrameFromDirection(*aPos); + if (next.Failed()) { + return NS_ERROR_FAILURE; + } + next.mJumpedLine |= current.mJumpedLine; + next.mMovedOverNonSelectableText |= current.mMovedOverNonSelectableText; + next.mHasSelectableFrame |= current.mHasSelectableFrame; + current = next; + } + + // Found frame, but because we moved over non selectable text we want + // the offset to be at the frame edge. Note that if we are extending the + // selection, this doesn't matter. + if (peekSearchState == FOUND && current.mMovedOverNonSelectableText && + (!aPos->mOptions.contains(PeekOffsetOption::Extend) || + current.mHasSelectableFrame)) { + auto [start, end] = current.mFrame->GetOffsets(); + current.mOffset = aPos->mDirection == eDirNext ? 0 : end - start; + } + } + + // Set outputs + current.TransferTo(*aPos); + // If we're dealing with a text frame and moving backward positions us at + // the end of that line, decrease the offset by one to make sure that + // we're placed before the linefeed character on the previous line. + if (current.mOffset < 0 && current.mJumpedLine && + aPos->mDirection == eDirPrevious && + current.mFrame->HasSignificantTerminalNewline() && + !current.mIgnoredBrFrame) { + --aPos->mContentOffset; + } + return NS_OK; +} + +nsresult nsIFrame::PeekOffsetForWord(PeekOffsetStruct* aPos, int32_t aOffset) { + SelectablePeekReport current{this, aOffset}; + bool shouldStopAtHardBreak = + aPos->mWordMovementType == eDefaultBehavior && + StaticPrefs::layout_word_select_eat_space_to_next_word(); + bool wordSelectEatSpace = ShouldWordSelectionEatSpace(*aPos); + + PeekWordState state; + while (true) { + bool movingInFrameDirection = IsMovingInFrameDirection( + current.mFrame, aPos->mDirection, + aPos->mOptions.contains(PeekOffsetOption::Visual)); + + FrameSearchResult searchResult = current.mFrame->PeekOffsetWord( + movingInFrameDirection, wordSelectEatSpace, + aPos->mOptions.contains(PeekOffsetOption::IsKeyboardSelect), + ¤t.mOffset, &state, + !aPos->mOptions.contains(PeekOffsetOption::PreserveSpaces)); + if (searchResult == FOUND) { + break; + } + + SelectablePeekReport next = current.mFrame->GetFrameFromDirection(*aPos); + if (next.Failed()) { + // If we've crossed the line boundary, check to make sure that we + // have not consumed a trailing newline as whitespace if it's + // significant. + if (next.mJumpedLine && wordSelectEatSpace && + current.mFrame->HasSignificantTerminalNewline() && + current.mFrame->StyleText()->mWhiteSpace != + StyleWhiteSpace::PreLine) { + current.mOffset -= 1; + } + break; + } + + if (next.mJumpedLine && !wordSelectEatSpace && state.mSawBeforeType) { + // We can't jump lines if we're looking for whitespace following + // non-whitespace, and we already encountered non-whitespace. + break; + } + + if (shouldStopAtHardBreak && next.mJumpedHardBreak) { + /** + * Prev, always: Jump and stop right there + * Next, saw inline: just stop + * Next, no inline: Jump and consume whitespaces + */ + if (aPos->mDirection == eDirPrevious) { + // Try moving to the previous line if exists + current.TransferTo(*aPos); + current.mFrame->PeekOffsetForCharacter(aPos, current.mOffset); + return NS_OK; + } + if (state.mSawInlineCharacter || current.mJumpedHardBreak) { + if (current.mFrame->HasSignificantTerminalNewline()) { + current.mOffset -= 1; + } + current.TransferTo(*aPos); + return NS_OK; + } + // Mark the state as whitespace and continue + state.Update(false, true); + } + + if (next.mJumpedLine) { + state.mContext.Truncate(); + } + current = next; + // Jumping a line is equivalent to encountering whitespace + // This affects only when it already met an actual character + if (wordSelectEatSpace && next.mJumpedLine) { + state.SetSawBeforeType(); + } + } + + // Set outputs + current.TransferTo(*aPos); + return NS_OK; +} + +static nsIFrame* GetFirstSelectableDescendantWithLineIterator( + nsIFrame* aParentFrame, bool aForceEditableRegion) { + auto FoundValidFrame = [aForceEditableRegion](const nsIFrame* aFrame) { + if (!aFrame->IsSelectable(nullptr)) { + return false; + } + if (aForceEditableRegion && !aFrame->GetContent()->IsEditable()) { + return false; + } + return true; + }; + + for (nsIFrame* child : aParentFrame->PrincipalChildList()) { + // some children may not be selectable, e.g. :before / :after pseudoelements + // content with user-select: none, or contenteditable="false" + // we need to skip them + if (child->CanProvideLineIterator() && FoundValidFrame(child)) { + return child; + } + if (nsIFrame* nested = GetFirstSelectableDescendantWithLineIterator( + child, aForceEditableRegion)) { + return nested; + } + } + return nullptr; +} + +nsresult nsIFrame::PeekOffsetForLine(PeekOffsetStruct* aPos) { + nsIFrame* blockFrame = this; + nsresult result = NS_ERROR_FAILURE; + + // outer loop + // moving to a next block when no more blocks are available in a subtree + AutoAssertNoDomMutations guard; + while (NS_FAILED(result)) { + auto [newBlock, lineFrame] = blockFrame->GetContainingBlockForLine( + aPos->mOptions.contains(PeekOffsetOption::ScrollViewStop)); + if (!newBlock) { + return NS_ERROR_FAILURE; + } + blockFrame = newBlock; + nsILineIterator* iter = blockFrame->GetLineIterator(); + int32_t thisLine = iter->FindLineContaining(lineFrame); + if (NS_WARN_IF(thisLine < 0)) { + return NS_ERROR_FAILURE; + } + + int8_t edgeCase = 0; // no edge case. This should look at thisLine + + // this part will find a frame or a block frame. If it's a block frame + // it will "drill down" to find a viable frame or it will return an + // error. + nsIFrame* lastFrame = this; + + // inner loop - crawling the frames within a specific block subtree + while (true) { + result = + GetNextPrevLineFromBlockFrame(aPos, blockFrame, thisLine, edgeCase); + // we came back to same spot! keep going + if (NS_SUCCEEDED(result) && + (!aPos->mResultFrame || aPos->mResultFrame == lastFrame)) { + aPos->mResultFrame = nullptr; + lastFrame = nullptr; + if (aPos->mDirection == eDirPrevious) { + thisLine--; + } else { + thisLine++; + } + continue; + } + + if (NS_FAILED(result)) { + break; + } + + lastFrame = aPos->mResultFrame; // set last frame + /* SPECIAL CHECK FOR NAVIGATION INTO TABLES + * when we hit a frame which doesn't have line iterator, we need to + * drill down and find a child with the line iterator to prevent the + * crawling process to prematurely finish. Note that this is only sound if + * we're guaranteed to not have multiple children implementing + * LineIterator. + * + * So far known cases are: + * 1) table wrapper (drill down into table row group) + * 2) table cell (drill down into its only anon child) + */ + const bool shouldDrillIntoChildren = + aPos->mResultFrame->IsTableWrapperFrame() || + aPos->mResultFrame->IsTableCellFrame(); + + if (shouldDrillIntoChildren) { + nsIFrame* child = GetFirstSelectableDescendantWithLineIterator( + aPos->mResultFrame, + aPos->mOptions.contains(PeekOffsetOption::ForceEditableRegion)); + if (child) { + aPos->mResultFrame = child; + } + } + + if (!aPos->mResultFrame->CanProvideLineIterator()) { + // no more selectable content at this level + break; + } + + if (aPos->mResultFrame == blockFrame) { + // Make sure block element is not the same as the one we had before. + break; + } + + // we've struck another block element with selectable content! + if (aPos->mDirection == eDirPrevious) { + edgeCase = 1; // far edge, search from end backwards + } else { + edgeCase = -1; // near edge search from beginning onwards + } + thisLine = 0; // this line means nothing now. + // everything else means something so keep looking "inside" the + // block + blockFrame = aPos->mResultFrame; + } + } + return result; +} + +nsresult nsIFrame::PeekOffsetForLineEdge(PeekOffsetStruct* aPos) { + // Adjusted so that the caret can't get confused when content changes + nsIFrame* frame = AdjustFrameForSelectionStyles(this); + Element* editingHost = frame->GetContent()->GetEditingHost(); + + auto [blockFrame, lineFrame] = frame->GetContainingBlockForLine( + aPos->mOptions.contains(PeekOffsetOption::ScrollViewStop)); + if (!blockFrame) { + return NS_ERROR_FAILURE; + } + AutoAssertNoDomMutations guard; + nsILineIterator* it = blockFrame->GetLineIterator(); + int32_t thisLine = it->FindLineContaining(lineFrame); + if (thisLine < 0) { + return NS_ERROR_FAILURE; + } + + nsIFrame* baseFrame = nullptr; + bool endOfLine = eSelectEndLine == aPos->mAmount; + + if (aPos->mOptions.contains(PeekOffsetOption::Visual) && + PresContext()->BidiEnabled()) { + nsIFrame* firstFrame; + bool isReordered; + nsIFrame* lastFrame; + MOZ_TRY( + it->CheckLineOrder(thisLine, &isReordered, &firstFrame, &lastFrame)); + baseFrame = endOfLine ? lastFrame : firstFrame; + } else { + auto line = it->GetLine(thisLine).unwrap(); + + nsIFrame* frame = line.mFirstFrameOnLine; + bool lastFrameWasEditable = false; + for (int32_t count = line.mNumFramesOnLine; count; + --count, frame = frame->GetNextSibling()) { + if (frame->IsGeneratedContentFrame()) { + continue; + } + // When jumping to the end of the line with the "end" key, + // try to skip over brFrames + if (endOfLine && line.mNumFramesOnLine > 1 && frame->IsBrFrame() && + lastFrameWasEditable == frame->GetContent()->IsEditable()) { + continue; + } + lastFrameWasEditable = + frame->GetContent() && frame->GetContent()->IsEditable(); + baseFrame = frame; + if (!endOfLine) { + break; + } + } + } + if (!baseFrame) { + return NS_ERROR_FAILURE; + } + // Make sure we are not leaving our inline editing host if exists + if (editingHost) { + if (nsIFrame* frame = editingHost->GetPrimaryFrame()) { + if (frame->IsInlineOutside() && + !editingHost->Contains(baseFrame->GetContent())) { + baseFrame = frame; + if (endOfLine) { + baseFrame = baseFrame->LastContinuation(); + } + } + } + } + FrameTarget targetFrame = DrillDownToSelectionFrame(baseFrame, endOfLine, 0); + SetPeekResultFromFrame(*aPos, targetFrame.frame, endOfLine ? -1 : 0, + OffsetIsAtLineEdge::Yes); + if (endOfLine && targetFrame.frame->HasSignificantTerminalNewline()) { + // Do not position the caret after the terminating newline if we're + // trying to move to the end of line (see bug 596506) + --aPos->mContentOffset; + } + if (!aPos->mResultContent) { + return NS_ERROR_FAILURE; + } + return NS_OK; +} + +nsresult nsIFrame::PeekOffset(PeekOffsetStruct* aPos) { + MOZ_ASSERT(aPos); + + if (NS_WARN_IF(HasAnyStateBits(NS_FRAME_IS_DIRTY))) { + // FIXME(Bug 1654362): <caption> currently can remain dirty. + return NS_ERROR_UNEXPECTED; + } + + // Translate content offset to be relative to frame + int32_t offset = aPos->mStartOffset - GetRangeForFrame(this).start; + + switch (aPos->mAmount) { + case eSelectCharacter: + case eSelectCluster: + return PeekOffsetForCharacter(aPos, offset); + case eSelectWordNoSpace: + // eSelectWordNoSpace means that we should not be eating any whitespace + // when moving to the adjacent word. This means that we should set aPos-> + // mWordMovementType to eEndWord if we're moving forwards, and to + // eStartWord if we're moving backwards. + if (aPos->mDirection == eDirPrevious) { + aPos->mWordMovementType = eStartWord; + } else { + aPos->mWordMovementType = eEndWord; + } + // Intentionally fall through the eSelectWord case. + [[fallthrough]]; + case eSelectWord: + return PeekOffsetForWord(aPos, offset); + case eSelectLine: + return PeekOffsetForLine(aPos); + case eSelectBeginLine: + case eSelectEndLine: + return PeekOffsetForLineEdge(aPos); + case eSelectParagraph: + return PeekOffsetForParagraph(aPos); + default: { + NS_ASSERTION(false, "Invalid amount"); + return NS_ERROR_FAILURE; + } + } +} + +nsIFrame::FrameSearchResult nsIFrame::PeekOffsetNoAmount(bool aForward, + int32_t* aOffset) { + NS_ASSERTION(aOffset && *aOffset <= 1, "aOffset out of range"); + // Sure, we can stop right here. + return FOUND; +} + +nsIFrame::FrameSearchResult nsIFrame::PeekOffsetCharacter( + bool aForward, int32_t* aOffset, PeekOffsetCharacterOptions aOptions) { + NS_ASSERTION(aOffset && *aOffset <= 1, "aOffset out of range"); + int32_t startOffset = *aOffset; + // A negative offset means "end of frame", which in our case means offset 1. + if (startOffset < 0) startOffset = 1; + if (aForward == (startOffset == 0)) { + // We're before the frame and moving forward, or after it and moving + // backwards: skip to the other side and we're done. + *aOffset = 1 - startOffset; + return FOUND; + } + return CONTINUE; +} + +nsIFrame::FrameSearchResult nsIFrame::PeekOffsetWord( + bool aForward, bool aWordSelectEatSpace, bool aIsKeyboardSelect, + int32_t* aOffset, PeekWordState* aState, bool /*aTrimSpaces*/) { + NS_ASSERTION(aOffset && *aOffset <= 1, "aOffset out of range"); + int32_t startOffset = *aOffset; + // This isn't text, so truncate the context + aState->mContext.Truncate(); + if (startOffset < 0) startOffset = 1; + if (aForward == (startOffset == 0)) { + // We're before the frame and moving forward, or after it and moving + // backwards. If we're looking for non-whitespace, we found it (without + // skipping this frame). + if (!aState->mAtStart) { + if (aState->mLastCharWasPunctuation) { + // We're not punctuation, so this is a punctuation boundary. + if (BreakWordBetweenPunctuation(aState, aForward, false, false, + aIsKeyboardSelect)) + return FOUND; + } else { + // This is not a punctuation boundary. + if (aWordSelectEatSpace && aState->mSawBeforeType) return FOUND; + } + } + // Otherwise skip to the other side and note that we encountered + // non-whitespace. + *aOffset = 1 - startOffset; + aState->Update(false, // not punctuation + false // not whitespace + ); + if (!aWordSelectEatSpace) aState->SetSawBeforeType(); + } + return CONTINUE; +} + +// static +bool nsIFrame::BreakWordBetweenPunctuation(const PeekWordState* aState, + bool aForward, bool aPunctAfter, + bool aWhitespaceAfter, + bool aIsKeyboardSelect) { + NS_ASSERTION(aPunctAfter != aState->mLastCharWasPunctuation, + "Call this only at punctuation boundaries"); + if (aState->mLastCharWasWhitespace) { + // We always stop between whitespace and punctuation + return true; + } + if (!StaticPrefs::layout_word_select_stop_at_punctuation()) { + // When this pref is false, we never stop at a punctuation boundary unless + // it's followed by whitespace (in the relevant direction). + return aWhitespaceAfter; + } + if (!aIsKeyboardSelect) { + // mouse caret movement (e.g. word selection) always stops at every + // punctuation boundary + return true; + } + bool afterPunct = aForward ? aState->mLastCharWasPunctuation : aPunctAfter; + if (!afterPunct) { + // keyboard caret movement only stops after punctuation (in content order) + return false; + } + // Stop only if we've seen some non-punctuation since the last whitespace; + // don't stop after punctuation that follows whitespace. + return aState->mSeenNonPunctuationSinceWhitespace; +} + +std::pair<nsIFrame*, nsIFrame*> nsIFrame::GetContainingBlockForLine( + bool aLockScroll) const { + const nsIFrame* parentFrame = this; + const nsIFrame* frame; + while (parentFrame) { + frame = parentFrame; + if (frame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW)) { + // if we are searching for a frame that is not in flow we will not find + // it. we must instead look for its placeholder + if (frame->HasAnyStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER)) { + // abspos continuations don't have placeholders, get the fif + frame = frame->FirstInFlow(); + } + frame = frame->GetPlaceholderFrame(); + if (!frame) { + return std::pair(nullptr, nullptr); + } + } + parentFrame = frame->GetParent(); + if (parentFrame) { + if (aLockScroll && parentFrame->IsScrollFrame()) { + return std::pair(nullptr, nullptr); + } + if (parentFrame->CanProvideLineIterator()) { + return std::pair(const_cast<nsIFrame*>(parentFrame), + const_cast<nsIFrame*>(frame)); + } + } + } + return std::pair(nullptr, nullptr); +} + +Result<bool, nsresult> nsIFrame::IsVisuallyAtLineEdge( + nsILineIterator* aLineIterator, int32_t aLine, nsDirection aDirection) { + nsIFrame* firstFrame; + nsIFrame* lastFrame; + + const bool lineIsRTL = aLineIterator->IsLineIteratorFlowRTL(); + bool isReordered; + + MOZ_TRY(aLineIterator->CheckLineOrder(aLine, &isReordered, &firstFrame, + &lastFrame)); + + nsIFrame** framePtr = aDirection == eDirPrevious ? &firstFrame : &lastFrame; + if (!*framePtr) { + return true; + } + + bool frameIsRTL = (nsBidiPresUtils::FrameDirection(*framePtr) == + mozilla::intl::BidiDirection::RTL); + if ((frameIsRTL == lineIsRTL) == (aDirection == eDirPrevious)) { + nsIFrame::GetFirstLeaf(framePtr); + } else { + nsIFrame::GetLastLeaf(framePtr); + } + return *framePtr == this; +} + +Result<bool, nsresult> nsIFrame::IsLogicallyAtLineEdge( + nsILineIterator* aLineIterator, int32_t aLine, nsDirection aDirection) { + auto line = aLineIterator->GetLine(aLine).unwrap(); + + if (aDirection == eDirPrevious) { + nsIFrame* firstFrame = line.mFirstFrameOnLine; + nsIFrame::GetFirstLeaf(&firstFrame); + return firstFrame == this; + } + + // eDirNext + nsIFrame* lastFrame = line.mFirstFrameOnLine; + for (int32_t lineFrameCount = line.mNumFramesOnLine; lineFrameCount > 1; + lineFrameCount--) { + lastFrame = lastFrame->GetNextSibling(); + if (!lastFrame) { + NS_ERROR("should not be reached nsIFrame"); + return Err(NS_ERROR_FAILURE); + } + } + nsIFrame::GetLastLeaf(&lastFrame); + return lastFrame == this; +} + +nsIFrame::SelectablePeekReport nsIFrame::GetFrameFromDirection( + nsDirection aDirection, const PeekOffsetOptions& aOptions) { + SelectablePeekReport result; + + nsPresContext* presContext = PresContext(); + const bool needsVisualTraversal = + aOptions.contains(PeekOffsetOption::Visual) && presContext->BidiEnabled(); + nsCOMPtr<nsIFrameEnumerator> frameTraversal; + MOZ_TRY(NS_NewFrameTraversal( + getter_AddRefs(frameTraversal), presContext, this, eLeaf, + needsVisualTraversal, aOptions.contains(PeekOffsetOption::ScrollViewStop), + true, // aFollowOOFs + false // aSkipPopupChecks + )); + + // Find the prev/next selectable frame + bool selectable = false; + nsIFrame* traversedFrame = this; + AutoAssertNoDomMutations guard; + const nsIContent* const nativeAnonymousSubtreeContent = + GetClosestNativeAnonymousSubtreeRoot(); + while (!selectable) { + auto [blockFrame, lineFrame] = traversedFrame->GetContainingBlockForLine( + aOptions.contains(PeekOffsetOption::ScrollViewStop)); + if (!blockFrame) { + return result; + } + + nsILineIterator* it = blockFrame->GetLineIterator(); + int32_t thisLine = it->FindLineContaining(lineFrame); + if (thisLine < 0) { + return result; + } + + bool atLineEdge; + MOZ_TRY_VAR( + atLineEdge, + needsVisualTraversal + ? traversedFrame->IsVisuallyAtLineEdge(it, thisLine, aDirection) + : traversedFrame->IsLogicallyAtLineEdge(it, thisLine, aDirection)); + if (atLineEdge) { + result.mJumpedLine = true; + if (!aOptions.contains(PeekOffsetOption::JumpLines)) { + return result; // we are done. cannot jump lines + } + int32_t lineToCheckWrap = + aDirection == eDirPrevious ? thisLine - 1 : thisLine; + if (lineToCheckWrap < 0 || + !it->GetLine(lineToCheckWrap).unwrap().mIsWrapped) { + result.mJumpedHardBreak = true; + } + } + + traversedFrame = frameTraversal->Traverse(aDirection == eDirNext); + if (!traversedFrame) { + return result; + } + + auto IsSelectable = + [aOptions, nativeAnonymousSubtreeContent](const nsIFrame* aFrame) { + if (!aFrame->IsSelectable(nullptr)) { + return false; + } + // If the new frame is in a native anonymous subtree, we should treat + // it as not selectable unless the frame and found frame are in same + // subtree. + if (aFrame->GetClosestNativeAnonymousSubtreeRoot() != + nativeAnonymousSubtreeContent) { + return false; + } + return !aOptions.contains(PeekOffsetOption::ForceEditableRegion) || + aFrame->GetContent()->IsEditable(); + }; + + // Skip br frames, but only if we can select something before hitting the + // end of the line or a non-selectable region. + if (atLineEdge && aDirection == eDirPrevious && + traversedFrame->IsBrFrame()) { + for (nsIFrame* current = traversedFrame->GetPrevSibling(); current; + current = current->GetPrevSibling()) { + if (!current->IsBlockOutside() && IsSelectable(current)) { + if (!current->IsBrFrame()) { + result.mIgnoredBrFrame = true; + } + break; + } + } + if (result.mIgnoredBrFrame) { + continue; + } + } + + selectable = IsSelectable(traversedFrame); + if (!selectable) { + if (traversedFrame->IsSelectable(nullptr)) { + result.mHasSelectableFrame = true; + } + result.mMovedOverNonSelectableText = true; + } + } // while (!selectable) + + result.mOffset = (aDirection == eDirNext) ? 0 : -1; + + if (aOptions.contains(PeekOffsetOption::Visual) && + nsBidiPresUtils::IsReversedDirectionFrame(traversedFrame)) { + // The new frame is reverse-direction, go to the other end + result.mOffset = -1 - result.mOffset; + } + result.mFrame = traversedFrame; + return result; +} + +nsIFrame::SelectablePeekReport nsIFrame::GetFrameFromDirection( + const PeekOffsetStruct& aPos) { + return GetFrameFromDirection(aPos.mDirection, aPos.mOptions); +} + +nsView* nsIFrame::GetClosestView(nsPoint* aOffset) const { + nsPoint offset(0, 0); + for (const nsIFrame* f = this; f; f = f->GetParent()) { + if (f->HasView()) { + if (aOffset) *aOffset = offset; + return f->GetView(); + } + offset += f->GetPosition(); + } + + MOZ_ASSERT_UNREACHABLE("No view on any parent? How did that happen?"); + return nullptr; +} + +/* virtual */ +void nsIFrame::ChildIsDirty(nsIFrame* aChild) { + MOZ_ASSERT_UNREACHABLE( + "should never be called on a frame that doesn't " + "inherit from nsContainerFrame"); +} + +#ifdef ACCESSIBILITY +a11y::AccType nsIFrame::AccessibleType() { + if (IsTableCaption() && !GetRect().IsEmpty()) { + return a11y::eHTMLCaptionType; + } + return a11y::eNoType; +} +#endif + +bool nsIFrame::ClearOverflowRects() { + if (mOverflow.mType == OverflowStorageType::None) { + return false; + } + if (mOverflow.mType == OverflowStorageType::Large) { + RemoveProperty(OverflowAreasProperty()); + } + mOverflow.mType = OverflowStorageType::None; + return true; +} + +bool nsIFrame::SetOverflowAreas(const OverflowAreas& aOverflowAreas) { + if (mOverflow.mType == OverflowStorageType::Large) { + OverflowAreas* overflow = GetOverflowAreasProperty(); + bool changed = *overflow != aOverflowAreas; + *overflow = aOverflowAreas; + + // Don't bother with converting to the deltas form if we already + // have a property. + return changed; + } + + const nsRect& vis = aOverflowAreas.InkOverflow(); + uint32_t l = -vis.x, // left edge: positive delta is leftwards + t = -vis.y, // top: positive is upwards + r = vis.XMost() - mRect.width, // right: positive is rightwards + b = vis.YMost() - mRect.height; // bottom: positive is downwards + if (aOverflowAreas.ScrollableOverflow().IsEqualEdges( + nsRect(nsPoint(0, 0), GetSize())) && + l <= InkOverflowDeltas::kMax && t <= InkOverflowDeltas::kMax && + r <= InkOverflowDeltas::kMax && b <= InkOverflowDeltas::kMax && + // we have to check these against zero because we *never* want to + // set a frame as having no overflow in this function. This is + // because FinishAndStoreOverflow calls this function prior to + // SetRect based on whether the overflow areas match aNewSize. + // In the case where the overflow areas exactly match mRect but + // do not match aNewSize, we need to store overflow in a property + // so that our eventual SetRect/SetSize will know that it has to + // reset our overflow areas. + (l | t | r | b) != 0) { + InkOverflowDeltas oldDeltas = mOverflow.mInkOverflowDeltas; + // It's a "small" overflow area so we store the deltas for each edge + // directly in the frame, rather than allocating a separate rect. + // If they're all zero, that's fine; we're setting things to + // no-overflow. + mOverflow.mInkOverflowDeltas.mLeft = l; + mOverflow.mInkOverflowDeltas.mTop = t; + mOverflow.mInkOverflowDeltas.mRight = r; + mOverflow.mInkOverflowDeltas.mBottom = b; + // There was no scrollable overflow before, and there isn't now. + return oldDeltas != mOverflow.mInkOverflowDeltas; + } else { + bool changed = + !aOverflowAreas.ScrollableOverflow().IsEqualEdges( + nsRect(nsPoint(0, 0), GetSize())) || + !aOverflowAreas.InkOverflow().IsEqualEdges(InkOverflowFromDeltas()); + + // it's a large overflow area that we need to store as a property + mOverflow.mType = OverflowStorageType::Large; + AddProperty(OverflowAreasProperty(), new OverflowAreas(aOverflowAreas)); + return changed; + } +} + +enum class ApplyTransform : bool { No, Yes }; + +/** + * Compute the outline inner rect (so without outline-width and outline-offset) + * of aFrame, maybe iterating over its descendants, in aFrame's coordinate space + * or its post-transform coordinate space (depending on aApplyTransform). + */ +static nsRect ComputeOutlineInnerRect( + nsIFrame* aFrame, ApplyTransform aApplyTransform, bool& aOutValid, + const nsSize* aSizeOverride = nullptr, + const OverflowAreas* aOverflowOverride = nullptr) { + const nsRect bounds(nsPoint(0, 0), + aSizeOverride ? *aSizeOverride : aFrame->GetSize()); + + // The SVG container frames besides SVGTextFrame do not maintain + // an accurate mRect. It will make the outline be larger than + // we expect, we need to make them narrow to their children's outline. + // aOutValid is set to false if the returned nsRect is not valid + // and should not be included in the outline rectangle. + aOutValid = !aFrame->HasAnyStateBits(NS_FRAME_SVG_LAYOUT) || + !aFrame->IsFrameOfType(nsIFrame::eSVGContainer) || + aFrame->IsSVGTextFrame(); + + nsRect u; + + if (!aFrame->FrameMaintainsOverflow()) { + return u; + } + + // Start from our border-box, transformed. See comment below about + // transform of children. + bool doTransform = + aApplyTransform == ApplyTransform::Yes && aFrame->IsTransformed(); + TransformReferenceBox boundsRefBox(nullptr, bounds); + if (doTransform) { + u = nsDisplayTransform::TransformRect(bounds, aFrame, boundsRefBox); + } else { + u = bounds; + } + + if (aOutValid && !StaticPrefs::layout_outline_include_overflow()) { + return u; + } + + // Only iterate through the children if the overflow areas suggest + // that we might need to, and if the frame doesn't clip its overflow + // anyway. + if (aOverflowOverride) { + if (!doTransform && bounds.IsEqualEdges(aOverflowOverride->InkOverflow()) && + bounds.IsEqualEdges(aOverflowOverride->ScrollableOverflow())) { + return u; + } + } else { + if (!doTransform && bounds.IsEqualEdges(aFrame->InkOverflowRect()) && + bounds.IsEqualEdges(aFrame->ScrollableOverflowRect())) { + return u; + } + } + const nsStyleDisplay* disp = aFrame->StyleDisplay(); + LayoutFrameType fType = aFrame->Type(); + if (fType == LayoutFrameType::Scroll || + fType == LayoutFrameType::ListControl || + fType == LayoutFrameType::SVGOuterSVG) { + return u; + } + + auto overflowClipAxes = aFrame->ShouldApplyOverflowClipping(disp); + auto overflowClipMargin = aFrame->OverflowClipMargin(overflowClipAxes); + if (overflowClipAxes == nsIFrame::PhysicalAxes::Both && + overflowClipMargin == nsSize()) { + return u; + } + + const nsStyleEffects* effects = aFrame->StyleEffects(); + Maybe<nsRect> clipPropClipRect = + aFrame->GetClipPropClipRect(disp, effects, bounds.Size()); + + // Iterate over all children except pop-up, absolutely-positioned, + // float, and overflow ones. + const FrameChildListIDs skip = { + FrameChildListID::Popup, FrameChildListID::Absolute, + FrameChildListID::Fixed, FrameChildListID::Float, + FrameChildListID::Overflow}; + for (const auto& [list, listID] : aFrame->ChildLists()) { + if (skip.contains(listID)) { + continue; + } + + for (nsIFrame* child : list) { + if (child->IsPlaceholderFrame()) { + continue; + } + + // Note that passing ApplyTransform::Yes when + // child->Combines3DTransformWithAncestors() returns true is incorrect if + // our aApplyTransform is No... but the opposite would be as well. + // This is because elements within a preserve-3d scene are always + // transformed up to the top of the scene. This means we don't have a + // mechanism for getting a transform up to an intermediate point within + // the scene. We choose to over-transform rather than under-transform + // because this is consistent with other overflow areas. + bool validRect = true; + nsRect childRect = + ComputeOutlineInnerRect(child, ApplyTransform::Yes, validRect) + + child->GetPosition(); + + if (!validRect) { + continue; + } + + if (clipPropClipRect) { + // Intersect with the clip before transforming. + childRect.IntersectRect(childRect, *clipPropClipRect); + } + + // Note that we transform each child separately according to + // aFrame's transform, and then union, which gives a different + // (smaller) result from unioning and then transforming the + // union. This doesn't match the way we handle overflow areas + // with 2-D transforms, though it does match the way we handle + // overflow areas in preserve-3d 3-D scenes. + if (doTransform && !child->Combines3DTransformWithAncestors()) { + childRect = + nsDisplayTransform::TransformRect(childRect, aFrame, boundsRefBox); + } + + // If a SVGContainer has a non-SVGContainer child, we assign + // its child's outline to this SVGContainer directly. + if (!aOutValid && validRect) { + u = childRect; + aOutValid = true; + } else { + u = u.UnionEdges(childRect); + } + } + } + + if (overflowClipAxes != nsIFrame::PhysicalAxes::None) { + OverflowAreas::ApplyOverflowClippingOnRect(u, bounds, overflowClipAxes, + overflowClipMargin); + } + return u; +} + +static void ComputeAndIncludeOutlineArea(nsIFrame* aFrame, + OverflowAreas& aOverflowAreas, + const nsSize& aNewSize) { + const nsStyleOutline* outline = aFrame->StyleOutline(); + if (!outline->ShouldPaintOutline()) { + return; + } + + // When the outline property is set on a :-moz-block-inside-inline-wrapper + // pseudo-element, it inherited that outline from the inline that was broken + // because it contained a block. In that case, we don't want a really wide + // outline if the block inside the inline is narrow, so union the actual + // contents of the anonymous blocks. + nsIFrame* frameForArea = aFrame; + do { + PseudoStyleType pseudoType = frameForArea->Style()->GetPseudoType(); + if (pseudoType != PseudoStyleType::mozBlockInsideInlineWrapper) break; + // If we're done, we really want it and all its later siblings. + frameForArea = frameForArea->PrincipalChildList().FirstChild(); + NS_ASSERTION(frameForArea, "anonymous block with no children?"); + } while (frameForArea); + + // Find the union of the border boxes of all descendants, or in + // the block-in-inline case, all descendants we care about. + // + // Note that the interesting perspective-related cases are taken + // care of by the code that handles those issues for overflow + // calling FinishAndStoreOverflow again, which in turn calls this + // function again. We still need to deal with preserve-3d a bit. + nsRect innerRect; + bool validRect = false; + if (frameForArea == aFrame) { + innerRect = ComputeOutlineInnerRect(aFrame, ApplyTransform::No, validRect, + &aNewSize, &aOverflowAreas); + } else { + for (; frameForArea; frameForArea = frameForArea->GetNextSibling()) { + nsRect r = + ComputeOutlineInnerRect(frameForArea, ApplyTransform::Yes, validRect); + + // Adjust for offsets transforms up to aFrame's pre-transform + // (i.e., normal) coordinate space; see comments in + // UnionBorderBoxes for some of the subtlety here. + for (nsIFrame *f = frameForArea, *parent = f->GetParent(); + /* see middle of loop */; f = parent, parent = f->GetParent()) { + r += f->GetPosition(); + if (parent == aFrame) { + break; + } + if (parent->IsTransformed() && !f->Combines3DTransformWithAncestors()) { + TransformReferenceBox refBox(parent); + r = nsDisplayTransform::TransformRect(r, parent, refBox); + } + } + + innerRect.UnionRect(innerRect, r); + } + } + + // Keep this code in sync with nsDisplayOutline::GetInnerRect. + if (innerRect == aFrame->GetRectRelativeToSelf()) { + aFrame->RemoveProperty(nsIFrame::OutlineInnerRectProperty()); + } else { + SetOrUpdateRectValuedProperty(aFrame, nsIFrame::OutlineInnerRectProperty(), + innerRect); + } + + const nscoord offset = outline->mOutlineOffset.ToAppUnits(); + nsRect outerRect(innerRect); + if (outline->mOutlineStyle.IsAuto()) { + nsPresContext* pc = aFrame->PresContext(); + outerRect.Inflate(offset); + pc->Theme()->GetWidgetOverflow(pc->DeviceContext(), aFrame, + StyleAppearance::FocusOutline, &outerRect); + } else { + nscoord width = outline->GetOutlineWidth(); + outerRect.Inflate(width + offset); + } + + nsRect& vo = aOverflowAreas.InkOverflow(); + vo = vo.UnionEdges(innerRect.Union(outerRect)); +} + +bool nsIFrame::FinishAndStoreOverflow(OverflowAreas& aOverflowAreas, + nsSize aNewSize, nsSize* aOldSize, + const nsStyleDisplay* aStyleDisplay) { + MOZ_ASSERT(FrameMaintainsOverflow(), + "Don't call - overflow rects not maintained on these SVG frames"); + + const nsStyleDisplay* disp = StyleDisplayWithOptionalParam(aStyleDisplay); + bool hasTransform = IsTransformed(); + + nsRect bounds(nsPoint(0, 0), aNewSize); + // Store the passed in overflow area if we are a preserve-3d frame or we have + // a transform, and it's not just the frame bounds. + if (hasTransform || Combines3DTransformWithAncestors()) { + if (!aOverflowAreas.InkOverflow().IsEqualEdges(bounds) || + !aOverflowAreas.ScrollableOverflow().IsEqualEdges(bounds)) { + OverflowAreas* initial = GetProperty(nsIFrame::InitialOverflowProperty()); + if (!initial) { + AddProperty(nsIFrame::InitialOverflowProperty(), + new OverflowAreas(aOverflowAreas)); + } else if (initial != &aOverflowAreas) { + *initial = aOverflowAreas; + } + } else { + RemoveProperty(nsIFrame::InitialOverflowProperty()); + } +#ifdef DEBUG + SetProperty(nsIFrame::DebugInitialOverflowPropertyApplied(), true); +#endif + } else { +#ifdef DEBUG + RemoveProperty(nsIFrame::DebugInitialOverflowPropertyApplied()); +#endif + } + + nsSize oldSize = mRect.Size(); + bool sizeChanged = ((aOldSize ? *aOldSize : oldSize) != aNewSize); + + // Our frame size may not have been computed and set yet, but code under + // functions such as ComputeEffectsRect (which we're about to call) use the + // values that are stored in our frame rect to compute their results. We + // need the results from those functions to be based on the frame size that + // we *will* have, so we temporarily set our frame size here before calling + // those functions. + // + // XXX Someone should document here why we revert the frame size before we + // return rather than just leaving it set. + // + // We pass false here to avoid invalidating display items for this temporary + // change. We sometimes reflow frames multiple times, with the final size + // being the same as the initial. The single call to SetSize after reflow is + // done will take care of invalidating display items if the size has actually + // changed. + SetSize(aNewSize, false); + + const auto overflowClipAxes = ShouldApplyOverflowClipping(disp); + + if (ChildrenHavePerspective(disp) && sizeChanged) { + RecomputePerspectiveChildrenOverflow(this); + + if (overflowClipAxes != PhysicalAxes::Both) { + aOverflowAreas.SetAllTo(bounds); + DebugOnly<bool> ok = ComputeCustomOverflow(aOverflowAreas); + + // ComputeCustomOverflow() should not return false, when + // FrameMaintainsOverflow() returns true. + MOZ_ASSERT(ok, "FrameMaintainsOverflow() != ComputeCustomOverflow()"); + + UnionChildOverflow(aOverflowAreas); + } + } + + // This is now called FinishAndStoreOverflow() instead of + // StoreOverflow() because frame-generic ways of adding overflow + // can happen here, e.g. CSS2 outline and native theme. + // If the overflow area width or height is nscoord_MAX, then a + // saturating union may have encounted an overflow, so the overflow may not + // contain the frame border-box. Don't warn in that case. + // Don't warn for SVG either, since SVG doesn't need the overflow area + // to contain the frame bounds. + for (const auto otype : AllOverflowTypes()) { + DebugOnly<nsRect*> r = &aOverflowAreas.Overflow(otype); + NS_ASSERTION(aNewSize.width == 0 || aNewSize.height == 0 || + r->width == nscoord_MAX || r->height == nscoord_MAX || + HasAnyStateBits(NS_FRAME_SVG_LAYOUT) || + r->Contains(nsRect(nsPoint(0, 0), aNewSize)), + "Computed overflow area must contain frame bounds"); + } + + // Overflow area must always include the frame's top-left and bottom-right, + // even if the frame rect is empty (so we can scroll to those positions). + const bool shouldIncludeBounds = [&] { + if (aNewSize.width == 0 && IsInlineFrame()) { + // Pending a real fix for bug 426879, don't do this for inline frames with + // zero width. + return false; + } + if (HasAnyStateBits(NS_FRAME_SVG_LAYOUT)) { + // Do not do this for SVG either, since it will usually massively increase + // the area unnecessarily (except for SVG that applies clipping, since + // that's the pre-existing behavior, and breaks pre-rendering otherwise). + // FIXME(bug 1770704): This check most likely wants to be removed or check + // for specific frame types at least. + return overflowClipAxes != PhysicalAxes::None; + } + return true; + }(); + + if (shouldIncludeBounds) { + for (const auto otype : AllOverflowTypes()) { + nsRect& o = aOverflowAreas.Overflow(otype); + o = o.UnionEdges(bounds); + } + } + + // If we clip our children, clear accumulated overflow area in the affected + // dimension(s). The children are actually clipped to the padding-box, but + // since the overflow area should include the entire border-box, just set it + // to the border-box size here. + if (overflowClipAxes != PhysicalAxes::None) { + aOverflowAreas.ApplyClipping(bounds, overflowClipAxes, + OverflowClipMargin(overflowClipAxes)); + } + + ComputeAndIncludeOutlineArea(this, aOverflowAreas, aNewSize); + + // Nothing in here should affect scrollable overflow. + aOverflowAreas.InkOverflow() = + ComputeEffectsRect(this, aOverflowAreas.InkOverflow(), aNewSize); + + // Absolute position clipping + const nsStyleEffects* effects = StyleEffects(); + Maybe<nsRect> clipPropClipRect = GetClipPropClipRect(disp, effects, aNewSize); + if (clipPropClipRect) { + for (const auto otype : AllOverflowTypes()) { + nsRect& o = aOverflowAreas.Overflow(otype); + o.IntersectRect(o, *clipPropClipRect); + } + } + + /* If we're transformed, transform the overflow rect by the current + * transformation. */ + if (hasTransform) { + SetProperty(nsIFrame::PreTransformOverflowAreasProperty(), + new OverflowAreas(aOverflowAreas)); + + if (Combines3DTransformWithAncestors()) { + /* If we're a preserve-3d leaf frame, then our pre-transform overflow + * should be correct. Our post-transform overflow is empty though, because + * we only contribute to the overflow area of the preserve-3d root frame. + * If we're an intermediate frame then the pre-transform overflow should + * contain all our non-preserve-3d children, which is what we want. Again + * we have no post-transform overflow. + */ + aOverflowAreas.SetAllTo(nsRect()); + } else { + TransformReferenceBox refBox(this); + for (const auto otype : AllOverflowTypes()) { + nsRect& o = aOverflowAreas.Overflow(otype); + o = nsDisplayTransform::TransformRect(o, this, refBox); + } + + /* If we're the root of the 3d context, then we want to include the + * overflow areas of all the participants. This won't have happened yet as + * the code above set their overflow area to empty. Manually collect these + * overflow areas now. + */ + if (Extend3DContext(disp, effects)) { + ComputePreserve3DChildrenOverflow(aOverflowAreas); + } + } + } else { + RemoveProperty(nsIFrame::PreTransformOverflowAreasProperty()); + } + + /* Revert the size change in case some caller is depending on this. */ + SetSize(oldSize, false); + + bool anyOverflowChanged; + if (aOverflowAreas != OverflowAreas(bounds, bounds)) { + anyOverflowChanged = SetOverflowAreas(aOverflowAreas); + } else { + anyOverflowChanged = ClearOverflowRects(); + } + + if (anyOverflowChanged) { + SVGObserverUtils::InvalidateDirectRenderingObservers(this); + if (nsBlockFrame* block = do_QueryFrame(this)) { + // NOTE(emilio): we need to use BeforeReflow::Yes, because we want to + // invalidate in cases where we _used_ to have an overflow marker and no + // longer do. + if (TextOverflow::CanHaveOverflowMarkers( + block, TextOverflow::BeforeReflow::Yes)) { + DiscardDisplayItems(this, [](nsDisplayItem* aItem) { + return aItem->GetType() == DisplayItemType::TYPE_TEXT_OVERFLOW; + }); + SchedulePaint(PAINT_DEFAULT); + } + } + } + return anyOverflowChanged; +} + +void nsIFrame::RecomputePerspectiveChildrenOverflow( + const nsIFrame* aStartFrame) { + for (const auto& childList : ChildLists()) { + for (nsIFrame* child : childList.mList) { + if (!child->FrameMaintainsOverflow()) { + continue; // frame does not maintain overflow rects + } + if (child->HasPerspective()) { + OverflowAreas* overflow = + child->GetProperty(nsIFrame::InitialOverflowProperty()); + nsRect bounds(nsPoint(0, 0), child->GetSize()); + if (overflow) { + OverflowAreas overflowCopy = *overflow; + child->FinishAndStoreOverflow(overflowCopy, bounds.Size()); + } else { + OverflowAreas boundsOverflow; + boundsOverflow.SetAllTo(bounds); + child->FinishAndStoreOverflow(boundsOverflow, bounds.Size()); + } + } else if (child->GetContent() == aStartFrame->GetContent() || + child->GetClosestFlattenedTreeAncestorPrimaryFrame() == + aStartFrame) { + // If a frame is using perspective, then the size used to compute + // perspective-origin is the size of the frame belonging to its parent + // style. We must find any descendant frames using our size + // (by recursing into frames that have the same containing block) + // to update their overflow rects too. + child->RecomputePerspectiveChildrenOverflow(aStartFrame); + } + } + } +} + +void nsIFrame::ComputePreserve3DChildrenOverflow( + OverflowAreas& aOverflowAreas) { + // Find all descendants that participate in the 3d context, and include their + // overflow. These descendants have an empty overflow, so won't have been + // included in the normal overflow calculation. Any children that don't + // participate have normal overflow, so will have been included already. + + nsRect childVisual; + nsRect childScrollable; + for (const auto& childList : ChildLists()) { + for (nsIFrame* child : childList.mList) { + // If this child participates in the 3d context, then take the + // pre-transform region (which contains all descendants that aren't + // participating in the 3d context) and transform it into the 3d context + // root coordinate space. + if (child->Combines3DTransformWithAncestors()) { + OverflowAreas childOverflow = child->GetOverflowAreasRelativeToSelf(); + TransformReferenceBox refBox(child); + for (const auto otype : AllOverflowTypes()) { + nsRect& o = childOverflow.Overflow(otype); + o = nsDisplayTransform::TransformRect(o, child, refBox); + } + + aOverflowAreas.UnionWith(childOverflow); + + // If this child also extends the 3d context, then recurse into it + // looking for more participants. + if (child->Extend3DContext()) { + child->ComputePreserve3DChildrenOverflow(aOverflowAreas); + } + } + } + } +} + +bool nsIFrame::ZIndexApplies() const { + return StyleDisplay()->IsPositionedStyle() || IsFlexOrGridItem() || + IsMenuPopupFrame(); +} + +Maybe<int32_t> nsIFrame::ZIndex() const { + if (!ZIndexApplies()) { + return Nothing(); + } + const auto& zIndex = StylePosition()->mZIndex; + if (zIndex.IsAuto()) { + return Nothing(); + } + return Some(zIndex.AsInteger()); +} + +bool nsIFrame::IsScrollAnchor(ScrollAnchorContainer** aOutContainer) { + if (!mInScrollAnchorChain) { + return false; + } + + nsIFrame* f = this; + + // FIXME(emilio, bug 1629280): We should find a non-null anchor if we have the + // flag set, but bug 1629280 makes it so that we cannot really assert it / + // make this just a `while (true)`, and uncomment the below assertion. + while (auto* container = ScrollAnchorContainer::FindFor(f)) { + // MOZ_ASSERT(f->IsInScrollAnchorChain()); + if (nsIFrame* anchor = container->AnchorNode()) { + if (anchor != this) { + return false; + } + if (aOutContainer) { + *aOutContainer = container; + } + return true; + } + + f = container->Frame(); + } + + return false; +} + +bool nsIFrame::IsInScrollAnchorChain() const { return mInScrollAnchorChain; } + +void nsIFrame::SetInScrollAnchorChain(bool aInChain) { + mInScrollAnchorChain = aInChain; +} + +uint32_t nsIFrame::GetDepthInFrameTree() const { + uint32_t result = 0; + for (nsContainerFrame* ancestor = GetParent(); ancestor; + ancestor = ancestor->GetParent()) { + result++; + } + return result; +} + +/** + * This function takes a frame that is part of a block-in-inline split, + * and _if_ that frame is an anonymous block created by an ib split it + * returns the block's preceding inline. This is needed because the + * split inline's style is the parent of the anonymous block's style. + * + * If aFrame is not an anonymous block, null is returned. + */ +static nsIFrame* GetIBSplitSiblingForAnonymousBlock(const nsIFrame* aFrame) { + MOZ_ASSERT(aFrame, "Must have a non-null frame!"); + NS_ASSERTION(aFrame->HasAnyStateBits(NS_FRAME_PART_OF_IBSPLIT), + "GetIBSplitSibling should only be called on ib-split frames"); + + if (aFrame->Style()->GetPseudoType() != + PseudoStyleType::mozBlockInsideInlineWrapper) { + // it's not an anonymous block + return nullptr; + } + + // Find the first continuation of the frame. (Ugh. This ends up + // being O(N^2) when it is called O(N) times.) + aFrame = aFrame->FirstContinuation(); + + /* + * Now look up the nsGkAtoms::IBSplitPrevSibling + * property. + */ + nsIFrame* ibSplitSibling = + aFrame->GetProperty(nsIFrame::IBSplitPrevSibling()); + NS_ASSERTION(ibSplitSibling, "Broken frame tree?"); + return ibSplitSibling; +} + +/** + * Get the parent, corrected for the mangled frame tree resulting from + * having a block within an inline. The result only differs from the + * result of |GetParent| when |GetParent| returns an anonymous block + * that was created for an element that was 'display: inline' because + * that element contained a block. + * + * Also skip anonymous scrolled-content parents; inherit directly from the + * outer scroll frame. + * + * Also skip NAC parents if the child frame is NAC. + */ +static nsIFrame* GetCorrectedParent(const nsIFrame* aFrame) { + nsIFrame* parent = aFrame->GetParent(); + if (!parent) { + return nullptr; + } + + // For a table caption we want the _inner_ table frame (unless it's anonymous) + // as the style parent. + if (aFrame->IsTableCaption()) { + nsIFrame* innerTable = parent->PrincipalChildList().FirstChild(); + if (!innerTable->Style()->IsAnonBox()) { + return innerTable; + } + } + + // Table wrappers are always anon boxes; if we're in here for an outer + // table, that actually means its the _inner_ table that wants to + // know its parent. So get the pseudo of the inner in that case. + auto pseudo = aFrame->Style()->GetPseudoType(); + if (pseudo == PseudoStyleType::tableWrapper) { + pseudo = + aFrame->PrincipalChildList().FirstChild()->Style()->GetPseudoType(); + } + + // Prevent a NAC pseudo-element from inheriting from its NAC parent, and + // inherit from the NAC generator element instead. + if (pseudo != PseudoStyleType::NotPseudo) { + MOZ_ASSERT(aFrame->GetContent()); + Element* element = Element::FromNode(aFrame->GetContent()); + // Make sure to avoid doing the fixup for non-element-backed pseudos like + // ::first-line and such. + if (element && !element->IsRootOfNativeAnonymousSubtree() && + element->GetPseudoElementType() == aFrame->Style()->GetPseudoType()) { + while (parent->GetContent() && + !parent->GetContent()->IsRootOfNativeAnonymousSubtree()) { + parent = parent->GetInFlowParent(); + } + parent = parent->GetInFlowParent(); + } + } + + return nsIFrame::CorrectStyleParentFrame(parent, pseudo); +} + +/* static */ +nsIFrame* nsIFrame::CorrectStyleParentFrame(nsIFrame* aProspectiveParent, + PseudoStyleType aChildPseudo) { + MOZ_ASSERT(aProspectiveParent, "Must have a prospective parent"); + + if (aChildPseudo != PseudoStyleType::NotPseudo) { + // Non-inheriting anon boxes have no style parent frame at all. + if (PseudoStyle::IsNonInheritingAnonBox(aChildPseudo)) { + return nullptr; + } + + // Other anon boxes are parented to their actual parent already, except + // for non-elements. Those should not be treated as an anon box. + if (PseudoStyle::IsAnonBox(aChildPseudo) && + !nsCSSAnonBoxes::IsNonElement(aChildPseudo)) { + NS_ASSERTION(aChildPseudo != PseudoStyleType::mozBlockInsideInlineWrapper, + "Should have dealt with kids that have " + "NS_FRAME_PART_OF_IBSPLIT elsewhere"); + return aProspectiveParent; + } + } + + // Otherwise, walk up out of all anon boxes. For placeholder frames, walk out + // of all pseudo-elements as well. Otherwise ReparentComputedStyle could + // cause style data to be out of sync with the frame tree. + nsIFrame* parent = aProspectiveParent; + do { + if (parent->HasAnyStateBits(NS_FRAME_PART_OF_IBSPLIT)) { + nsIFrame* sibling = GetIBSplitSiblingForAnonymousBlock(parent); + + if (sibling) { + // |parent| was a block in an {ib} split; use the inline as + // |the style parent. + parent = sibling; + } + } + + if (!parent->Style()->IsPseudoOrAnonBox()) { + return parent; + } + + if (!parent->Style()->IsAnonBox() && aChildPseudo != PseudoStyleType::MAX) { + // nsPlaceholderFrame passes in PseudoStyleType::MAX for + // aChildPseudo (even though that's not a valid pseudo-type) just to + // trigger this behavior of walking up to the nearest non-pseudo + // ancestor. + return parent; + } + + parent = parent->GetInFlowParent(); + } while (parent); + + if (aProspectiveParent->Style()->GetPseudoType() == + PseudoStyleType::viewportScroll) { + // aProspectiveParent is the scrollframe for a viewport + // and the kids are the anonymous scrollbars + return aProspectiveParent; + } + + // We can get here if the root element is absolutely positioned. + // We can't test for this very accurately, but it can only happen + // when the prospective parent is a canvas frame. + NS_ASSERTION(aProspectiveParent->IsCanvasFrame(), + "Should have found a parent before this"); + return nullptr; +} + +ComputedStyle* nsIFrame::DoGetParentComputedStyle( + nsIFrame** aProviderFrame) const { + *aProviderFrame = nullptr; + + // Handle display:contents and the root frame, when there's no parent frame + // to inherit from. + if (MOZ_LIKELY(mContent)) { + Element* parentElement = mContent->GetFlattenedTreeParentElement(); + if (MOZ_LIKELY(parentElement)) { + auto pseudo = Style()->GetPseudoType(); + if (pseudo == PseudoStyleType::NotPseudo || !mContent->IsElement() || + (!PseudoStyle::IsAnonBox(pseudo) && + // Ensure that we don't return the display:contents style + // of the parent content for pseudos that have the same content + // as their primary frame (like -moz-list-bullets do): + IsPrimaryFrame()) || + /* if next is true then it's really a request for the table frame's + parent context, see nsTable[Outer]Frame::GetParentComputedStyle. */ + pseudo == PseudoStyleType::tableWrapper) { + // In some edge cases involving display: contents, we may end up here + // for something that's pending to be reframed. In this case we return + // the wrong style from here (because we've already lost track of it!), + // but it's not a big deal as we're going to be reframed anyway. + if (MOZ_LIKELY(parentElement->HasServoData()) && + Servo_Element_IsDisplayContents(parentElement)) { + RefPtr<ComputedStyle> style = + ServoStyleSet::ResolveServoStyle(*parentElement); + // NOTE(emilio): we return a weak reference because the element also + // holds the style context alive. This is a bit silly (we could've + // returned a weak ref directly), but it's probably not worth + // optimizing, given this function has just one caller which is rare, + // and this path is rare itself. + return style; + } + } + } else { + if (Style()->GetPseudoType() == PseudoStyleType::NotPseudo) { + // We're a frame for the root. We have no style parent. + return nullptr; + } + } + } + + if (!HasAnyStateBits(NS_FRAME_OUT_OF_FLOW)) { + /* + * If this frame is an anonymous block created when an inline with a block + * inside it got split, then the parent style is on its preceding inline. We + * can get to it using GetIBSplitSiblingForAnonymousBlock. + */ + if (HasAnyStateBits(NS_FRAME_PART_OF_IBSPLIT)) { + nsIFrame* ibSplitSibling = GetIBSplitSiblingForAnonymousBlock(this); + if (ibSplitSibling) { + return (*aProviderFrame = ibSplitSibling)->Style(); + } + } + + // If this frame is one of the blocks that split an inline, we must + // return the "special" inline parent, i.e., the parent that this + // frame would have if we didn't mangle the frame structure. + *aProviderFrame = GetCorrectedParent(this); + return *aProviderFrame ? (*aProviderFrame)->Style() : nullptr; + } + + // We're an out-of-flow frame. For out-of-flow frames, we must + // resolve underneath the placeholder's parent. The placeholder is + // reached from the first-in-flow. + nsPlaceholderFrame* placeholder = FirstInFlow()->GetPlaceholderFrame(); + if (!placeholder) { + MOZ_ASSERT_UNREACHABLE("no placeholder frame for out-of-flow frame"); + *aProviderFrame = GetCorrectedParent(this); + return *aProviderFrame ? (*aProviderFrame)->Style() : nullptr; + } + return placeholder->GetParentComputedStyleForOutOfFlow(aProviderFrame); +} + +void nsIFrame::GetLastLeaf(nsIFrame** aFrame) { + if (!aFrame || !*aFrame) return; + nsIFrame* child = *aFrame; + // if we are a block frame then go for the last line of 'this' + while (1) { + child = child->PrincipalChildList().FirstChild(); + if (!child) return; // nothing to do + nsIFrame* siblingFrame; + nsIContent* content; + // ignore anonymous elements, e.g. mozTableAdd* mozTableRemove* + // see bug 278197 comment #12 #13 for details + while ((siblingFrame = child->GetNextSibling()) && + (content = siblingFrame->GetContent()) && + !content->IsRootOfNativeAnonymousSubtree()) + child = siblingFrame; + *aFrame = child; + } +} + +void nsIFrame::GetFirstLeaf(nsIFrame** aFrame) { + if (!aFrame || !*aFrame) return; + nsIFrame* child = *aFrame; + while (1) { + child = child->PrincipalChildList().FirstChild(); + if (!child) return; // nothing to do + *aFrame = child; + } +} + +bool nsIFrame::IsFocusableDueToScrollFrame() { + if (!IsScrollFrame()) { + if (nsFieldSetFrame* fieldset = do_QueryFrame(this)) { + // TODO: Do we have similar special-cases like this where we can have + // anonymous scrollable boxes hanging off a primary frame? + if (nsIFrame* inner = fieldset->GetInner()) { + return inner->IsFocusableDueToScrollFrame(); + } + } + return false; + } + if (!mContent->IsHTMLElement()) { + return false; + } + if (mContent->IsRootOfNativeAnonymousSubtree()) { + return false; + } + if (!mContent->GetParent()) { + return false; + } + if (mContent->AsElement()->HasAttr(nsGkAtoms::tabindex)) { + return false; + } + // Elements with scrollable view are focusable with script & tabbable + // Otherwise you couldn't scroll them with keyboard, which is an accessibility + // issue (e.g. Section 508 rules) However, we don't make them to be focusable + // with the mouse, because the extra focus outlines are considered + // unnecessarily ugly. When clicked on, the selection position within the + // element will be enough to make them keyboard scrollable. + nsIScrollableFrame* scrollFrame = do_QueryFrame(this); + if (!scrollFrame) { + return false; + } + if (scrollFrame->IsForTextControlWithNoScrollbars()) { + return false; + } + if (scrollFrame->GetScrollStyles().IsHiddenInBothDirections()) { + return false; + } + if (scrollFrame->GetScrollRange().IsEqualEdges(nsRect(0, 0, 0, 0))) { + return false; + } + return true; +} + +nsIFrame::Focusable nsIFrame::IsFocusable(bool aWithMouse, + bool aCheckVisibility) { + // cannot focus content in print preview mode. Only the root can be focused, + // but that's handled elsewhere. + if (PresContext()->Type() == nsPresContext::eContext_PrintPreview) { + return {}; + } + + if (!mContent || !mContent->IsElement()) { + return {}; + } + + if (aCheckVisibility && !IsVisibleConsideringAncestors()) { + return {}; + } + + const nsStyleUI& ui = *StyleUI(); + if (ui.IsInert()) { + return {}; + } + + PseudoStyleType pseudo = Style()->GetPseudoType(); + if (pseudo == PseudoStyleType::anonymousItem) { + return {}; + } + + int32_t tabIndex = -1; + if (ui.UserFocus() != StyleUserFocus::Ignore && + ui.UserFocus() != StyleUserFocus::None) { + // Pass in default tabindex of -1 for nonfocusable and 0 for focusable + tabIndex = 0; + } + + if (mContent->IsFocusable(&tabIndex, aWithMouse)) { + // If the content is focusable, then we're done. + return {true, tabIndex}; + } + + // If we're focusing with the mouse we never focus scroll areas. + if (!aWithMouse && IsFocusableDueToScrollFrame()) { + return {true, 0}; + } + + return {false, tabIndex}; +} + +/** + * @return true if this text frame ends with a newline character which is + * treated as preformatted. It should return false if this is not a text frame. + */ +bool nsIFrame::HasSignificantTerminalNewline() const { return false; } + +static StyleVerticalAlignKeyword ConvertSVGDominantBaselineToVerticalAlign( + StyleDominantBaseline aDominantBaseline) { + // Most of these are approximate mappings. + switch (aDominantBaseline) { + case StyleDominantBaseline::Hanging: + case StyleDominantBaseline::TextBeforeEdge: + return StyleVerticalAlignKeyword::TextTop; + case StyleDominantBaseline::TextAfterEdge: + case StyleDominantBaseline::Ideographic: + return StyleVerticalAlignKeyword::TextBottom; + case StyleDominantBaseline::Central: + case StyleDominantBaseline::Middle: + case StyleDominantBaseline::Mathematical: + return StyleVerticalAlignKeyword::Middle; + case StyleDominantBaseline::Auto: + case StyleDominantBaseline::Alphabetic: + return StyleVerticalAlignKeyword::Baseline; + default: + MOZ_ASSERT_UNREACHABLE("unexpected aDominantBaseline value"); + return StyleVerticalAlignKeyword::Baseline; + } +} + +Maybe<StyleVerticalAlignKeyword> nsIFrame::VerticalAlignEnum() const { + if (IsInSVGTextSubtree()) { + StyleDominantBaseline dominantBaseline = StyleSVG()->mDominantBaseline; + return Some(ConvertSVGDominantBaselineToVerticalAlign(dominantBaseline)); + } + + const auto& verticalAlign = StyleDisplay()->mVerticalAlign; + if (verticalAlign.IsKeyword()) { + return Some(verticalAlign.AsKeyword()); + } + + return Nothing(); +} + +void nsIFrame::UpdateStyleOfChildAnonBox(nsIFrame* aChildFrame, + ServoRestyleState& aRestyleState) { +#ifdef DEBUG + nsIFrame* parent = aChildFrame->GetInFlowParent(); + if (aChildFrame->IsTableFrame()) { + parent = parent->GetParent(); + } + if (parent->IsLineFrame()) { + parent = parent->GetParent(); + } + MOZ_ASSERT(nsLayoutUtils::FirstContinuationOrIBSplitSibling(parent) == this, + "This should only be used for children!"); +#endif // DEBUG + MOZ_ASSERT(!GetContent() || !aChildFrame->GetContent() || + aChildFrame->GetContent() == GetContent(), + "What content node is it a frame for?"); + MOZ_ASSERT(!aChildFrame->GetPrevContinuation(), + "Only first continuations should end up here"); + + // We could force the caller to pass in the pseudo, since some callers know it + // statically... But this API is a bit nicer. + auto pseudo = aChildFrame->Style()->GetPseudoType(); + MOZ_ASSERT(PseudoStyle::IsAnonBox(pseudo), "Child is not an anon box?"); + MOZ_ASSERT(!PseudoStyle::IsNonInheritingAnonBox(pseudo), + "Why did the caller bother calling us?"); + + // Anon boxes inherit from their parent; that's us. + RefPtr<ComputedStyle> newContext = + aRestyleState.StyleSet().ResolveInheritingAnonymousBoxStyle(pseudo, + Style()); + + nsChangeHint childHint = + UpdateStyleOfOwnedChildFrame(aChildFrame, newContext, aRestyleState); + + // Now that we've updated the style on aChildFrame, check whether it itself + // has anon boxes to deal with. + ServoRestyleState childrenState(*aChildFrame, aRestyleState, childHint, + ServoRestyleState::Type::InFlow); + aChildFrame->UpdateStyleOfOwnedAnonBoxes(childrenState); + + // Assuming anon boxes don't have ::backdrop associated with them... if that + // ever changes, we'd need to handle that here, like we do in + // RestyleManager::ProcessPostTraversal + + // We do need to handle block pseudo-elements here, though. Especially list + // bullets. + if (nsBlockFrame* block = do_QueryFrame(aChildFrame)) { + block->UpdatePseudoElementStyles(childrenState); + } +} + +/* static */ +nsChangeHint nsIFrame::UpdateStyleOfOwnedChildFrame( + nsIFrame* aChildFrame, ComputedStyle* aNewComputedStyle, + ServoRestyleState& aRestyleState, + const Maybe<ComputedStyle*>& aContinuationComputedStyle) { + MOZ_ASSERT(!aChildFrame->GetAdditionalComputedStyle(0), + "We don't handle additional styles here"); + + // Figure out whether we have an actual change. It's important that we do + // this, for several reasons: + // + // 1) Even if all the child's changes are due to properties it inherits from + // us, it's possible that no one ever asked us for those style structs and + // hence changes to them aren't reflected in the changes handled at all. + // + // 2) Content can change stylesheets that change the styles of pseudos, and + // extensions can add/remove stylesheets that change the styles of + // anonymous boxes directly. + uint32_t equalStructs; // Not used, actually. + nsChangeHint childHint = aChildFrame->Style()->CalcStyleDifference( + *aNewComputedStyle, &equalStructs); + + // If aChildFrame is out of flow, then aRestyleState's "changes handled by the + // parent" doesn't apply to it, because it may have some other parent in the + // frame tree. + if (!aChildFrame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW)) { + childHint = NS_RemoveSubsumedHints( + childHint, aRestyleState.ChangesHandledFor(aChildFrame)); + } + if (childHint) { + if (childHint & nsChangeHint_ReconstructFrame) { + // If we generate a reconstruct here, remove any non-reconstruct hints we + // may have already generated for this content. + aRestyleState.ChangeList().PopChangesForContent( + aChildFrame->GetContent()); + } + aRestyleState.ChangeList().AppendChange( + aChildFrame, aChildFrame->GetContent(), childHint); + } + + aChildFrame->SetComputedStyle(aNewComputedStyle); + ComputedStyle* continuationStyle = aContinuationComputedStyle + ? *aContinuationComputedStyle + : aNewComputedStyle; + for (nsIFrame* kid = aChildFrame->GetNextContinuation(); kid; + kid = kid->GetNextContinuation()) { + MOZ_ASSERT(!kid->GetAdditionalComputedStyle(0)); + kid->SetComputedStyle(continuationStyle); + } + + return childHint; +} + +/* static */ +void nsIFrame::AddInPopupStateBitToDescendants(nsIFrame* aFrame) { + if (!aFrame->HasAnyStateBits(NS_FRAME_IN_POPUP) && + aFrame->TrackingVisibility()) { + // Assume all frames in popups are visible. + aFrame->IncApproximateVisibleCount(); + } + + aFrame->AddStateBits(NS_FRAME_IN_POPUP); + + for (const auto& childList : aFrame->CrossDocChildLists()) { + for (nsIFrame* child : childList.mList) { + AddInPopupStateBitToDescendants(child); + } + } +} + +/* static */ +void nsIFrame::RemoveInPopupStateBitFromDescendants(nsIFrame* aFrame) { + if (!aFrame->HasAnyStateBits(NS_FRAME_IN_POPUP) || + nsLayoutUtils::IsPopup(aFrame)) { + return; + } + + aFrame->RemoveStateBits(NS_FRAME_IN_POPUP); + + if (aFrame->TrackingVisibility()) { + // We assume all frames in popups are visible, so this decrement balances + // out the increment in AddInPopupStateBitToDescendants above. + aFrame->DecApproximateVisibleCount(); + } + for (const auto& childList : aFrame->CrossDocChildLists()) { + for (nsIFrame* child : childList.mList) { + RemoveInPopupStateBitFromDescendants(child); + } + } +} + +void nsIFrame::SetParent(nsContainerFrame* aParent) { + // If our parent is a wrapper anon box, our new parent should be too. We + // _can_ change parent if our parent is a wrapper anon box, because some + // wrapper anon boxes can have continuations. + MOZ_ASSERT_IF(ParentIsWrapperAnonBox(), + aParent->Style()->IsInheritingAnonBox()); + + // Note that the current mParent may already be destroyed at this point. + mParent = aParent; + MOZ_DIAGNOSTIC_ASSERT(!mParent || PresShell() == mParent->PresShell()); + + if (HasAnyStateBits(NS_FRAME_HAS_VIEW | NS_FRAME_HAS_CHILD_WITH_VIEW)) { + for (nsIFrame* f = aParent; + f && !f->HasAnyStateBits(NS_FRAME_HAS_CHILD_WITH_VIEW); + f = f->GetParent()) { + f->AddStateBits(NS_FRAME_HAS_CHILD_WITH_VIEW); + } + } + + if (HasAnyStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE)) { + for (nsIFrame* f = aParent; f; f = f->GetParent()) { + if (f->HasAnyStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE)) { + break; + } + f->AddStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE); + } + } + + if (HasAnyStateBits(NS_FRAME_DESCENDANT_INTRINSIC_ISIZE_DEPENDS_ON_BSIZE)) { + for (nsIFrame* f = aParent; f; f = f->GetParent()) { + if (f->HasAnyStateBits( + NS_FRAME_DESCENDANT_INTRINSIC_ISIZE_DEPENDS_ON_BSIZE)) { + break; + } + f->AddStateBits(NS_FRAME_DESCENDANT_INTRINSIC_ISIZE_DEPENDS_ON_BSIZE); + } + } + + if (HasInvalidFrameInSubtree()) { + for (nsIFrame* f = aParent; + f && !f->HasAnyStateBits(NS_FRAME_DESCENDANT_NEEDS_PAINT | + NS_FRAME_IS_NONDISPLAY); + f = nsLayoutUtils::GetCrossDocParentFrameInProcess(f)) { + f->AddStateBits(NS_FRAME_DESCENDANT_NEEDS_PAINT); + } + } + + if (aParent->HasAnyStateBits(NS_FRAME_IN_POPUP)) { + AddInPopupStateBitToDescendants(this); + } else { + RemoveInPopupStateBitFromDescendants(this); + } + + // If our new parent only has invalid children, then we just invalidate + // ourselves too. This is probably faster than clearing the flag all + // the way up the frame tree. + if (aParent->HasAnyStateBits(NS_FRAME_ALL_DESCENDANTS_NEED_PAINT)) { + InvalidateFrame(); + } else { + SchedulePaint(); + } +} + +bool nsIFrame::IsStackingContext(const nsStyleDisplay* aStyleDisplay, + const nsStyleEffects* aStyleEffects) { + // Properties that influence the output of this function should be handled in + // change_bits_for_longhand as well. + if (HasOpacity(aStyleDisplay, aStyleEffects, nullptr)) { + return true; + } + if (IsTransformed()) { + return true; + } + auto willChange = aStyleDisplay->mWillChange.bits; + if (aStyleDisplay->IsContainPaint() || aStyleDisplay->IsContainLayout() || + willChange & StyleWillChangeBits::CONTAIN) { + if (IsFrameOfType(eSupportsContainLayoutAndPaint)) { + return true; + } + } + // strictly speaking, 'perspective' doesn't require visual atomicity, + // but the spec says it acts like the rest of these + if (aStyleDisplay->HasPerspectiveStyle() || + willChange & StyleWillChangeBits::PERSPECTIVE) { + if (IsFrameOfType(eSupportsCSSTransforms)) { + return true; + } + } + if (!StylePosition()->mZIndex.IsAuto() || + willChange & StyleWillChangeBits::Z_INDEX) { + if (ZIndexApplies()) { + return true; + } + } + return aStyleEffects->mMixBlendMode != StyleBlend::Normal || + SVGIntegrationUtils::UsingEffectsForFrame(this) || + aStyleDisplay->IsPositionForcingStackingContext() || + aStyleDisplay->mIsolation != StyleIsolation::Auto || + willChange & StyleWillChangeBits::STACKING_CONTEXT_UNCONDITIONAL; +} + +bool nsIFrame::IsStackingContext() { + return IsStackingContext(StyleDisplay(), StyleEffects()); +} + +static bool IsFrameScrolledOutOfView(const nsIFrame* aTarget, + const nsRect& aTargetRect, + const nsIFrame* aParent) { + // The ancestor frame we are checking if it clips out aTargetRect relative to + // aTarget. + nsIFrame* clipParent = nullptr; + + // find the first scrollable frame or root frame if we are in a fixed pos + // subtree + for (nsIFrame* f = const_cast<nsIFrame*>(aParent); f; + f = nsLayoutUtils::GetCrossDocParentFrameInProcess(f)) { + nsIScrollableFrame* scrollableFrame = do_QueryFrame(f); + if (scrollableFrame) { + clipParent = f; + break; + } + if (f->StyleDisplay()->mPosition == StylePositionProperty::Fixed && + nsLayoutUtils::IsReallyFixedPos(f)) { + clipParent = f->GetParent(); + break; + } + } + + if (!clipParent) { + // Even if we couldn't find the nearest scrollable frame, it might mean we + // are in an out-of-process iframe, try to see if |aTarget| frame is + // scrolled out of view in an scrollable frame in a cross-process ancestor + // document. + return nsLayoutUtils::FrameIsScrolledOutOfViewInCrossProcess(aTarget); + } + + nsRect clipRect = clipParent->InkOverflowRectRelativeToSelf(); + // We consider that the target is scrolled out if the scrollable (or root) + // frame is empty. + if (clipRect.IsEmpty()) { + return true; + } + + nsRect transformedRect = nsLayoutUtils::TransformFrameRectToAncestor( + aTarget, aTargetRect, clipParent); + + if (transformedRect.IsEmpty()) { + // If the transformed rect is empty it represents a line or a point that we + // should check is outside the the scrollable rect. + if (transformedRect.x > clipRect.XMost() || + transformedRect.y > clipRect.YMost() || + clipRect.x > transformedRect.XMost() || + clipRect.y > transformedRect.YMost()) { + return true; + } + } else if (!transformedRect.Intersects(clipRect)) { + return true; + } + + nsIFrame* parent = clipParent->GetParent(); + if (!parent) { + return false; + } + + return IsFrameScrolledOutOfView(aTarget, aTargetRect, parent); +} + +bool nsIFrame::IsScrolledOutOfView() const { + nsRect rect = InkOverflowRectRelativeToSelf(); + return IsFrameScrolledOutOfView(this, rect, this); +} + +gfx::Matrix nsIFrame::ComputeWidgetTransform() const { + const nsStyleUIReset* uiReset = StyleUIReset(); + if (uiReset->mMozWindowTransform.IsNone()) { + return gfx::Matrix(); + } + + TransformReferenceBox refBox(nullptr, nsRect(nsPoint(), GetSize())); + + nsPresContext* presContext = PresContext(); + int32_t appUnitsPerDevPixel = presContext->AppUnitsPerDevPixel(); + gfx::Matrix4x4 matrix = nsStyleTransformMatrix::ReadTransforms( + uiReset->mMozWindowTransform, refBox, float(appUnitsPerDevPixel)); + + // Apply the -moz-window-transform-origin translation to the matrix. + const StyleTransformOrigin& origin = uiReset->mWindowTransformOrigin; + Point transformOrigin = nsStyleTransformMatrix::Convert2DPosition( + origin.horizontal, origin.vertical, refBox, appUnitsPerDevPixel); + matrix.ChangeBasis(Point3D(transformOrigin.x, transformOrigin.y, 0)); + + gfx::Matrix result2d; + if (!matrix.CanDraw2D(&result2d)) { + // FIXME: It would be preferable to reject non-2D transforms at parse time. + NS_WARNING( + "-moz-window-transform does not describe a 2D transform, " + "but only 2d transforms are supported"); + return gfx::Matrix(); + } + + return result2d; +} + +void nsIFrame::DoUpdateStyleOfOwnedAnonBoxes(ServoRestyleState& aRestyleState) { + // As a special case, we check for {ib}-split block frames here, rather + // than have an nsInlineFrame::AppendDirectlyOwnedAnonBoxes implementation + // that returns them. + // + // (If we did handle them in AppendDirectlyOwnedAnonBoxes, we would have to + // return *all* of the in-flow {ib}-split block frames, not just the first + // one. For restyling, we really just need the first in flow, and the other + // user of the AppendOwnedAnonBoxes API, AllChildIterator, doesn't need to + // know about them at all, since these block frames never create NAC. So we + // avoid any unncessary hashtable lookups for the {ib}-split frames by calling + // UpdateStyleOfOwnedAnonBoxesForIBSplit directly here.) + if (IsInlineFrame()) { + if (HasAnyStateBits(NS_FRAME_PART_OF_IBSPLIT)) { + static_cast<nsInlineFrame*>(this)->UpdateStyleOfOwnedAnonBoxesForIBSplit( + aRestyleState); + } + return; + } + + AutoTArray<OwnedAnonBox, 4> frames; + AppendDirectlyOwnedAnonBoxes(frames); + for (OwnedAnonBox& box : frames) { + if (box.mUpdateStyleFn) { + box.mUpdateStyleFn(this, box.mAnonBoxFrame, aRestyleState); + } else { + UpdateStyleOfChildAnonBox(box.mAnonBoxFrame, aRestyleState); + } + } +} + +/* virtual */ +void nsIFrame::AppendDirectlyOwnedAnonBoxes(nsTArray<OwnedAnonBox>& aResult) { + MOZ_ASSERT(!HasAnyStateBits(NS_FRAME_OWNS_ANON_BOXES)); + MOZ_ASSERT(false, "Why did this get called?"); +} + +void nsIFrame::DoAppendOwnedAnonBoxes(nsTArray<OwnedAnonBox>& aResult) { + size_t i = aResult.Length(); + AppendDirectlyOwnedAnonBoxes(aResult); + + // After appending the directly owned anonymous boxes of this frame to + // aResult above, we need to check each of them to see if they own + // any anonymous boxes themselves. Note that we keep progressing + // through aResult, looking for additional entries in aResult from these + // subsequent AppendDirectlyOwnedAnonBoxes calls. (Thus we can't + // use a ranged for loop here.) + + while (i < aResult.Length()) { + nsIFrame* f = aResult[i].mAnonBoxFrame; + if (f->HasAnyStateBits(NS_FRAME_OWNS_ANON_BOXES)) { + f->AppendDirectlyOwnedAnonBoxes(aResult); + } + ++i; + } +} + +nsIFrame::CaretPosition::CaretPosition() : mContentOffset(0) {} + +nsIFrame::CaretPosition::~CaretPosition() = default; + +bool nsIFrame::HasCSSAnimations() { + auto* collection = AnimationCollection<CSSAnimation>::Get(this); + return collection && !collection->mAnimations.IsEmpty(); +} + +bool nsIFrame::HasCSSTransitions() { + auto* collection = AnimationCollection<CSSTransition>::Get(this); + return collection && !collection->mAnimations.IsEmpty(); +} + +void nsIFrame::AddSizeOfExcludingThisForTree(nsWindowSizes& aSizes) const { + aSizes.mLayoutFramePropertiesSize += + mProperties.SizeOfExcludingThis(aSizes.mState.mMallocSizeOf); + + // We don't do this for Gecko because this stuff is stored in the nsPresArena + // and so measured elsewhere. + if (!aSizes.mState.HaveSeenPtr(mComputedStyle)) { + mComputedStyle->AddSizeOfIncludingThis(aSizes, + &aSizes.mLayoutComputedValuesNonDom); + } + + // And our additional styles. + int32_t index = 0; + while (auto* extra = GetAdditionalComputedStyle(index++)) { + if (!aSizes.mState.HaveSeenPtr(extra)) { + extra->AddSizeOfIncludingThis(aSizes, + &aSizes.mLayoutComputedValuesNonDom); + } + } + + for (const auto& childList : ChildLists()) { + for (const nsIFrame* f : childList.mList) { + f->AddSizeOfExcludingThisForTree(aSizes); + } + } +} + +nsRect nsIFrame::GetCompositorHitTestArea(nsDisplayListBuilder* aBuilder) { + nsRect area; + + nsIScrollableFrame* scrollFrame = nsLayoutUtils::GetScrollableFrameFor(this); + if (scrollFrame) { + // If the frame is content of a scrollframe, then we need to pick up the + // area corresponding to the overflow rect as well. Otherwise the parts of + // the overflow that are not occupied by descendants get skipped and the + // APZ code sends touch events to the content underneath instead. + // See https://bugzilla.mozilla.org/show_bug.cgi?id=1127773#c15. + area = ScrollableOverflowRect(); + } else { + area = GetRectRelativeToSelf(); + } + + if (!area.IsEmpty()) { + return area + aBuilder->ToReferenceFrame(this); + } + + return area; +} + +CompositorHitTestInfo nsIFrame::GetCompositorHitTestInfo( + nsDisplayListBuilder* aBuilder) { + CompositorHitTestInfo result = CompositorHitTestInvisibleToHit; + + if (aBuilder->IsInsidePointerEventsNoneDoc()) { + // Somewhere up the parent document chain is a subdocument with pointer- + // events:none set on it. + return result; + } + if (!GetParent()) { + MOZ_ASSERT(IsViewportFrame()); + // Viewport frames are never event targets, other frames, like canvas + // frames, are the event targets for any regions viewport frames may cover. + return result; + } + if (Style()->PointerEvents() == StylePointerEvents::None) { + return result; + } + if (!StyleVisibility()->IsVisible()) { + return result; + } + + // Anything that didn't match the above conditions is visible to hit-testing. + result = CompositorHitTestFlags::eVisibleToHitTest; + if (SVGIntegrationUtils::UsingMaskOrClipPathForFrame(this)) { + // If WebRender is enabled, simple clip-paths can be converted into WR + // clips that WR knows how to hit-test against, so we don't need to mark + // it as an irregular area. + if (!SVGIntegrationUtils::UsingSimpleClipPathForFrame(this)) { + result += CompositorHitTestFlags::eIrregularArea; + } + } + + if (aBuilder->IsBuildingNonLayerizedScrollbar()) { + // Scrollbars may be painted into a layer below the actual layer they will + // scroll, and therefore wheel events may be dispatched to the outer frame + // instead of the intended scrollframe. To address this, we force a d-t-c + // region on scrollbar frames that won't be placed in their own layer. See + // bug 1213324 for details. + result += CompositorHitTestFlags::eInactiveScrollframe; + } else if (aBuilder->GetAncestorHasApzAwareEventHandler()) { + result += CompositorHitTestFlags::eApzAwareListeners; + } else if (IsRangeFrame()) { + // Range frames handle touch events directly without having a touch listener + // so we need to let APZ know that this area cares about events. + result += CompositorHitTestFlags::eApzAwareListeners; + } + + if (aBuilder->IsTouchEventPrefEnabledDoc()) { + // Inherit the touch-action flags from the parent, if there is one. We do + // this because of how the touch-action on a frame combines the touch-action + // from ancestor DOM elements. Refer to the documentation in + // TouchActionHelper.cpp for details; this code is meant to be equivalent to + // that code, but woven into the top-down recursive display list building + // process. + CompositorHitTestInfo inheritedTouchAction = + aBuilder->GetCompositorHitTestInfo() & CompositorHitTestTouchActionMask; + + nsIFrame* touchActionFrame = this; + if (nsIScrollableFrame* scrollFrame = + nsLayoutUtils::GetScrollableFrameFor(this)) { + ScrollStyles ss = scrollFrame->GetScrollStyles(); + if (ss.mVertical != StyleOverflow::Hidden || + ss.mHorizontal != StyleOverflow::Hidden) { + touchActionFrame = do_QueryFrame(scrollFrame); + // On scrollframes, stop inheriting the pan-x and pan-y flags; instead, + // reset them back to zero to allow panning on the scrollframe unless we + // encounter an element that disables it that's inside the scrollframe. + // This is equivalent to the |considerPanning| variable in + // TouchActionHelper.cpp, but for a top-down traversal. + CompositorHitTestInfo panMask( + CompositorHitTestFlags::eTouchActionPanXDisabled, + CompositorHitTestFlags::eTouchActionPanYDisabled); + inheritedTouchAction -= panMask; + } + } + + result += inheritedTouchAction; + + const StyleTouchAction touchAction = touchActionFrame->UsedTouchAction(); + // The CSS allows the syntax auto | none | [pan-x || pan-y] | manipulation + // so we can eliminate some combinations of things. + if (touchAction == StyleTouchAction::AUTO) { + // nothing to do + } else if (touchAction & StyleTouchAction::MANIPULATION) { + result += CompositorHitTestFlags::eTouchActionAnimatingZoomDisabled; + } else { + // This path handles the cases none | [pan-x || pan-y || pinch-zoom] so + // double-tap is disabled in here. + if (!(touchAction & StyleTouchAction::PINCH_ZOOM)) { + result += CompositorHitTestFlags::eTouchActionPinchZoomDisabled; + } + + result += CompositorHitTestFlags::eTouchActionAnimatingZoomDisabled; + + if (!(touchAction & StyleTouchAction::PAN_X)) { + result += CompositorHitTestFlags::eTouchActionPanXDisabled; + } + if (!(touchAction & StyleTouchAction::PAN_Y)) { + result += CompositorHitTestFlags::eTouchActionPanYDisabled; + } + if (touchAction & StyleTouchAction::NONE) { + // all the touch-action disabling flags will already have been set above + MOZ_ASSERT(result.contains(CompositorHitTestTouchActionMask)); + } + } + } + + const Maybe<ScrollDirection> scrollDirection = + aBuilder->GetCurrentScrollbarDirection(); + if (scrollDirection.isSome()) { + if (GetContent()->IsXULElement(nsGkAtoms::thumb)) { + const bool thumbGetsLayer = aBuilder->GetCurrentScrollbarTarget() != + layers::ScrollableLayerGuid::NULL_SCROLL_ID; + if (thumbGetsLayer) { + result += CompositorHitTestFlags::eScrollbarThumb; + } else { + result += CompositorHitTestFlags::eInactiveScrollframe; + } + } + + if (*scrollDirection == ScrollDirection::eVertical) { + result += CompositorHitTestFlags::eScrollbarVertical; + } + + // includes the ScrollbarFrame, SliderFrame, anything else that + // might be inside the xul:scrollbar + result += CompositorHitTestFlags::eScrollbar; + } + + return result; +} + +// Returns true if we can guarantee there is no visible descendants. +static bool HasNoVisibleDescendants(const nsIFrame* aFrame) { + for (const auto& childList : aFrame->ChildLists()) { + for (nsIFrame* f : childList.mList) { + if (nsPlaceholderFrame::GetRealFrameFor(f) + ->IsVisibleOrMayHaveVisibleDescendants()) { + return false; + } + } + } + return true; +} + +void nsIFrame::UpdateVisibleDescendantsState() { + if (StyleVisibility()->IsVisible()) { + // Notify invisible ancestors that a visible descendant exists now. + nsIFrame* ancestor; + for (ancestor = GetInFlowParent(); + ancestor && !ancestor->StyleVisibility()->IsVisible(); + ancestor = ancestor->GetInFlowParent()) { + ancestor->mAllDescendantsAreInvisible = false; + } + } else { + mAllDescendantsAreInvisible = HasNoVisibleDescendants(this); + } +} + +void nsIFrame::UpdateAnimationVisibility() { + auto* animationCollection = AnimationCollection<CSSAnimation>::Get(this); + auto* transitionCollection = AnimationCollection<CSSTransition>::Get(this); + + if ((!animationCollection || animationCollection->mAnimations.IsEmpty()) && + (!transitionCollection || transitionCollection->mAnimations.IsEmpty())) { + return; + } + + bool hidden = IsHiddenByContentVisibilityOnAnyAncestor(); + if (animationCollection) { + for (auto& animation : animationCollection->mAnimations) { + animation->SetHiddenByContentVisibility(hidden); + } + } + + if (transitionCollection) { + for (auto& transition : transitionCollection->mAnimations) { + transition->SetHiddenByContentVisibility(hidden); + } + } +} + +nsIFrame::PhysicalAxes nsIFrame::ShouldApplyOverflowClipping( + const nsStyleDisplay* aDisp) const { + MOZ_ASSERT(aDisp == StyleDisplay(), "Wrong display struct"); + + // 'contain:paint', which we handle as 'overflow:clip' here. Except for + // scrollframes we don't need contain:paint to add any clipping, because + // the scrollable frame will already clip overflowing content, and because + // 'contain:paint' should prevent all means of escaping that clipping + // (e.g. because it forms a fixed-pos containing block). + if (aDisp->IsContainPaint() && !IsScrollFrame() && + IsFrameOfType(eSupportsContainLayoutAndPaint)) { + return PhysicalAxes::Both; + } + + // and overflow:hidden that we should interpret as clip + if (aDisp->mOverflowX == StyleOverflow::Hidden && + aDisp->mOverflowY == StyleOverflow::Hidden) { + // REVIEW: these are the frame types that set up clipping. + LayoutFrameType type = Type(); + switch (type) { + case LayoutFrameType::Table: + case LayoutFrameType::TableCell: + case LayoutFrameType::SVGOuterSVG: + case LayoutFrameType::SVGInnerSVG: + case LayoutFrameType::SVGSymbol: + case LayoutFrameType::SVGForeignObject: + return PhysicalAxes::Both; + default: + if (IsFrameOfType(nsIFrame::eReplacedContainsBlock)) { + if (type == mozilla::LayoutFrameType::TextInput) { + // It has an anonymous scroll frame that handles any overflow. + return PhysicalAxes::None; + } + return PhysicalAxes::Both; + } + } + } + + // clip overflow:clip, except for nsListControlFrame which is + // an nsHTMLScrollFrame sub-class. + if (MOZ_UNLIKELY((aDisp->mOverflowX == mozilla::StyleOverflow::Clip || + aDisp->mOverflowY == mozilla::StyleOverflow::Clip) && + !IsListControlFrame())) { + // FIXME: we could use GetViewportScrollStylesOverrideElement() here instead + // if that worked correctly in a print context. (see bug 1654667) + const auto* element = Element::FromNodeOrNull(GetContent()); + if (!element || + !PresContext()->ElementWouldPropagateScrollStyles(*element)) { + uint8_t axes = uint8_t(PhysicalAxes::None); + if (aDisp->mOverflowX == mozilla::StyleOverflow::Clip) { + axes |= uint8_t(PhysicalAxes::Horizontal); + } + if (aDisp->mOverflowY == mozilla::StyleOverflow::Clip) { + axes |= uint8_t(PhysicalAxes::Vertical); + } + return PhysicalAxes(axes); + } + } + + if (HasAnyStateBits(NS_FRAME_SVG_LAYOUT)) { + return PhysicalAxes::None; + } + + // If we're paginated and a block, and have NS_BLOCK_CLIP_PAGINATED_OVERFLOW + // set, then we want to clip our overflow. + bool clip = HasAnyStateBits(NS_BLOCK_CLIP_PAGINATED_OVERFLOW) && + PresContext()->IsPaginated() && IsBlockFrame(); + return clip ? PhysicalAxes::Both : PhysicalAxes::None; +} + +#ifdef DEBUG +static void GetTagName(nsIFrame* aFrame, nsIContent* aContent, int aResultSize, + char* aResult) { + if (aContent) { + snprintf(aResult, aResultSize, "%s@%p", + nsAtomCString(aContent->NodeInfo()->NameAtom()).get(), aFrame); + } else { + snprintf(aResult, aResultSize, "@%p", aFrame); + } +} + +void nsIFrame::Trace(const char* aMethod, bool aEnter) { + if (NS_FRAME_LOG_TEST(sFrameLogModule, NS_FRAME_TRACE_CALLS)) { + char tagbuf[40]; + GetTagName(this, mContent, sizeof(tagbuf), tagbuf); + printf_stderr("%s: %s %s", tagbuf, aEnter ? "enter" : "exit", aMethod); + } +} + +void nsIFrame::Trace(const char* aMethod, bool aEnter, + const nsReflowStatus& aStatus) { + if (NS_FRAME_LOG_TEST(sFrameLogModule, NS_FRAME_TRACE_CALLS)) { + char tagbuf[40]; + GetTagName(this, mContent, sizeof(tagbuf), tagbuf); + printf_stderr("%s: %s %s, status=%scomplete%s", tagbuf, + aEnter ? "enter" : "exit", aMethod, + aStatus.IsIncomplete() ? "not" : "", + (aStatus.NextInFlowNeedsReflow()) ? "+reflow" : ""); + } +} + +void nsIFrame::TraceMsg(const char* aFormatString, ...) { + if (NS_FRAME_LOG_TEST(sFrameLogModule, NS_FRAME_TRACE_CALLS)) { + // Format arguments into a buffer + char argbuf[200]; + va_list ap; + va_start(ap, aFormatString); + VsprintfLiteral(argbuf, aFormatString, ap); + va_end(ap); + + char tagbuf[40]; + GetTagName(this, mContent, sizeof(tagbuf), tagbuf); + printf_stderr("%s: %s", tagbuf, argbuf); + } +} + +void nsIFrame::VerifyDirtyBitSet(const nsFrameList& aFrameList) { + for (nsIFrame* f : aFrameList) { + NS_ASSERTION(f->HasAnyStateBits(NS_FRAME_IS_DIRTY), "dirty bit not set"); + } +} + +// Start Display Reflow +DR_cookie::DR_cookie(nsPresContext* aPresContext, nsIFrame* aFrame, + const ReflowInput& aReflowInput, ReflowOutput& aMetrics, + nsReflowStatus& aStatus) + : mPresContext(aPresContext), + mFrame(aFrame), + mReflowInput(aReflowInput), + mMetrics(aMetrics), + mStatus(aStatus) { + MOZ_COUNT_CTOR(DR_cookie); + mValue = nsIFrame::DisplayReflowEnter(aPresContext, mFrame, mReflowInput); +} + +DR_cookie::~DR_cookie() { + MOZ_COUNT_DTOR(DR_cookie); + nsIFrame::DisplayReflowExit(mPresContext, mFrame, mMetrics, mStatus, mValue); +} + +DR_layout_cookie::DR_layout_cookie(nsIFrame* aFrame) : mFrame(aFrame) { + MOZ_COUNT_CTOR(DR_layout_cookie); + mValue = nsIFrame::DisplayLayoutEnter(mFrame); +} + +DR_layout_cookie::~DR_layout_cookie() { + MOZ_COUNT_DTOR(DR_layout_cookie); + nsIFrame::DisplayLayoutExit(mFrame, mValue); +} + +DR_intrinsic_inline_size_cookie::DR_intrinsic_inline_size_cookie( + nsIFrame* aFrame, const char* aType, nscoord& aResult) + : mFrame(aFrame), mType(aType), mResult(aResult) { + MOZ_COUNT_CTOR(DR_intrinsic_inline_size_cookie); + mValue = nsIFrame::DisplayIntrinsicISizeEnter(mFrame, mType); +} + +DR_intrinsic_inline_size_cookie::~DR_intrinsic_inline_size_cookie() { + MOZ_COUNT_DTOR(DR_intrinsic_inline_size_cookie); + nsIFrame::DisplayIntrinsicISizeExit(mFrame, mType, mResult, mValue); +} + +DR_intrinsic_size_cookie::DR_intrinsic_size_cookie(nsIFrame* aFrame, + const char* aType, + nsSize& aResult) + : mFrame(aFrame), mType(aType), mResult(aResult) { + MOZ_COUNT_CTOR(DR_intrinsic_size_cookie); + mValue = nsIFrame::DisplayIntrinsicSizeEnter(mFrame, mType); +} + +DR_intrinsic_size_cookie::~DR_intrinsic_size_cookie() { + MOZ_COUNT_DTOR(DR_intrinsic_size_cookie); + nsIFrame::DisplayIntrinsicSizeExit(mFrame, mType, mResult, mValue); +} + +DR_init_constraints_cookie::DR_init_constraints_cookie( + nsIFrame* aFrame, ReflowInput* aState, nscoord aCBWidth, nscoord aCBHeight, + const mozilla::Maybe<mozilla::LogicalMargin> aBorder, + const mozilla::Maybe<mozilla::LogicalMargin> aPadding) + : mFrame(aFrame), mState(aState) { + MOZ_COUNT_CTOR(DR_init_constraints_cookie); + nsMargin border; + if (aBorder) { + border = aBorder->GetPhysicalMargin(aFrame->GetWritingMode()); + } + nsMargin padding; + if (aPadding) { + padding = aPadding->GetPhysicalMargin(aFrame->GetWritingMode()); + } + mValue = ReflowInput::DisplayInitConstraintsEnter( + mFrame, mState, aCBWidth, aCBHeight, aBorder ? &border : nullptr, + aPadding ? &padding : nullptr); +} + +DR_init_constraints_cookie::~DR_init_constraints_cookie() { + MOZ_COUNT_DTOR(DR_init_constraints_cookie); + ReflowInput::DisplayInitConstraintsExit(mFrame, mState, mValue); +} + +DR_init_offsets_cookie::DR_init_offsets_cookie( + nsIFrame* aFrame, SizeComputationInput* aState, nscoord aPercentBasis, + WritingMode aCBWritingMode, + const mozilla::Maybe<mozilla::LogicalMargin> aBorder, + const mozilla::Maybe<mozilla::LogicalMargin> aPadding) + : mFrame(aFrame), mState(aState) { + MOZ_COUNT_CTOR(DR_init_offsets_cookie); + nsMargin border; + if (aBorder) { + border = aBorder->GetPhysicalMargin(aFrame->GetWritingMode()); + } + nsMargin padding; + if (aPadding) { + padding = aPadding->GetPhysicalMargin(aFrame->GetWritingMode()); + } + mValue = SizeComputationInput::DisplayInitOffsetsEnter( + mFrame, mState, aPercentBasis, aCBWritingMode, + aBorder ? &border : nullptr, aPadding ? &padding : nullptr); +} + +DR_init_offsets_cookie::~DR_init_offsets_cookie() { + MOZ_COUNT_DTOR(DR_init_offsets_cookie); + SizeComputationInput::DisplayInitOffsetsExit(mFrame, mState, mValue); +} + +struct DR_Rule; + +struct DR_FrameTypeInfo { + DR_FrameTypeInfo(LayoutFrameType aFrameType, const char* aFrameNameAbbrev, + const char* aFrameName); + ~DR_FrameTypeInfo(); + + LayoutFrameType mType; + char mNameAbbrev[16]; + char mName[32]; + nsTArray<DR_Rule*> mRules; + + private: + DR_FrameTypeInfo& operator=(const DR_FrameTypeInfo&) = delete; +}; + +struct DR_FrameTreeNode; +struct DR_Rule; + +struct DR_State { + DR_State(); + ~DR_State(); + void Init(); + void AddFrameTypeInfo(LayoutFrameType aFrameType, + const char* aFrameNameAbbrev, const char* aFrameName); + DR_FrameTypeInfo* GetFrameTypeInfo(LayoutFrameType aFrameType); + DR_FrameTypeInfo* GetFrameTypeInfo(char* aFrameName); + void InitFrameTypeTable(); + DR_FrameTreeNode* CreateTreeNode(nsIFrame* aFrame, + const ReflowInput* aReflowInput); + void FindMatchingRule(DR_FrameTreeNode& aNode); + bool RuleMatches(DR_Rule& aRule, DR_FrameTreeNode& aNode); + bool GetToken(FILE* aFile, char* aBuf, size_t aBufSize); + DR_Rule* ParseRule(FILE* aFile); + void ParseRulesFile(); + void AddRule(nsTArray<DR_Rule*>& aRules, DR_Rule& aRule); + bool IsWhiteSpace(int c); + bool GetNumber(char* aBuf, int32_t& aNumber); + void PrettyUC(nscoord aSize, char* aBuf, int aBufSize); + void PrintMargin(const char* tag, const nsMargin* aMargin); + void DisplayFrameTypeInfo(nsIFrame* aFrame, int32_t aIndent); + void DeleteTreeNode(DR_FrameTreeNode& aNode); + + bool mInited; + bool mActive; + int32_t mCount; + int32_t mAssert; + int32_t mIndent; + bool mIndentUndisplayedFrames; + bool mDisplayPixelErrors; + nsTArray<DR_Rule*> mWildRules; + nsTArray<DR_FrameTypeInfo> mFrameTypeTable; + // reflow specific state + nsTArray<DR_FrameTreeNode*> mFrameTreeLeaves; +}; + +static DR_State* DR_state; // the one and only DR_State + +struct DR_RulePart { + explicit DR_RulePart(LayoutFrameType aFrameType) + : mFrameType(aFrameType), mNext(0) {} + + void Destroy(); + + LayoutFrameType mFrameType; + DR_RulePart* mNext; +}; + +void DR_RulePart::Destroy() { + if (mNext) { + mNext->Destroy(); + } + delete this; +} + +struct DR_Rule { + DR_Rule() : mLength(0), mTarget(nullptr), mDisplay(false) { + MOZ_COUNT_CTOR(DR_Rule); + } + ~DR_Rule() { + if (mTarget) mTarget->Destroy(); + MOZ_COUNT_DTOR(DR_Rule); + } + void AddPart(LayoutFrameType aFrameType); + + uint32_t mLength; + DR_RulePart* mTarget; + bool mDisplay; +}; + +void DR_Rule::AddPart(LayoutFrameType aFrameType) { + DR_RulePart* newPart = new DR_RulePart(aFrameType); + newPart->mNext = mTarget; + mTarget = newPart; + mLength++; +} + +DR_FrameTypeInfo::~DR_FrameTypeInfo() { + int32_t numElements; + numElements = mRules.Length(); + for (int32_t i = numElements - 1; i >= 0; i--) { + delete mRules.ElementAt(i); + } +} + +DR_FrameTypeInfo::DR_FrameTypeInfo(LayoutFrameType aFrameType, + const char* aFrameNameAbbrev, + const char* aFrameName) { + mType = aFrameType; + PL_strncpyz(mNameAbbrev, aFrameNameAbbrev, sizeof(mNameAbbrev)); + PL_strncpyz(mName, aFrameName, sizeof(mName)); +} + +struct DR_FrameTreeNode { + DR_FrameTreeNode(nsIFrame* aFrame, DR_FrameTreeNode* aParent) + : mFrame(aFrame), mParent(aParent), mDisplay(0), mIndent(0) { + MOZ_COUNT_CTOR(DR_FrameTreeNode); + } + + MOZ_COUNTED_DTOR(DR_FrameTreeNode) + + nsIFrame* mFrame; + DR_FrameTreeNode* mParent; + bool mDisplay; + uint32_t mIndent; +}; + +// DR_State implementation + +DR_State::DR_State() + : mInited(false), + mActive(false), + mCount(0), + mAssert(-1), + mIndent(0), + mIndentUndisplayedFrames(false), + mDisplayPixelErrors(false) { + MOZ_COUNT_CTOR(DR_State); +} + +void DR_State::Init() { + char* env = PR_GetEnv("GECKO_DISPLAY_REFLOW_ASSERT"); + int32_t num; + if (env) { + if (GetNumber(env, num)) + mAssert = num; + else + printf("GECKO_DISPLAY_REFLOW_ASSERT - invalid value = %s", env); + } + + env = PR_GetEnv("GECKO_DISPLAY_REFLOW_INDENT_START"); + if (env) { + if (GetNumber(env, num)) + mIndent = num; + else + printf("GECKO_DISPLAY_REFLOW_INDENT_START - invalid value = %s", env); + } + + env = PR_GetEnv("GECKO_DISPLAY_REFLOW_INDENT_UNDISPLAYED_FRAMES"); + if (env) { + if (GetNumber(env, num)) + mIndentUndisplayedFrames = num; + else + printf( + "GECKO_DISPLAY_REFLOW_INDENT_UNDISPLAYED_FRAMES - invalid value = %s", + env); + } + + env = PR_GetEnv("GECKO_DISPLAY_REFLOW_FLAG_PIXEL_ERRORS"); + if (env) { + if (GetNumber(env, num)) + mDisplayPixelErrors = num; + else + printf("GECKO_DISPLAY_REFLOW_FLAG_PIXEL_ERRORS - invalid value = %s", + env); + } + + InitFrameTypeTable(); + ParseRulesFile(); + mInited = true; +} + +DR_State::~DR_State() { + MOZ_COUNT_DTOR(DR_State); + int32_t numElements, i; + numElements = mWildRules.Length(); + for (i = numElements - 1; i >= 0; i--) { + delete mWildRules.ElementAt(i); + } + numElements = mFrameTreeLeaves.Length(); + for (i = numElements - 1; i >= 0; i--) { + delete mFrameTreeLeaves.ElementAt(i); + } +} + +bool DR_State::GetNumber(char* aBuf, int32_t& aNumber) { + if (sscanf(aBuf, "%d", &aNumber) > 0) + return true; + else + return false; +} + +bool DR_State::IsWhiteSpace(int c) { + return (c == ' ') || (c == '\t') || (c == '\n') || (c == '\r'); +} + +bool DR_State::GetToken(FILE* aFile, char* aBuf, size_t aBufSize) { + bool haveToken = false; + aBuf[0] = 0; + // get the 1st non whitespace char + int c = -1; + for (c = getc(aFile); (c > 0) && IsWhiteSpace(c); c = getc(aFile)) { + } + + if (c > 0) { + haveToken = true; + aBuf[0] = c; + // get everything up to the next whitespace char + size_t cX; + for (cX = 1; cX + 1 < aBufSize; cX++) { + c = getc(aFile); + if (c < 0) { // EOF + ungetc(' ', aFile); + break; + } else { + if (IsWhiteSpace(c)) { + break; + } else { + aBuf[cX] = c; + } + } + } + aBuf[cX] = 0; + } + return haveToken; +} + +DR_Rule* DR_State::ParseRule(FILE* aFile) { + char buf[128]; + int32_t doDisplay; + DR_Rule* rule = nullptr; + while (GetToken(aFile, buf, sizeof(buf))) { + if (GetNumber(buf, doDisplay)) { + if (rule) { + rule->mDisplay = !!doDisplay; + break; + } else { + printf("unexpected token - %s \n", buf); + } + } else { + if (!rule) { + rule = new DR_Rule; + } + if (strcmp(buf, "*") == 0) { + rule->AddPart(LayoutFrameType::None); + } else { + DR_FrameTypeInfo* info = GetFrameTypeInfo(buf); + if (info) { + rule->AddPart(info->mType); + } else { + printf("invalid frame type - %s \n", buf); + } + } + } + } + return rule; +} + +void DR_State::AddRule(nsTArray<DR_Rule*>& aRules, DR_Rule& aRule) { + int32_t numRules = aRules.Length(); + for (int32_t ruleX = 0; ruleX < numRules; ruleX++) { + DR_Rule* rule = aRules.ElementAt(ruleX); + NS_ASSERTION(rule, "program error"); + if (aRule.mLength > rule->mLength) { + aRules.InsertElementAt(ruleX, &aRule); + return; + } + } + aRules.AppendElement(&aRule); +} + +static Maybe<bool> ShouldLogReflow(const char* processes) { + switch (processes[0]) { + case 'A': + case 'a': + return Some(true); + case 'P': + case 'p': + return Some(XRE_IsParentProcess()); + case 'C': + case 'c': + return Some(XRE_IsContentProcess()); + default: + return Nothing{}; + } +} + +void DR_State::ParseRulesFile() { + char* processes = PR_GetEnv("GECKO_DISPLAY_REFLOW_PROCESSES"); + if (processes) { + Maybe<bool> enableLog = ShouldLogReflow(processes); + if (enableLog.isNothing()) { + MOZ_CRASH("GECKO_DISPLAY_REFLOW_PROCESSES: [a]ll [p]arent [c]ontent"); + } else if (enableLog.value()) { + DR_Rule* rule = new DR_Rule; + rule->AddPart(LayoutFrameType::None); + rule->mDisplay = true; + AddRule(mWildRules, *rule); + mActive = true; + } + return; + } + + char* path = PR_GetEnv("GECKO_DISPLAY_REFLOW_RULES_FILE"); + if (path) { + FILE* inFile = fopen(path, "r"); + if (!inFile) { + MOZ_CRASH( + "Failed to open the specified rules file; Try `--setpref " + "security.sandbox.content.level=2` if the sandbox is at cause"); + } + for (DR_Rule* rule = ParseRule(inFile); rule; rule = ParseRule(inFile)) { + if (rule->mTarget) { + LayoutFrameType fType = rule->mTarget->mFrameType; + if (fType != LayoutFrameType::None) { + DR_FrameTypeInfo* info = GetFrameTypeInfo(fType); + AddRule(info->mRules, *rule); + } else { + AddRule(mWildRules, *rule); + } + mActive = true; + } + } + + fclose(inFile); + } +} + +void DR_State::AddFrameTypeInfo(LayoutFrameType aFrameType, + const char* aFrameNameAbbrev, + const char* aFrameName) { + mFrameTypeTable.EmplaceBack(aFrameType, aFrameNameAbbrev, aFrameName); +} + +DR_FrameTypeInfo* DR_State::GetFrameTypeInfo(LayoutFrameType aFrameType) { + int32_t numEntries = mFrameTypeTable.Length(); + NS_ASSERTION(numEntries != 0, "empty FrameTypeTable"); + for (int32_t i = 0; i < numEntries; i++) { + DR_FrameTypeInfo& info = mFrameTypeTable.ElementAt(i); + if (info.mType == aFrameType) { + return &info; + } + } + return &mFrameTypeTable.ElementAt(numEntries - + 1); // return unknown frame type +} + +DR_FrameTypeInfo* DR_State::GetFrameTypeInfo(char* aFrameName) { + int32_t numEntries = mFrameTypeTable.Length(); + NS_ASSERTION(numEntries != 0, "empty FrameTypeTable"); + for (int32_t i = 0; i < numEntries; i++) { + DR_FrameTypeInfo& info = mFrameTypeTable.ElementAt(i); + if ((strcmp(aFrameName, info.mName) == 0) || + (strcmp(aFrameName, info.mNameAbbrev) == 0)) { + return &info; + } + } + return &mFrameTypeTable.ElementAt(numEntries - + 1); // return unknown frame type +} + +void DR_State::InitFrameTypeTable() { + AddFrameTypeInfo(LayoutFrameType::Block, "block", "block"); + AddFrameTypeInfo(LayoutFrameType::Br, "br", "br"); + AddFrameTypeInfo(LayoutFrameType::ColorControl, "color", "colorControl"); + AddFrameTypeInfo(LayoutFrameType::GfxButtonControl, "button", + "gfxButtonControl"); + AddFrameTypeInfo(LayoutFrameType::HTMLButtonControl, "HTMLbutton", + "HTMLButtonControl"); + AddFrameTypeInfo(LayoutFrameType::HTMLCanvas, "HTMLCanvas", "HTMLCanvas"); + AddFrameTypeInfo(LayoutFrameType::SubDocument, "subdoc", "subDocument"); + AddFrameTypeInfo(LayoutFrameType::Image, "img", "image"); + AddFrameTypeInfo(LayoutFrameType::Inline, "inline", "inline"); + AddFrameTypeInfo(LayoutFrameType::Letter, "letter", "letter"); + AddFrameTypeInfo(LayoutFrameType::Line, "line", "line"); + AddFrameTypeInfo(LayoutFrameType::ListControl, "select", "select"); + AddFrameTypeInfo(LayoutFrameType::Page, "page", "page"); + AddFrameTypeInfo(LayoutFrameType::Placeholder, "place", "placeholder"); + AddFrameTypeInfo(LayoutFrameType::Canvas, "canvas", "canvas"); + AddFrameTypeInfo(LayoutFrameType::Scroll, "scroll", "scroll"); + AddFrameTypeInfo(LayoutFrameType::TableCell, "cell", "tableCell"); + AddFrameTypeInfo(LayoutFrameType::TableCol, "col", "tableCol"); + AddFrameTypeInfo(LayoutFrameType::TableColGroup, "colG", "tableColGroup"); + AddFrameTypeInfo(LayoutFrameType::Table, "tbl", "table"); + AddFrameTypeInfo(LayoutFrameType::TableWrapper, "tblW", "tableWrapper"); + AddFrameTypeInfo(LayoutFrameType::TableRowGroup, "rowG", "tableRowGroup"); + AddFrameTypeInfo(LayoutFrameType::TableRow, "row", "tableRow"); + AddFrameTypeInfo(LayoutFrameType::TextInput, "textCtl", "textInput"); + AddFrameTypeInfo(LayoutFrameType::Text, "text", "text"); + AddFrameTypeInfo(LayoutFrameType::Viewport, "VP", "viewport"); + AddFrameTypeInfo(LayoutFrameType::Slider, "Slider", "Slider"); + AddFrameTypeInfo(LayoutFrameType::None, "unknown", "unknown"); +} + +void DR_State::DisplayFrameTypeInfo(nsIFrame* aFrame, int32_t aIndent) { + DR_FrameTypeInfo* frameTypeInfo = GetFrameTypeInfo(aFrame->Type()); + if (frameTypeInfo) { + for (int32_t i = 0; i < aIndent; i++) { + printf(" "); + } + if (!strcmp(frameTypeInfo->mNameAbbrev, "unknown")) { + if (aFrame) { + nsAutoString name; + aFrame->GetFrameName(name); + printf("%s %p ", NS_LossyConvertUTF16toASCII(name).get(), + (void*)aFrame); + } else { + printf("%s %p ", frameTypeInfo->mNameAbbrev, (void*)aFrame); + } + } else { + printf("%s %p ", frameTypeInfo->mNameAbbrev, (void*)aFrame); + } + } +} + +bool DR_State::RuleMatches(DR_Rule& aRule, DR_FrameTreeNode& aNode) { + NS_ASSERTION(aRule.mTarget, "program error"); + + DR_RulePart* rulePart; + DR_FrameTreeNode* parentNode; + for (rulePart = aRule.mTarget->mNext, parentNode = aNode.mParent; + rulePart && parentNode; + rulePart = rulePart->mNext, parentNode = parentNode->mParent) { + if (rulePart->mFrameType != LayoutFrameType::None) { + if (parentNode->mFrame) { + if (rulePart->mFrameType != parentNode->mFrame->Type()) { + return false; + } + } else + NS_ASSERTION(false, "program error"); + } + // else wild card match + } + return true; +} + +void DR_State::FindMatchingRule(DR_FrameTreeNode& aNode) { + if (!aNode.mFrame) { + NS_ASSERTION(false, "invalid DR_FrameTreeNode \n"); + return; + } + + bool matchingRule = false; + + DR_FrameTypeInfo* info = GetFrameTypeInfo(aNode.mFrame->Type()); + NS_ASSERTION(info, "program error"); + int32_t numRules = info->mRules.Length(); + for (int32_t ruleX = 0; ruleX < numRules; ruleX++) { + DR_Rule* rule = info->mRules.ElementAt(ruleX); + if (rule && RuleMatches(*rule, aNode)) { + aNode.mDisplay = rule->mDisplay; + matchingRule = true; + break; + } + } + if (!matchingRule) { + int32_t numWildRules = mWildRules.Length(); + for (int32_t ruleX = 0; ruleX < numWildRules; ruleX++) { + DR_Rule* rule = mWildRules.ElementAt(ruleX); + if (rule && RuleMatches(*rule, aNode)) { + aNode.mDisplay = rule->mDisplay; + break; + } + } + } +} + +DR_FrameTreeNode* DR_State::CreateTreeNode(nsIFrame* aFrame, + const ReflowInput* aReflowInput) { + // find the frame of the parent reflow input (usually just the parent of + // aFrame) + nsIFrame* parentFrame; + if (aReflowInput) { + const ReflowInput* parentRI = aReflowInput->mParentReflowInput; + parentFrame = (parentRI) ? parentRI->mFrame : nullptr; + } else { + parentFrame = aFrame->GetParent(); + } + + // find the parent tree node leaf + DR_FrameTreeNode* parentNode = nullptr; + + DR_FrameTreeNode* lastLeaf = nullptr; + if (mFrameTreeLeaves.Length()) + lastLeaf = mFrameTreeLeaves.ElementAt(mFrameTreeLeaves.Length() - 1); + if (lastLeaf) { + for (parentNode = lastLeaf; + parentNode && (parentNode->mFrame != parentFrame); + parentNode = parentNode->mParent) { + } + } + DR_FrameTreeNode* newNode = new DR_FrameTreeNode(aFrame, parentNode); + FindMatchingRule(*newNode); + + newNode->mIndent = mIndent; + if (newNode->mDisplay || mIndentUndisplayedFrames) { + ++mIndent; + } + + if (lastLeaf && (lastLeaf == parentNode)) { + mFrameTreeLeaves.RemoveLastElement(); + } + mFrameTreeLeaves.AppendElement(newNode); + mCount++; + + return newNode; +} + +void DR_State::PrettyUC(nscoord aSize, char* aBuf, int aBufSize) { + if (NS_UNCONSTRAINEDSIZE == aSize) { + strcpy(aBuf, "UC"); + } else { + if ((nscoord)0xdeadbeefU == aSize) { + strcpy(aBuf, "deadbeef"); + } else { + snprintf(aBuf, aBufSize, "%d", aSize); + } + } +} + +void DR_State::PrintMargin(const char* tag, const nsMargin* aMargin) { + if (aMargin) { + char t[16], r[16], b[16], l[16]; + PrettyUC(aMargin->top, t, 16); + PrettyUC(aMargin->right, r, 16); + PrettyUC(aMargin->bottom, b, 16); + PrettyUC(aMargin->left, l, 16); + printf(" %s=%s,%s,%s,%s", tag, t, r, b, l); + } else { + // use %p here for consistency with other null-pointer printouts + printf(" %s=%p", tag, (void*)aMargin); + } +} + +void DR_State::DeleteTreeNode(DR_FrameTreeNode& aNode) { + mFrameTreeLeaves.RemoveElement(&aNode); + int32_t numLeaves = mFrameTreeLeaves.Length(); + if ((0 == numLeaves) || + (aNode.mParent != mFrameTreeLeaves.ElementAt(numLeaves - 1))) { + mFrameTreeLeaves.AppendElement(aNode.mParent); + } + + if (aNode.mDisplay || mIndentUndisplayedFrames) { + --mIndent; + } + // delete the tree node + delete &aNode; +} + +static void CheckPixelError(nscoord aSize, int32_t aPixelToTwips) { + if (NS_UNCONSTRAINEDSIZE != aSize) { + if ((aSize % aPixelToTwips) > 0) { + printf("VALUE %d is not a whole pixel \n", aSize); + } + } +} + +static void DisplayReflowEnterPrint(nsPresContext* aPresContext, + nsIFrame* aFrame, + const ReflowInput& aReflowInput, + DR_FrameTreeNode& aTreeNode, + bool aChanged) { + if (aTreeNode.mDisplay) { + DR_state->DisplayFrameTypeInfo(aFrame, aTreeNode.mIndent); + + char width[16]; + char height[16]; + + DR_state->PrettyUC(aReflowInput.AvailableWidth(), width, 16); + DR_state->PrettyUC(aReflowInput.AvailableHeight(), height, 16); + printf("Reflow a=%s,%s ", width, height); + + DR_state->PrettyUC(aReflowInput.ComputedWidth(), width, 16); + DR_state->PrettyUC(aReflowInput.ComputedHeight(), height, 16); + printf("c=%s,%s ", width, height); + + if (aFrame->HasAnyStateBits(NS_FRAME_IS_DIRTY)) printf("dirty "); + + if (aFrame->HasAnyStateBits(NS_FRAME_HAS_DIRTY_CHILDREN)) + printf("dirty-children "); + + if (aReflowInput.mFlags.mSpecialBSizeReflow) printf("special-bsize "); + + if (aReflowInput.IsHResize()) printf("h-resize "); + + if (aReflowInput.IsVResize()) printf("v-resize "); + + nsIFrame* inFlow = aFrame->GetPrevInFlow(); + if (inFlow) { + printf("pif=%p ", (void*)inFlow); + } + inFlow = aFrame->GetNextInFlow(); + if (inFlow) { + printf("nif=%p ", (void*)inFlow); + } + if (aChanged) + printf("CHANGED \n"); + else + printf("cnt=%d \n", DR_state->mCount); + if (DR_state->mDisplayPixelErrors) { + int32_t d2a = aPresContext->AppUnitsPerDevPixel(); + CheckPixelError(aReflowInput.AvailableWidth(), d2a); + CheckPixelError(aReflowInput.AvailableHeight(), d2a); + CheckPixelError(aReflowInput.ComputedWidth(), d2a); + CheckPixelError(aReflowInput.ComputedHeight(), d2a); + } + } +} + +void* nsIFrame::DisplayReflowEnter(nsPresContext* aPresContext, + nsIFrame* aFrame, + const ReflowInput& aReflowInput) { + if (!DR_state->mInited) DR_state->Init(); + if (!DR_state->mActive) return nullptr; + + NS_ASSERTION(aFrame, "invalid call"); + + DR_FrameTreeNode* treeNode = DR_state->CreateTreeNode(aFrame, &aReflowInput); + if (treeNode) { + DisplayReflowEnterPrint(aPresContext, aFrame, aReflowInput, *treeNode, + false); + } + return treeNode; +} + +void* nsIFrame::DisplayLayoutEnter(nsIFrame* aFrame) { + if (!DR_state->mInited) DR_state->Init(); + if (!DR_state->mActive) return nullptr; + + NS_ASSERTION(aFrame, "invalid call"); + + DR_FrameTreeNode* treeNode = DR_state->CreateTreeNode(aFrame, nullptr); + if (treeNode && treeNode->mDisplay) { + DR_state->DisplayFrameTypeInfo(aFrame, treeNode->mIndent); + printf("XULLayout\n"); + } + return treeNode; +} + +void* nsIFrame::DisplayIntrinsicISizeEnter(nsIFrame* aFrame, + const char* aType) { + if (!DR_state->mInited) DR_state->Init(); + if (!DR_state->mActive) return nullptr; + + NS_ASSERTION(aFrame, "invalid call"); + + DR_FrameTreeNode* treeNode = DR_state->CreateTreeNode(aFrame, nullptr); + if (treeNode && treeNode->mDisplay) { + DR_state->DisplayFrameTypeInfo(aFrame, treeNode->mIndent); + printf("Get%sISize\n", aType); + } + return treeNode; +} + +void* nsIFrame::DisplayIntrinsicSizeEnter(nsIFrame* aFrame, const char* aType) { + if (!DR_state->mInited) DR_state->Init(); + if (!DR_state->mActive) return nullptr; + + NS_ASSERTION(aFrame, "invalid call"); + + DR_FrameTreeNode* treeNode = DR_state->CreateTreeNode(aFrame, nullptr); + if (treeNode && treeNode->mDisplay) { + DR_state->DisplayFrameTypeInfo(aFrame, treeNode->mIndent); + printf("Get%sSize\n", aType); + } + return treeNode; +} + +void nsIFrame::DisplayReflowExit(nsPresContext* aPresContext, nsIFrame* aFrame, + ReflowOutput& aMetrics, + const nsReflowStatus& aStatus, + void* aFrameTreeNode) { + if (!DR_state->mActive) return; + + NS_ASSERTION(aFrame, "DisplayReflowExit - invalid call"); + if (!aFrameTreeNode) return; + + DR_FrameTreeNode* treeNode = (DR_FrameTreeNode*)aFrameTreeNode; + if (treeNode->mDisplay) { + DR_state->DisplayFrameTypeInfo(aFrame, treeNode->mIndent); + + char width[16]; + char height[16]; + char x[16]; + char y[16]; + DR_state->PrettyUC(aMetrics.Width(), width, 16); + DR_state->PrettyUC(aMetrics.Height(), height, 16); + printf("Reflow d=%s,%s", width, height); + + if (!aStatus.IsEmpty()) { + printf(" status=%s", ToString(aStatus).c_str()); + } + if (aFrame->HasOverflowAreas()) { + DR_state->PrettyUC(aMetrics.InkOverflow().x, x, 16); + DR_state->PrettyUC(aMetrics.InkOverflow().y, y, 16); + DR_state->PrettyUC(aMetrics.InkOverflow().width, width, 16); + DR_state->PrettyUC(aMetrics.InkOverflow().height, height, 16); + printf(" vis-o=(%s,%s) %s x %s", x, y, width, height); + + nsRect storedOverflow = aFrame->InkOverflowRect(); + DR_state->PrettyUC(storedOverflow.x, x, 16); + DR_state->PrettyUC(storedOverflow.y, y, 16); + DR_state->PrettyUC(storedOverflow.width, width, 16); + DR_state->PrettyUC(storedOverflow.height, height, 16); + printf(" vis-sto=(%s,%s) %s x %s", x, y, width, height); + + DR_state->PrettyUC(aMetrics.ScrollableOverflow().x, x, 16); + DR_state->PrettyUC(aMetrics.ScrollableOverflow().y, y, 16); + DR_state->PrettyUC(aMetrics.ScrollableOverflow().width, width, 16); + DR_state->PrettyUC(aMetrics.ScrollableOverflow().height, height, 16); + printf(" scr-o=(%s,%s) %s x %s", x, y, width, height); + + storedOverflow = aFrame->ScrollableOverflowRect(); + DR_state->PrettyUC(storedOverflow.x, x, 16); + DR_state->PrettyUC(storedOverflow.y, y, 16); + DR_state->PrettyUC(storedOverflow.width, width, 16); + DR_state->PrettyUC(storedOverflow.height, height, 16); + printf(" scr-sto=(%s,%s) %s x %s", x, y, width, height); + } + printf("\n"); + if (DR_state->mDisplayPixelErrors) { + int32_t d2a = aPresContext->AppUnitsPerDevPixel(); + CheckPixelError(aMetrics.Width(), d2a); + CheckPixelError(aMetrics.Height(), d2a); + } + } + DR_state->DeleteTreeNode(*treeNode); +} + +void nsIFrame::DisplayLayoutExit(nsIFrame* aFrame, void* aFrameTreeNode) { + if (!DR_state->mActive) return; + + NS_ASSERTION(aFrame, "non-null frame required"); + if (!aFrameTreeNode) return; + + DR_FrameTreeNode* treeNode = (DR_FrameTreeNode*)aFrameTreeNode; + if (treeNode->mDisplay) { + DR_state->DisplayFrameTypeInfo(aFrame, treeNode->mIndent); + nsRect rect = aFrame->GetRect(); + printf("XULLayout=%d,%d,%d,%d\n", rect.x, rect.y, rect.width, rect.height); + } + DR_state->DeleteTreeNode(*treeNode); +} + +void nsIFrame::DisplayIntrinsicISizeExit(nsIFrame* aFrame, const char* aType, + nscoord aResult, + void* aFrameTreeNode) { + if (!DR_state->mActive) return; + + NS_ASSERTION(aFrame, "non-null frame required"); + if (!aFrameTreeNode) return; + + DR_FrameTreeNode* treeNode = (DR_FrameTreeNode*)aFrameTreeNode; + if (treeNode->mDisplay) { + DR_state->DisplayFrameTypeInfo(aFrame, treeNode->mIndent); + char iSize[16]; + DR_state->PrettyUC(aResult, iSize, 16); + printf("Get%sISize=%s\n", aType, iSize); + } + DR_state->DeleteTreeNode(*treeNode); +} + +void nsIFrame::DisplayIntrinsicSizeExit(nsIFrame* aFrame, const char* aType, + nsSize aResult, void* aFrameTreeNode) { + if (!DR_state->mActive) return; + + NS_ASSERTION(aFrame, "non-null frame required"); + if (!aFrameTreeNode) return; + + DR_FrameTreeNode* treeNode = (DR_FrameTreeNode*)aFrameTreeNode; + if (treeNode->mDisplay) { + DR_state->DisplayFrameTypeInfo(aFrame, treeNode->mIndent); + + char width[16]; + char height[16]; + DR_state->PrettyUC(aResult.width, width, 16); + DR_state->PrettyUC(aResult.height, height, 16); + printf("Get%sSize=%s,%s\n", aType, width, height); + } + DR_state->DeleteTreeNode(*treeNode); +} + +/* static */ +void nsIFrame::DisplayReflowStartup() { DR_state = new DR_State(); } + +/* static */ +void nsIFrame::DisplayReflowShutdown() { + delete DR_state; + DR_state = nullptr; +} + +void DR_cookie::Change() const { + DR_FrameTreeNode* treeNode = (DR_FrameTreeNode*)mValue; + if (treeNode && treeNode->mDisplay) { + DisplayReflowEnterPrint(mPresContext, mFrame, mReflowInput, *treeNode, + true); + } +} + +/* static */ +void* ReflowInput::DisplayInitConstraintsEnter(nsIFrame* aFrame, + ReflowInput* aState, + nscoord aContainingBlockWidth, + nscoord aContainingBlockHeight, + const nsMargin* aBorder, + const nsMargin* aPadding) { + MOZ_ASSERT(aFrame, "non-null frame required"); + MOZ_ASSERT(aState, "non-null state required"); + + if (!DR_state->mInited) DR_state->Init(); + if (!DR_state->mActive) return nullptr; + + DR_FrameTreeNode* treeNode = DR_state->CreateTreeNode(aFrame, aState); + if (treeNode && treeNode->mDisplay) { + DR_state->DisplayFrameTypeInfo(aFrame, treeNode->mIndent); + + printf("InitConstraints parent=%p", (void*)aState->mParentReflowInput); + + char width[16]; + char height[16]; + + DR_state->PrettyUC(aContainingBlockWidth, width, 16); + DR_state->PrettyUC(aContainingBlockHeight, height, 16); + printf(" cb=%s,%s", width, height); + + DR_state->PrettyUC(aState->AvailableWidth(), width, 16); + DR_state->PrettyUC(aState->AvailableHeight(), height, 16); + printf(" as=%s,%s", width, height); + + DR_state->PrintMargin("b", aBorder); + DR_state->PrintMargin("p", aPadding); + putchar('\n'); + } + return treeNode; +} + +/* static */ +void ReflowInput::DisplayInitConstraintsExit(nsIFrame* aFrame, + ReflowInput* aState, + void* aValue) { + MOZ_ASSERT(aFrame, "non-null frame required"); + MOZ_ASSERT(aState, "non-null state required"); + + if (!DR_state->mActive) return; + if (!aValue) return; + + DR_FrameTreeNode* treeNode = (DR_FrameTreeNode*)aValue; + if (treeNode->mDisplay) { + DR_state->DisplayFrameTypeInfo(aFrame, treeNode->mIndent); + char cmiw[16], cw[16], cmxw[16], cmih[16], ch[16], cmxh[16]; + DR_state->PrettyUC(aState->ComputedMinWidth(), cmiw, 16); + DR_state->PrettyUC(aState->ComputedWidth(), cw, 16); + DR_state->PrettyUC(aState->ComputedMaxWidth(), cmxw, 16); + DR_state->PrettyUC(aState->ComputedMinHeight(), cmih, 16); + DR_state->PrettyUC(aState->ComputedHeight(), ch, 16); + DR_state->PrettyUC(aState->ComputedMaxHeight(), cmxh, 16); + printf("InitConstraints= cw=(%s <= %s <= %s) ch=(%s <= %s <= %s)", cmiw, cw, + cmxw, cmih, ch, cmxh); + const nsMargin m = aState->ComputedPhysicalOffsets(); + DR_state->PrintMargin("co", &m); + putchar('\n'); + } + DR_state->DeleteTreeNode(*treeNode); +} + +/* static */ +void* SizeComputationInput::DisplayInitOffsetsEnter( + nsIFrame* aFrame, SizeComputationInput* aState, nscoord aPercentBasis, + WritingMode aCBWritingMode, const nsMargin* aBorder, + const nsMargin* aPadding) { + MOZ_ASSERT(aFrame, "non-null frame required"); + MOZ_ASSERT(aState, "non-null state required"); + + if (!DR_state->mInited) DR_state->Init(); + if (!DR_state->mActive) return nullptr; + + // aState is not necessarily a ReflowInput + DR_FrameTreeNode* treeNode = DR_state->CreateTreeNode(aFrame, nullptr); + if (treeNode && treeNode->mDisplay) { + DR_state->DisplayFrameTypeInfo(aFrame, treeNode->mIndent); + + char pctBasisStr[16]; + DR_state->PrettyUC(aPercentBasis, pctBasisStr, 16); + printf("InitOffsets pct_basis=%s", pctBasisStr); + + DR_state->PrintMargin("b", aBorder); + DR_state->PrintMargin("p", aPadding); + putchar('\n'); + } + return treeNode; +} + +/* static */ +void SizeComputationInput::DisplayInitOffsetsExit(nsIFrame* aFrame, + SizeComputationInput* aState, + void* aValue) { + MOZ_ASSERT(aFrame, "non-null frame required"); + MOZ_ASSERT(aState, "non-null state required"); + + if (!DR_state->mActive) return; + if (!aValue) return; + + DR_FrameTreeNode* treeNode = (DR_FrameTreeNode*)aValue; + if (treeNode->mDisplay) { + DR_state->DisplayFrameTypeInfo(aFrame, treeNode->mIndent); + printf("InitOffsets="); + const auto m = aState->ComputedPhysicalMargin(); + DR_state->PrintMargin("m", &m); + const auto p = aState->ComputedPhysicalPadding(); + DR_state->PrintMargin("p", &p); + const auto bp = aState->ComputedPhysicalBorderPadding(); + DR_state->PrintMargin("b+p", &bp); + putchar('\n'); + } + DR_state->DeleteTreeNode(*treeNode); +} + +// End Display Reflow + +// Validation of SideIsVertical. +# define CASE(side, result) \ + static_assert(SideIsVertical(side) == result, "SideIsVertical is wrong") +CASE(eSideTop, false); +CASE(eSideRight, true); +CASE(eSideBottom, false); +CASE(eSideLeft, true); +# undef CASE + +// Validation of HalfCornerIsX. +# define CASE(corner, result) \ + static_assert(HalfCornerIsX(corner) == result, "HalfCornerIsX is wrong") +CASE(eCornerTopLeftX, true); +CASE(eCornerTopLeftY, false); +CASE(eCornerTopRightX, true); +CASE(eCornerTopRightY, false); +CASE(eCornerBottomRightX, true); +CASE(eCornerBottomRightY, false); +CASE(eCornerBottomLeftX, true); +CASE(eCornerBottomLeftY, false); +# undef CASE + +// Validation of HalfToFullCorner. +# define CASE(corner, result) \ + static_assert(HalfToFullCorner(corner) == result, \ + "HalfToFullCorner is " \ + "wrong") +CASE(eCornerTopLeftX, eCornerTopLeft); +CASE(eCornerTopLeftY, eCornerTopLeft); +CASE(eCornerTopRightX, eCornerTopRight); +CASE(eCornerTopRightY, eCornerTopRight); +CASE(eCornerBottomRightX, eCornerBottomRight); +CASE(eCornerBottomRightY, eCornerBottomRight); +CASE(eCornerBottomLeftX, eCornerBottomLeft); +CASE(eCornerBottomLeftY, eCornerBottomLeft); +# undef CASE + +// Validation of FullToHalfCorner. +# define CASE(corner, vert, result) \ + static_assert(FullToHalfCorner(corner, vert) == result, \ + "FullToHalfCorner is wrong") +CASE(eCornerTopLeft, false, eCornerTopLeftX); +CASE(eCornerTopLeft, true, eCornerTopLeftY); +CASE(eCornerTopRight, false, eCornerTopRightX); +CASE(eCornerTopRight, true, eCornerTopRightY); +CASE(eCornerBottomRight, false, eCornerBottomRightX); +CASE(eCornerBottomRight, true, eCornerBottomRightY); +CASE(eCornerBottomLeft, false, eCornerBottomLeftX); +CASE(eCornerBottomLeft, true, eCornerBottomLeftY); +# undef CASE + +// Validation of SideToFullCorner. +# define CASE(side, second, result) \ + static_assert(SideToFullCorner(side, second) == result, \ + "SideToFullCorner is wrong") +CASE(eSideTop, false, eCornerTopLeft); +CASE(eSideTop, true, eCornerTopRight); + +CASE(eSideRight, false, eCornerTopRight); +CASE(eSideRight, true, eCornerBottomRight); + +CASE(eSideBottom, false, eCornerBottomRight); +CASE(eSideBottom, true, eCornerBottomLeft); + +CASE(eSideLeft, false, eCornerBottomLeft); +CASE(eSideLeft, true, eCornerTopLeft); +# undef CASE + +// Validation of SideToHalfCorner. +# define CASE(side, second, parallel, result) \ + static_assert(SideToHalfCorner(side, second, parallel) == result, \ + "SideToHalfCorner is wrong") +CASE(eSideTop, false, true, eCornerTopLeftX); +CASE(eSideTop, false, false, eCornerTopLeftY); +CASE(eSideTop, true, true, eCornerTopRightX); +CASE(eSideTop, true, false, eCornerTopRightY); + +CASE(eSideRight, false, false, eCornerTopRightX); +CASE(eSideRight, false, true, eCornerTopRightY); +CASE(eSideRight, true, false, eCornerBottomRightX); +CASE(eSideRight, true, true, eCornerBottomRightY); + +CASE(eSideBottom, false, true, eCornerBottomRightX); +CASE(eSideBottom, false, false, eCornerBottomRightY); +CASE(eSideBottom, true, true, eCornerBottomLeftX); +CASE(eSideBottom, true, false, eCornerBottomLeftY); + +CASE(eSideLeft, false, false, eCornerBottomLeftX); +CASE(eSideLeft, false, true, eCornerBottomLeftY); +CASE(eSideLeft, true, false, eCornerTopLeftX); +CASE(eSideLeft, true, true, eCornerTopLeftY); +# undef CASE + +#endif |