diff options
Diffstat (limited to 'layout/generic/nsGridContainerFrame.h')
| -rw-r--r-- | layout/generic/nsGridContainerFrame.h | 662 |
1 files changed, 662 insertions, 0 deletions
diff --git a/layout/generic/nsGridContainerFrame.h b/layout/generic/nsGridContainerFrame.h new file mode 100644 index 0000000000..d785d65a50 --- /dev/null +++ b/layout/generic/nsGridContainerFrame.h @@ -0,0 +1,662 @@ +/* -*- 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/. */ + +/* rendering object for CSS "display: grid | inline-grid" */ + +#ifndef nsGridContainerFrame_h___ +#define nsGridContainerFrame_h___ + +#include "mozilla/CSSOrderAwareFrameIterator.h" +#include "mozilla/MathAlgorithms.h" +#include "mozilla/Maybe.h" +#include "mozilla/HashTable.h" +#include "nsAtomHashKeys.h" +#include "nsContainerFrame.h" +#include "nsILineIterator.h" + +namespace mozilla { +class PresShell; +namespace dom { +class Grid; +} +} // namespace mozilla + +/** + * Factory function. + * @return a newly allocated nsGridContainerFrame (infallible) + */ +nsContainerFrame* NS_NewGridContainerFrame(mozilla::PresShell* aPresShell, + mozilla::ComputedStyle* aStyle); + +namespace mozilla { + +/** + * The number of implicit / explicit tracks and their sizes. + */ +struct ComputedGridTrackInfo { + ComputedGridTrackInfo( + uint32_t aNumLeadingImplicitTracks, uint32_t aNumExplicitTracks, + uint32_t aStartFragmentTrack, uint32_t aEndFragmentTrack, + nsTArray<nscoord>&& aPositions, nsTArray<nscoord>&& aSizes, + nsTArray<uint32_t>&& aStates, nsTArray<bool>&& aRemovedRepeatTracks, + uint32_t aRepeatFirstTrack, + nsTArray<nsTArray<StyleCustomIdent>>&& aResolvedLineNames, + bool aIsSubgrid, bool aIsMasonry) + : mNumLeadingImplicitTracks(aNumLeadingImplicitTracks), + mNumExplicitTracks(aNumExplicitTracks), + mStartFragmentTrack(aStartFragmentTrack), + mEndFragmentTrack(aEndFragmentTrack), + mPositions(std::move(aPositions)), + mSizes(std::move(aSizes)), + mStates(std::move(aStates)), + mRemovedRepeatTracks(std::move(aRemovedRepeatTracks)), + mResolvedLineNames(std::move(aResolvedLineNames)), + mRepeatFirstTrack(aRepeatFirstTrack), + mIsSubgrid(aIsSubgrid), + mIsMasonry(aIsMasonry) {} + uint32_t mNumLeadingImplicitTracks; + uint32_t mNumExplicitTracks; + uint32_t mStartFragmentTrack; + uint32_t mEndFragmentTrack; + nsTArray<nscoord> mPositions; + nsTArray<nscoord> mSizes; + nsTArray<uint32_t> mStates; + // Indicates if a track has been collapsed. This will be populated for each + // track in the repeat(auto-fit) and repeat(auto-fill), even if there are no + // collapsed tracks. + nsTArray<bool> mRemovedRepeatTracks; + // Contains lists of all line name lists, including the name lists inside + // repeats. When a repeat(auto) track exists, the internal track names will + // appear once each in this array. + nsTArray<nsTArray<StyleCustomIdent>> mResolvedLineNames; + uint32_t mRepeatFirstTrack; + bool mIsSubgrid; + bool mIsMasonry; +}; + +struct ComputedGridLineInfo { + explicit ComputedGridLineInfo( + nsTArray<nsTArray<RefPtr<nsAtom>>>&& aNames, + const nsTArray<RefPtr<nsAtom>>& aNamesBefore, + const nsTArray<RefPtr<nsAtom>>& aNamesAfter, + nsTArray<RefPtr<nsAtom>>&& aNamesFollowingRepeat) + : mNames(std::move(aNames)), + mNamesBefore(aNamesBefore.Clone()), + mNamesAfter(aNamesAfter.Clone()), + mNamesFollowingRepeat(std::move(aNamesFollowingRepeat)) {} + nsTArray<nsTArray<RefPtr<nsAtom>>> mNames; + nsTArray<RefPtr<nsAtom>> mNamesBefore; + nsTArray<RefPtr<nsAtom>> mNamesAfter; + nsTArray<RefPtr<nsAtom>> mNamesFollowingRepeat; +}; +} // namespace mozilla + +class nsGridContainerFrame final : public nsContainerFrame, + public nsILineIterator { + public: + NS_DECL_FRAMEARENA_HELPERS(nsGridContainerFrame) + NS_DECL_QUERYFRAME + using ComputedGridTrackInfo = mozilla::ComputedGridTrackInfo; + using ComputedGridLineInfo = mozilla::ComputedGridLineInfo; + using LogicalAxis = mozilla::LogicalAxis; + using BaselineSharingGroup = mozilla::BaselineSharingGroup; + using NamedArea = mozilla::StyleNamedArea; + + template <typename T> + using PerBaseline = mozilla::EnumeratedArray<BaselineSharingGroup, + BaselineSharingGroup(2), T>; + + template <typename T> + using PerLogicalAxis = + mozilla::EnumeratedArray<LogicalAxis, LogicalAxis(2), T>; + + // nsIFrame overrides + void Reflow(nsPresContext* aPresContext, ReflowOutput& aDesiredSize, + const ReflowInput& aReflowInput, + nsReflowStatus& aStatus) override; + void Init(nsIContent* aContent, nsContainerFrame* aParent, + nsIFrame* aPrevInFlow) override; + void DidSetComputedStyle(ComputedStyle* aOldStyle) override; + nscoord GetMinISize(gfxContext* aRenderingContext) override; + nscoord GetPrefISize(gfxContext* aRenderingContext) override; + void MarkIntrinsicISizesDirty() override; + + void BuildDisplayList(nsDisplayListBuilder* aBuilder, + const nsDisplayListSet& aLists) override; + + Maybe<nscoord> GetNaturalBaselineBOffset( + mozilla::WritingMode aWM, BaselineSharingGroup aBaselineGroup, + BaselineExportContext) const override { + if (StyleDisplay()->IsContainLayout() || + HasAnyStateBits(NS_STATE_GRID_SYNTHESIZE_BASELINE)) { + return Nothing{}; + } + return mozilla::Some(GetBBaseline(aBaselineGroup)); + } + +#ifdef DEBUG_FRAME_DUMP + nsresult GetFrameName(nsAString& aResult) const override; + void ExtraContainerFrameInfo(nsACString& aTo) const override; +#endif + + // nsContainerFrame overrides + bool DrainSelfOverflowList() override; + void AppendFrames(ChildListID aListID, nsFrameList&& aFrameList) override; + void InsertFrames(ChildListID aListID, nsIFrame* aPrevFrame, + const nsLineList::iterator* aPrevFrameLine, + nsFrameList&& aFrameList) override; + void RemoveFrame(DestroyContext&, ChildListID, nsIFrame*) override; + mozilla::StyleAlignFlags CSSAlignmentForAbsPosChild( + const ReflowInput& aChildRI, LogicalAxis aLogicalAxis) const override; + +#ifdef DEBUG + void SetInitialChildList(ChildListID aListID, + nsFrameList&& aChildList) override; +#endif + + /** + * Return the containing block for aChild which MUST be an abs.pos. child + * of a grid container and that container must have been reflowed. + */ + static const nsRect& GridItemCB(nsIFrame* aChild); + + NS_DECLARE_FRAME_PROPERTY_DELETABLE(GridItemContainingBlockRect, nsRect) + + /** + * These properties are created by a call to + * nsGridContainerFrame::GetGridFrameWithComputedInfo, typically from + * Element::GetGridFragments. + */ + NS_DECLARE_FRAME_PROPERTY_DELETABLE(GridColTrackInfo, ComputedGridTrackInfo) + const ComputedGridTrackInfo* GetComputedTemplateColumns() { + const ComputedGridTrackInfo* info = GetProperty(GridColTrackInfo()); + MOZ_ASSERT(info, "Property generation wasn't requested."); + return info; + } + + NS_DECLARE_FRAME_PROPERTY_DELETABLE(GridRowTrackInfo, ComputedGridTrackInfo) + const ComputedGridTrackInfo* GetComputedTemplateRows() { + const ComputedGridTrackInfo* info = GetProperty(GridRowTrackInfo()); + MOZ_ASSERT(info, "Property generation wasn't requested."); + return info; + } + + NS_DECLARE_FRAME_PROPERTY_DELETABLE(GridColumnLineInfo, ComputedGridLineInfo) + const ComputedGridLineInfo* GetComputedTemplateColumnLines() { + const ComputedGridLineInfo* info = GetProperty(GridColumnLineInfo()); + MOZ_ASSERT(info, "Property generation wasn't requested."); + return info; + } + + NS_DECLARE_FRAME_PROPERTY_DELETABLE(GridRowLineInfo, ComputedGridLineInfo) + const ComputedGridLineInfo* GetComputedTemplateRowLines() { + const ComputedGridLineInfo* info = GetProperty(GridRowLineInfo()); + MOZ_ASSERT(info, "Property generation wasn't requested."); + return info; + } + + /** + * This property is set by the creation of a dom::Grid object, and cleared + * during GC unlink. Since the Grid object manages the lifecycle, the property + * itself is set without a destructor. The property is also cleared whenever + * new grid computed info is generated during reflow, ensuring that we aren't + * holding a stale dom::Grid object. + */ + NS_DECLARE_FRAME_PROPERTY_WITHOUT_DTOR(GridFragmentInfo, mozilla::dom::Grid) + mozilla::dom::Grid* GetGridFragmentInfo() { + return GetProperty(GridFragmentInfo()); + } + + using ImplicitNamedAreas = + mozilla::HashMap<mozilla::AtomHashKey, NamedArea, mozilla::AtomHashKey>; + NS_DECLARE_FRAME_PROPERTY_DELETABLE(ImplicitNamedAreasProperty, + ImplicitNamedAreas) + ImplicitNamedAreas* GetImplicitNamedAreas() const { + return GetProperty(ImplicitNamedAreasProperty()); + } + + using ExplicitNamedAreas = mozilla::StyleOwnedSlice<NamedArea>; + NS_DECLARE_FRAME_PROPERTY_DELETABLE(ExplicitNamedAreasProperty, + ExplicitNamedAreas) + ExplicitNamedAreas* GetExplicitNamedAreas() const { + return GetProperty(ExplicitNamedAreasProperty()); + } + + using nsContainerFrame::IsMasonry; + + /** Return true if this frame has masonry layout in any axis. */ + bool IsMasonry() const { + return HasAnyStateBits(NS_STATE_GRID_IS_ROW_MASONRY | + NS_STATE_GRID_IS_COL_MASONRY); + } + + /** Return true if this frame is subgridded in its aAxis. */ + bool IsSubgrid(LogicalAxis aAxis) const { + return HasAnyStateBits(aAxis == mozilla::eLogicalAxisBlock + ? NS_STATE_GRID_IS_ROW_SUBGRID + : NS_STATE_GRID_IS_COL_SUBGRID); + } + bool IsColSubgrid() const { return IsSubgrid(mozilla::eLogicalAxisInline); } + bool IsRowSubgrid() const { return IsSubgrid(mozilla::eLogicalAxisBlock); } + /** Return true if this frame is subgridded in any axis. */ + bool IsSubgrid() const { + return HasAnyStateBits(NS_STATE_GRID_IS_ROW_SUBGRID | + NS_STATE_GRID_IS_COL_SUBGRID); + } + + /** Return true if this frame has an item that is subgridded in our aAxis. */ + bool HasSubgridItems(LogicalAxis aAxis) const { + return HasAnyStateBits(aAxis == mozilla::eLogicalAxisBlock + ? NS_STATE_GRID_HAS_ROW_SUBGRID_ITEM + : NS_STATE_GRID_HAS_COL_SUBGRID_ITEM); + } + /** Return true if this frame has any subgrid items. */ + bool HasSubgridItems() const { + return HasAnyStateBits(NS_STATE_GRID_HAS_ROW_SUBGRID_ITEM | + NS_STATE_GRID_HAS_COL_SUBGRID_ITEM); + } + /** + * Return true if the grid item aChild should stretch in its aAxis (i.e. aAxis + * is in the aChild's writing-mode). + * + * Note: this method does *not* consider the grid item's aspect-ratio and + * natural size in the axis when the self-alignment value is 'normal' per + * https://drafts.csswg.org/css-grid/#grid-item-sizing + */ + bool GridItemShouldStretch(const nsIFrame* aChild, LogicalAxis aAxis) const; + + /** + * Returns true if aFrame forms an independent formatting context and hence + * should be inhibited from being a subgrid (i.e. if the used value of + * 'grid-template-{rows,columns}:subgrid' should be 'none'). + * https://drafts.csswg.org/css-grid-2/#subgrid-listing + * + * (Note this only makes sense to call if aFrame is itself either a grid + * container frame or a wrapper frame for a grid container frame, e.g. a + * scroll container frame for a scrollable grid. Having said that, this is + * technically safe to call on any non-null frame.) + */ + static bool ShouldInhibitSubgridDueToIFC(const nsIFrame* aFrame); + + /** + * Return a container grid frame for the supplied frame, if available. + * @return nullptr if aFrame has no grid container. + */ + static nsGridContainerFrame* GetGridContainerFrame(nsIFrame* aFrame); + + /** + * Return a container grid frame, and ensure it has computed grid info + * @return nullptr if aFrame has no grid container, or frame was destroyed + * @note this might destroy layout/style data since it may flush layout + */ + MOZ_CAN_RUN_SCRIPT_BOUNDARY + static nsGridContainerFrame* GetGridFrameWithComputedInfo(nsIFrame* aFrame); + + struct Subgrid; + struct UsedTrackSizes; + struct TrackSize; + struct GridItemInfo; + struct GridReflowInput; + struct FindItemInGridOrderResult { + // The first(last) item in (reverse) grid order. + const GridItemInfo* mItem; + // Does the above item span the first(last) track? + bool mIsInEdgeTrack; + }; + + /** Return our parent grid container; |this| MUST be a subgrid. */ + nsGridContainerFrame* ParentGridContainerForSubgrid() const; + + // https://drafts.csswg.org/css-sizing/#constraints + enum class SizingConstraint { + MinContent, // sizing under min-content constraint + MaxContent, // sizing under max-content constraint + NoConstraint // no constraint, used during Reflow + }; + + protected: + typedef mozilla::LogicalPoint LogicalPoint; + typedef mozilla::LogicalRect LogicalRect; + typedef mozilla::LogicalSize LogicalSize; + typedef mozilla::WritingMode WritingMode; + struct Grid; + struct GridArea; + class LineNameMap; + struct LineRange; + struct SharedGridData; + struct SubgridFallbackTrackSizingFunctions; + struct TrackSizingFunctions; + struct Tracks; + struct TranslatedLineRange; + friend nsContainerFrame* NS_NewGridContainerFrame( + mozilla::PresShell* aPresShell, ComputedStyle* aStyle); + explicit nsGridContainerFrame(ComputedStyle* aStyle, + nsPresContext* aPresContext) + : nsContainerFrame(aStyle, aPresContext, kClassID), + mCachedMinISize(NS_INTRINSIC_ISIZE_UNKNOWN), + mCachedPrefISize(NS_INTRINSIC_ISIZE_UNKNOWN) { + for (auto& perAxisBaseline : mBaseline) { + for (auto& baseline : perAxisBaseline) { + baseline = NS_INTRINSIC_ISIZE_UNKNOWN; + } + } + } + + /** + * XXX temporary - move the ImplicitNamedAreas stuff to the style system. + * The implicit area names that come from x-start .. x-end lines in + * grid-template-columns / grid-template-rows are stored in this frame + * property when needed, as a ImplicitNamedAreas* value. + */ + void InitImplicitNamedAreas(const nsStylePosition* aStyle); + + using LineNameList = + const mozilla::StyleOwnedSlice<mozilla::StyleCustomIdent>; + void AddImplicitNamedAreas(mozilla::Span<LineNameList>); + using StyleLineNameListValue = + const mozilla::StyleGenericLineNameListValue<mozilla::StyleInteger>; + void AddImplicitNamedAreas(mozilla::Span<StyleLineNameListValue>); + + /** + * Reflow and place our children. + * @return the consumed size of all of this grid container's continuations + * so far including this frame + */ + nscoord ReflowChildren(GridReflowInput& aState, + const LogicalRect& aContentArea, + const nsSize& aContainerSize, + ReflowOutput& aDesiredSize, nsReflowStatus& aStatus); + + /** + * Helper for GetMinISize / GetPrefISize. + */ + nscoord IntrinsicISize(gfxContext* aRenderingContext, + mozilla::IntrinsicISizeType aConstraint); + + nscoord GetBBaseline(BaselineSharingGroup aBaselineGroup) const { + return mBaseline[mozilla::eLogicalAxisBlock][aBaselineGroup]; + } + nscoord GetIBaseline(BaselineSharingGroup aBaselineGroup) const { + return mBaseline[mozilla::eLogicalAxisInline][aBaselineGroup]; + } + + /** + * Calculate this grid container's baselines. + * @param aBaselineSet which baseline(s) to derive from a baseline-group or + * items; a baseline not included is synthesized from the border-box instead. + * @param aFragmentStartTrack is the first track in this fragment in the same + * axis as aMajor. Pass zero if that's not the axis we're fragmenting in. + * @param aFirstExcludedTrack should be the first track in the next fragment + * or one beyond the final track in the last fragment, in aMajor's axis. + * Pass the number of tracks if that's not the axis we're fragmenting in. + */ + enum BaselineSet : uint32_t { + eNone = 0x0, + eFirst = 0x1, + eLast = 0x2, + eBoth = eFirst | eLast, + }; + void CalculateBaselines(BaselineSet aBaselineSet, + mozilla::CSSOrderAwareFrameIterator* aIter, + const nsTArray<GridItemInfo>* aGridItems, + const Tracks& aTracks, uint32_t aFragmentStartTrack, + uint32_t aFirstExcludedTrack, WritingMode aWM, + const nsSize& aCBPhysicalSize, + nscoord aCBBorderPaddingStart, + nscoord aCBBorderPaddingStartEnd, nscoord aCBSize); + + /** + * Synthesize a Grid container baseline for aGroup. + */ + nscoord SynthesizeBaseline(const FindItemInGridOrderResult& aGridOrderItem, + LogicalAxis aAxis, BaselineSharingGroup aGroup, + const nsSize& aCBPhysicalSize, nscoord aCBSize, + WritingMode aCBWM); + /** + * Find the first item in Grid Order in this fragment. + * https://drafts.csswg.org/css-grid/#grid-order + * @param aFragmentStartTrack is the first track in this fragment in the same + * axis as aMajor. Pass zero if that's not the axis we're fragmenting in. + */ + static FindItemInGridOrderResult FindFirstItemInGridOrder( + mozilla::CSSOrderAwareFrameIterator& aIter, + const nsTArray<GridItemInfo>& aGridItems, LineRange GridArea::*aMajor, + LineRange GridArea::*aMinor, uint32_t aFragmentStartTrack); + /** + * Find the last item in Grid Order in this fragment. + * @param aFragmentStartTrack is the first track in this fragment in the same + * axis as aMajor. Pass zero if that's not the axis we're fragmenting in. + * @param aFirstExcludedTrack should be the first track in the next fragment + * or one beyond the final track in the last fragment, in aMajor's axis. + * Pass the number of tracks if that's not the axis we're fragmenting in. + */ + static FindItemInGridOrderResult FindLastItemInGridOrder( + mozilla::ReverseCSSOrderAwareFrameIterator& aIter, + const nsTArray<GridItemInfo>& aGridItems, LineRange GridArea::*aMajor, + LineRange GridArea::*aMinor, uint32_t aFragmentStartTrack, + uint32_t aFirstExcludedTrack); + + /** + * Update our NS_STATE_GRID_IS_COL/ROW_SUBGRID bits and related subgrid state + * on our entire continuation chain based on the current style. + * This is needed because grid-template-columns/rows style changes only + * trigger a reflow so we need to update this dynamically. + */ + void UpdateSubgridFrameState(); + + /** + * Return the NS_STATE_GRID_IS_COL/ROW_SUBGRID and + * NS_STATE_GRID_IS_ROW/COL_MASONRY bits we ought to have. + */ + nsFrameState ComputeSelfSubgridMasonryBits() const; + + private: + // Helpers for ReflowChildren + struct Fragmentainer { + /** + * The distance from the first grid container fragment's block-axis content + * edge to the fragmentainer end. + */ + nscoord mToFragmentainerEnd; + /** + * True if the current fragment is at the start of the fragmentainer. + */ + bool mIsTopOfPage; + /** + * Is there a Class C break opportunity at the start content edge? + */ + bool mCanBreakAtStart; + /** + * Is there a Class C break opportunity at the end content edge? + */ + bool mCanBreakAtEnd; + /** + * Is the grid container's block-size unconstrained? + */ + bool mIsAutoBSize; + }; + + mozilla::Maybe<nsGridContainerFrame::Fragmentainer> GetNearestFragmentainer( + const GridReflowInput& aState) const; + + // @return the consumed size of all continuations so far including this frame + nscoord ReflowInFragmentainer(GridReflowInput& aState, + const LogicalRect& aContentArea, + ReflowOutput& aDesiredSize, + nsReflowStatus& aStatus, + Fragmentainer& aFragmentainer, + const nsSize& aContainerSize); + + // Helper for ReflowInFragmentainer + // @return the consumed size of all continuations so far including this frame + nscoord ReflowRowsInFragmentainer( + GridReflowInput& aState, const LogicalRect& aContentArea, + ReflowOutput& aDesiredSize, nsReflowStatus& aStatus, + Fragmentainer& aFragmentainer, const nsSize& aContainerSize, + const nsTArray<const GridItemInfo*>& aItems, uint32_t aStartRow, + uint32_t aEndRow, nscoord aBSize, nscoord aAvailableSize); + + // Helper for ReflowChildren / ReflowInFragmentainer + void ReflowInFlowChild(nsIFrame* aChild, const GridItemInfo* aGridItemInfo, + nsSize aContainerSize, + const mozilla::Maybe<nscoord>& aStretchBSize, + const Fragmentainer* aFragmentainer, + const GridReflowInput& aState, + const LogicalRect& aContentArea, + ReflowOutput& aDesiredSize, nsReflowStatus& aStatus); + + /** + * Places and reflows items when we have masonry layout. + * It handles unconstrained reflow and also fragmentation when the row axis + * is the masonry axis. ReflowInFragmentainer handles the case when we're + * fragmenting and our row axis is a grid axis and it handles masonry layout + * in the column axis in that case. + * @return the intrinsic size in the masonry axis + */ + nscoord MasonryLayout(GridReflowInput& aState, + const LogicalRect& aContentArea, + SizingConstraint aConstraint, + ReflowOutput& aDesiredSize, nsReflowStatus& aStatus, + Fragmentainer* aFragmentainer, + const nsSize& aContainerSize); + + // Return the stored UsedTrackSizes, if any. + UsedTrackSizes* GetUsedTrackSizes() const; + + // Store the given TrackSizes in aAxis on a UsedTrackSizes frame property. + void StoreUsedTrackSizes(LogicalAxis aAxis, + const nsTArray<TrackSize>& aSizes); + + // The internal implementation for AddImplicitNamedAreas(). + void AddImplicitNamedAreasInternal(LineNameList& aNameList, + ImplicitNamedAreas*& aAreas); + + /** + * Cached values to optimize GetMinISize/GetPrefISize. + */ + nscoord mCachedMinISize; + nscoord mCachedPrefISize; + + // Our baselines, one per BaselineSharingGroup per axis. + PerLogicalAxis<PerBaseline<nscoord>> mBaseline; + + public: + // A cached result for a grid item's block-axis measuring reflow. This + // cache prevents us from doing exponential reflows in cases of deeply + // nested grid frames. + // + // We store the cached value in the grid item's frame property table. + // + // We cache the following as a "key" + // - The size of the grid area in the item's inline axis + // - The item's block axis baseline padding + // ...and we cache the following as the "value", + // - The item's border-box BSize + class CachedBAxisMeasurement { + public: + NS_DECLARE_FRAME_PROPERTY_SMALL_VALUE(Prop, CachedBAxisMeasurement) + CachedBAxisMeasurement(const nsIFrame* aFrame, const LogicalSize& aCBSize, + const nscoord aBSize) + : mKey(aFrame, aCBSize), mBSize(aBSize) {} + + CachedBAxisMeasurement() = default; + + bool IsValidFor(const nsIFrame* aFrame, const LogicalSize& aCBSize) const { + if (aFrame->IsSubtreeDirty()) { + return false; + } + + if (!CanCacheMeasurement(aFrame, aCBSize)) { + return false; + } + + return mKey == Key(aFrame, aCBSize); + } + + static bool CanCacheMeasurement(const nsIFrame* aFrame, + const LogicalSize& aCBSize) { + return Key::CanHash(aFrame, aCBSize); + } + + nscoord BSize() const { return mBSize; } + + void Update(const nsIFrame* aFrame, const LogicalSize& aCBSize, + const nscoord aBSize) { + MOZ_ASSERT(CanCacheMeasurement(aFrame, aCBSize)); + mKey.mHashKey = Key::GenerateHash(aFrame, aCBSize); + mBSize = aBSize; + } + + private: + struct Key { + // mHashKey is generated by combining these 2 variables together + // 1. The containing block size in the item's inline axis used + // for measuring reflow + // 2. The item's baseline padding property + uint32_t mHashKey; + + Key() = default; + + Key(const nsIFrame* aFrame, const LogicalSize& aCBSize) { + MOZ_ASSERT(CanHash(aFrame, aCBSize)); + mHashKey = GenerateHash(aFrame, aCBSize); + } + + void UpdateHash(const nsIFrame* aFrame, const LogicalSize& aCBSize) { + MOZ_ASSERT(CanHash(aFrame, aCBSize)); + mHashKey = GenerateHash(aFrame, aCBSize); + } + + static uint32_t GenerateHash(const nsIFrame* aFrame, + const LogicalSize& aCBSize) { + MOZ_ASSERT(CanHash(aFrame, aCBSize)); + + nscoord gridAreaISize = aCBSize.ISize(aFrame->GetWritingMode()); + nscoord bBaselinePaddingProperty = + abs(aFrame->GetProperty(nsIFrame::BBaselinePadProperty())); + + uint_fast8_t bitsNeededForISize = mozilla::FloorLog2(gridAreaISize) + 1; + + return (gridAreaISize << (32 - bitsNeededForISize)) | + bBaselinePaddingProperty; + } + + static bool CanHash(const nsIFrame* aFrame, const LogicalSize& aCBSize) { + uint_fast8_t bitsNeededForISize = + mozilla::FloorLog2(aCBSize.ISize(aFrame->GetWritingMode())) + 1; + + uint_fast8_t bitsNeededForBBaselinePadding = + mozilla::FloorLog2( + abs(aFrame->GetProperty(nsIFrame::BBaselinePadProperty()))) + + 1; + + return bitsNeededForISize + bitsNeededForBBaselinePadding <= 32; + } + + bool operator==(const Key& aOther) const { + return mHashKey == aOther.mHashKey; + } + }; + + Key mKey; + nscoord mBSize; + }; + + bool CanProvideLineIterator() const final { return true; } + nsILineIterator* GetLineIterator() final { return this; } + int32_t GetNumLines() const final; + bool IsLineIteratorFlowRTL() final; + mozilla::Result<LineInfo, nsresult> GetLine(int32_t aLineNumber) final; + int32_t FindLineContaining(nsIFrame* aFrame, int32_t aStartLine = 0) final; + NS_IMETHOD FindFrameAt(int32_t aLineNumber, nsPoint aPos, + nsIFrame** aFrameFound, bool* aPosIsBeforeFirstFrame, + bool* aPosIsAfterLastFrame) final; + NS_IMETHOD CheckLineOrder(int32_t aLine, bool* aIsReordered, + nsIFrame** aFirstVisual, + nsIFrame** aLastVisual) final; +}; + +#endif /* nsGridContainerFrame_h___ */ |