corysanin/tubestation
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Bug 1909761 Part 3 - Use IntrinsicSizeInput for AddInlineMinISize() and AddInlinePrefISize(). r=dholbert

Browse Source 
Another preparation patch in order to pass down a percentage basis when
computing intrinsic size.

Differential Revision: https://phabricator.services.mozilla.com/D219522
This commit is contained in:
Ting-Yu Lin
2024-09-03 04:25:42 +00:00
parent 6af05a0977
commit 116ca76700
20 changed files with 98 additions and 85 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
layout/generic/BRFrame.cpp
View File

@@ -53,9 +53,9 @@ class BRFrame final : public nsIFrame {
void Reflow(nsPresContext* aPresContext, ReflowOutput& aMetrics, void Reflow(nsPresContext* aPresContext, ReflowOutput& aMetrics,
const ReflowInput& aReflowInput, const ReflowInput& aReflowInput,
nsReflowStatus& aStatus) override; nsReflowStatus& aStatus) override;
void AddInlineMinISize(gfxContext* aRenderingContext, void AddInlineMinISize(const IntrinsicSizeInput& aInput,
InlineMinISizeData* aData) override; InlineMinISizeData* aData) override;
void AddInlinePrefISize(gfxContext* aRenderingContext, void AddInlinePrefISize(const IntrinsicSizeInput& aInput,
InlinePrefISizeData* aData) override; InlinePrefISizeData* aData) override;
Maybe<nscoord> GetNaturalBaselineBOffset( Maybe<nscoord> GetNaturalBaselineBOffset(
@@ -165,7 +165,7 @@ void BRFrame::Reflow(nsPresContext* aPresContext, ReflowOutput& aMetrics,
} }
/* virtual */ /* virtual */
void BRFrame::AddInlineMinISize(gfxContext* aRenderingContext, void BRFrame::AddInlineMinISize(const IntrinsicSizeInput& aInput,
InlineMinISizeData* aData) { InlineMinISizeData* aData) {
if (!GetParent()->Style()->ShouldSuppressLineBreak()) { if (!GetParent()->Style()->ShouldSuppressLineBreak()) {
aData->ForceBreak(); aData->ForceBreak();
@@ -173,7 +173,7 @@ void BRFrame::AddInlineMinISize(gfxContext* aRenderingContext,
} }
/* virtual */ /* virtual */
void BRFrame::AddInlinePrefISize(gfxContext* aRenderingContext, void BRFrame::AddInlinePrefISize(const IntrinsicSizeInput& aInput,
InlinePrefISizeData* aData) { InlinePrefISizeData* aData) {
if (!GetParent()->Style()->ShouldSuppressLineBreak()) { if (!GetParent()->Style()->ShouldSuppressLineBreak()) {
// Match the 1 appunit width assigned in the Reflow method above // Match the 1 appunit width assigned in the Reflow method above

9
layout/generic/nsBlockFrame.cpp
View File

@@ -883,7 +883,8 @@ nscoord nsBlockFrame::MinISize(const IntrinsicSizeInput& aInput) {
nsIFrame* kid = line->mFirstChild; nsIFrame* kid = line->mFirstChild;
for (int32_t i = 0, i_end = line->GetChildCount(); i != i_end; for (int32_t i = 0, i_end = line->GetChildCount(); i != i_end;
++i, kid = kid->GetNextSibling()) { ++i, kid = kid->GetNextSibling()) {
kid->AddInlineMinISize(aInput.mContext, &data); const IntrinsicSizeInput kidInput(aInput.mContext);
kid->AddInlineMinISize(kidInput, &data);
if (whiteSpaceCanWrap && data.mTrailingWhitespace) { if (whiteSpaceCanWrap && data.mTrailingWhitespace) {
data.OptionallyBreak(); data.OptionallyBreak();
} }
@@ -965,7 +966,8 @@ nscoord nsBlockFrame::PrefISize(const IntrinsicSizeInput& aInput) {
nsIFrame* kid = line->mFirstChild; nsIFrame* kid = line->mFirstChild;
for (int32_t i = 0, i_end = line->GetChildCount(); i != i_end; for (int32_t i = 0, i_end = line->GetChildCount(); i != i_end;
++i, kid = kid->GetNextSibling()) { ++i, kid = kid->GetNextSibling()) {
kid->AddInlinePrefISize(aInput.mContext, &data); const IntrinsicSizeInput kidInput(aInput.mContext);
kid->AddInlinePrefISize(kidInput, &data);
} }
} }
#ifdef DEBUG #ifdef DEBUG
@@ -1022,6 +1024,7 @@ nsresult nsBlockFrame::GetPrefWidthTightBounds(gfxContext* aRenderingContext,
data.mLine = &line; data.mLine = &line;
data.SetLineContainer(curFrame); data.SetLineContainer(curFrame);
nsIFrame* kid = line->mFirstChild; nsIFrame* kid = line->mFirstChild;
const IntrinsicSizeInput kidInput(aRenderingContext);
for (int32_t i = 0, i_end = line->GetChildCount(); i != i_end; for (int32_t i = 0, i_end = line->GetChildCount(); i != i_end;
++i, kid = kid->GetNextSibling()) { ++i, kid = kid->GetNextSibling()) {
rv = kid->GetPrefWidthTightBounds(aRenderingContext, &childX, rv = kid->GetPrefWidthTightBounds(aRenderingContext, &childX,
@@ -1029,7 +1032,7 @@ nsresult nsBlockFrame::GetPrefWidthTightBounds(gfxContext* aRenderingContext,
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
*aX = std::min(*aX, data.mCurrentLine + childX); *aX = std::min(*aX, data.mCurrentLine + childX);
*aXMost = std::max(*aXMost, data.mCurrentLine + childXMost); *aXMost = std::max(*aXMost, data.mCurrentLine + childXMost);
kid->AddInlinePrefISize(aRenderingContext, &data); kid->AddInlinePrefISize(kidInput, &data);
} }
} }
} }

14
layout/generic/nsContainerFrame.cpp
View File

@@ -788,21 +788,23 @@ void nsContainerFrame::SyncFrameViewAfterReflow(nsPresContext* aPresContext,
} }
} }
void nsContainerFrame::DoInlineMinISize(gfxContext* aRenderingContext, void nsContainerFrame::DoInlineMinISize(const IntrinsicSizeInput& aInput,
InlineMinISizeData* aData) { InlineMinISizeData* aData) {
auto handleChildren = [aRenderingContext](auto frame, auto data) { auto handleChildren = [&](auto frame, auto data) {
for (nsIFrame* kid : frame->mFrames) { for (nsIFrame* kid : frame->mFrames) {
kid->AddInlineMinISize(aRenderingContext, data); const IntrinsicSizeInput kidInput(aInput.mContext);
kid->AddInlineMinISize(kidInput, data);
} }
}; };
DoInlineIntrinsicISize(aData, handleChildren); DoInlineIntrinsicISize(aData, handleChildren);
} }
void nsContainerFrame::DoInlinePrefISize(gfxContext* aRenderingContext, void nsContainerFrame::DoInlinePrefISize(const IntrinsicSizeInput& aInput,
InlinePrefISizeData* aData) { InlinePrefISizeData* aData) {
auto handleChildren = [aRenderingContext](auto frame, auto data) { auto handleChildren = [&](auto frame, auto data) {
for (nsIFrame* kid : frame->mFrames) { for (nsIFrame* kid : frame->mFrames) {
kid->AddInlinePrefISize(aRenderingContext, data); const IntrinsicSizeInput kidInput(aInput.mContext);
kid->AddInlinePrefISize(kidInput, data);
} }
}; };
DoInlineIntrinsicISize(aData, handleChildren); DoInlineIntrinsicISize(aData, handleChildren);

4
layout/generic/nsContainerFrame.h
View File

@@ -210,9 +210,9 @@ class nsContainerFrame : public nsSplittableFrame {
template <typename ISizeData, typename F> template <typename ISizeData, typename F>
void DoInlineIntrinsicISize(ISizeData* aData, F& aHandleChildren); void DoInlineIntrinsicISize(ISizeData* aData, F& aHandleChildren);
void DoInlineMinISize(gfxContext* aRenderingContext, void DoInlineMinISize(const mozilla::IntrinsicSizeInput& aInput,
InlineMinISizeData* aData); InlineMinISizeData* aData);
void DoInlinePrefISize(gfxContext* aRenderingContext, void DoInlinePrefISize(const mozilla::IntrinsicSizeInput& aInput,
InlinePrefISizeData* aData); InlinePrefISizeData* aData);
/** /**

10
layout/generic/nsFirstLetterFrame.cpp
View File

@@ -109,23 +109,23 @@ nsresult nsFirstLetterFrame::GetChildFrameContainingOffset(
// Needed for non-floating first-letter frames and for the continuations // Needed for non-floating first-letter frames and for the continuations
// following the first-letter that we also use nsFirstLetterFrame for. // following the first-letter that we also use nsFirstLetterFrame for.
/* virtual */ /* virtual */
void nsFirstLetterFrame::AddInlineMinISize(gfxContext* aRenderingContext, void nsFirstLetterFrame::AddInlineMinISize(const IntrinsicSizeInput& aInput,
InlineMinISizeData* aData) { InlineMinISizeData* aData) {
DoInlineMinISize(aRenderingContext, aData); DoInlineMinISize(aInput, aData);
} }
// Needed for non-floating first-letter frames and for the continuations // Needed for non-floating first-letter frames and for the continuations
// following the first-letter that we also use nsFirstLetterFrame for. // following the first-letter that we also use nsFirstLetterFrame for.
/* virtual */ /* virtual */
void nsFirstLetterFrame::AddInlinePrefISize(gfxContext* aRenderingContext, void nsFirstLetterFrame::AddInlinePrefISize(const IntrinsicSizeInput& aInput,
InlinePrefISizeData* aData) { InlinePrefISizeData* aData) {
DoInlinePrefISize(aRenderingContext, aData); DoInlinePrefISize(aInput, aData);
} }
// Needed for floating first-letter frames. // Needed for floating first-letter frames.
nscoord nsFirstLetterFrame::IntrinsicISize(const IntrinsicSizeInput& aInput, nscoord nsFirstLetterFrame::IntrinsicISize(const IntrinsicSizeInput& aInput,
IntrinsicISizeType aType) { IntrinsicISizeType aType) {
return IntrinsicISizeFromInline(aInput.mContext, aType); return IntrinsicISizeFromInline(aInput, aType);
} }
/* virtual */ /* virtual */

4
layout/generic/nsFirstLetterFrame.h
View File

@@ -38,9 +38,9 @@ class nsFirstLetterFrame : public nsContainerFrame {
nscoord IntrinsicISize(const mozilla::IntrinsicSizeInput& aInput, nscoord IntrinsicISize(const mozilla::IntrinsicSizeInput& aInput,
mozilla::IntrinsicISizeType aType) final; mozilla::IntrinsicISizeType aType) final;
void AddInlineMinISize(gfxContext* aRenderingContext, void AddInlineMinISize(const mozilla::IntrinsicSizeInput& aInput,
InlineMinISizeData* aData) final; InlineMinISizeData* aData) final;
void AddInlinePrefISize(gfxContext* aRenderingContext, void AddInlinePrefISize(const mozilla::IntrinsicSizeInput& aInput,
InlinePrefISizeData* aData) final; InlinePrefISizeData* aData) final;
SizeComputationResult ComputeSize( SizeComputationResult ComputeSize(

14
layout/generic/nsIFrame.cpp
View File

@@ -6013,18 +6013,18 @@ void nsIFrame::MarkSubtreeDirty() {
} }
/* virtual */ /* virtual */
void nsIFrame::AddInlineMinISize(gfxContext* aRenderingContext, void nsIFrame::AddInlineMinISize(const IntrinsicSizeInput& aInput,
InlineMinISizeData* aData) { InlineMinISizeData* aData) {
nscoord isize = nsLayoutUtils::IntrinsicForContainer( nscoord isize = nsLayoutUtils::IntrinsicForContainer(
aRenderingContext, this, IntrinsicISizeType::MinISize); aInput.mContext, this, IntrinsicISizeType::MinISize);
aData->DefaultAddInlineMinISize(this, isize); aData->DefaultAddInlineMinISize(this, isize);
} }
/* virtual */ /* virtual */
void nsIFrame::AddInlinePrefISize(gfxContext* aRenderingContext, void nsIFrame::AddInlinePrefISize(const IntrinsicSizeInput& aInput,
nsIFrame::InlinePrefISizeData* aData) { nsIFrame::InlinePrefISizeData* aData) {
nscoord isize = nsLayoutUtils::IntrinsicForContainer( nscoord isize = nsLayoutUtils::IntrinsicForContainer(
aRenderingContext, this, IntrinsicISizeType::PrefISize); aInput.mContext, this, IntrinsicISizeType::PrefISize);
aData->DefaultAddInlinePrefISize(isize); aData->DefaultAddInlinePrefISize(isize);
} }
@@ -6740,20 +6740,20 @@ nscoord nsIFrame::ShrinkISizeToFit(const IntrinsicSizeInput& aInput,
return result; return result;
} }
nscoord nsIFrame::IntrinsicISizeFromInline(gfxContext* aContext, nscoord nsIFrame::IntrinsicISizeFromInline(const IntrinsicSizeInput& aInput,
IntrinsicISizeType aType) { IntrinsicISizeType aType) {
MOZ_ASSERT(!IsContainerForFontSizeInflation(), MOZ_ASSERT(!IsContainerForFontSizeInflation(),
"Should not be a container for font size inflation!"); "Should not be a container for font size inflation!");
if (aType == IntrinsicISizeType::MinISize) { if (aType == IntrinsicISizeType::MinISize) {
InlineMinISizeData data; InlineMinISizeData data;
AddInlineMinISize(aContext, &data); AddInlineMinISize(aInput, &data);
data.ForceBreak(); data.ForceBreak();
return data.mPrevLines; return data.mPrevLines;
} }
InlinePrefISizeData data; InlinePrefISizeData data;
AddInlinePrefISize(aContext, &data); AddInlinePrefISize(aInput, &data);
data.ForceBreak(); data.ForceBreak();
return data.mPrevLines; return data.mPrevLines;
} }

6
layout/generic/nsIFrame.h
View File

@@ -2743,7 +2743,7 @@ class nsIFrame : public nsQueryFrame {
* line breaking can inherit the default implementation on nsIFrame, * line breaking can inherit the default implementation on nsIFrame,
* which calls |GetMinISize|. * which calls |GetMinISize|.
*/ */
virtual void AddInlineMinISize(gfxContext* aRenderingContext, virtual void AddInlineMinISize(const mozilla::IntrinsicSizeInput& aInput,
InlineMinISizeData* aData); InlineMinISizeData* aData);
/** /**
@@ -2756,7 +2756,7 @@ class nsIFrame : public nsQueryFrame {
* except that this fills in an |InlinePrefISizeData| structure * except that this fills in an |InlinePrefISizeData| structure
* based on using all *mandatory* breakpoints within the frame. * based on using all *mandatory* breakpoints within the frame.
*/ */
virtual void AddInlinePrefISize(gfxContext* aRenderingContext, virtual void AddInlinePrefISize(const mozilla::IntrinsicSizeInput& aInput,
InlinePrefISizeData* aData); InlinePrefISizeData* aData);
/** /**
@@ -2915,7 +2915,7 @@ class nsIFrame : public nsQueryFrame {
* intrinsic inline size in terms of AddInlineMinISize() and * intrinsic inline size in terms of AddInlineMinISize() and
* AddInlinePrefISize(). * AddInlinePrefISize().
*/ */
nscoord IntrinsicISizeFromInline(gfxContext* aContext, nscoord IntrinsicISizeFromInline(const mozilla::IntrinsicSizeInput& aInput,
mozilla::IntrinsicISizeType aType); mozilla::IntrinsicISizeType aType);
public: public:

4
layout/generic/nsImageFrame.cpp
View File

@@ -2847,10 +2847,10 @@ static bool IsInAutoWidthTableCellForQuirk(nsIFrame* aFrame) {
return false; return false;
} }
void nsImageFrame::AddInlineMinISize(gfxContext* aRenderingContext, void nsImageFrame::AddInlineMinISize(const IntrinsicSizeInput& aInput,
InlineMinISizeData* aData) { InlineMinISizeData* aData) {
nscoord isize = nsLayoutUtils::IntrinsicForContainer( nscoord isize = nsLayoutUtils::IntrinsicForContainer(
aRenderingContext, this, IntrinsicISizeType::MinISize); aInput.mContext, this, IntrinsicISizeType::MinISize);
bool canBreak = !IsInAutoWidthTableCellForQuirk(this); bool canBreak = !IsInAutoWidthTableCellForQuirk(this);
aData->DefaultAddInlineMinISize(this, isize, canBreak); aData->DefaultAddInlineMinISize(this, isize, canBreak);
} }

2
layout/generic/nsImageFrame.h
View File

@@ -174,7 +174,7 @@ class nsImageFrame : public nsAtomicContainerFrame, public nsIReflowCallback {
nsImageMap* GetImageMap(); nsImageMap* GetImageMap();
nsImageMap* GetExistingImageMap() const { return mImageMap; } nsImageMap* GetExistingImageMap() const { return mImageMap; }
void AddInlineMinISize(gfxContext* aRenderingContext, void AddInlineMinISize(const mozilla::IntrinsicSizeInput& aInput,
InlineMinISizeData* aData) final; InlineMinISizeData* aData) final;
void DisconnectMap(); void DisconnectMap();

8
layout/generic/nsInlineFrame.cpp
View File

@@ -223,15 +223,15 @@ void nsInlineFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
// Reflow methods // Reflow methods
/* virtual */ /* virtual */
void nsInlineFrame::AddInlineMinISize(gfxContext* aRenderingContext, void nsInlineFrame::AddInlineMinISize(const IntrinsicSizeInput& aInput,
InlineMinISizeData* aData) { InlineMinISizeData* aData) {
DoInlineMinISize(aRenderingContext, aData); DoInlineMinISize(aInput, aData);
} }
/* virtual */ /* virtual */
void nsInlineFrame::AddInlinePrefISize(gfxContext* aRenderingContext, void nsInlineFrame::AddInlinePrefISize(const IntrinsicSizeInput& aInput,
InlinePrefISizeData* aData) { InlinePrefISizeData* aData) {
DoInlinePrefISize(aRenderingContext, aData); DoInlinePrefISize(aInput, aData);
} }
/* virtual */ /* virtual */

4
layout/generic/nsInlineFrame.h
View File

@@ -61,9 +61,9 @@ class nsInlineFrame : public nsContainerFrame {
void StealFrame(nsIFrame* aChild) override; void StealFrame(nsIFrame* aChild) override;
void AddInlineMinISize(gfxContext* aRenderingContext, void AddInlineMinISize(const mozilla::IntrinsicSizeInput& aInput,
InlineMinISizeData* aData) override; InlineMinISizeData* aData) override;
void AddInlinePrefISize(gfxContext* aRenderingContext, void AddInlinePrefISize(const mozilla::IntrinsicSizeInput& aInput,
InlinePrefISizeData* aData) override; InlinePrefISizeData* aData) override;
SizeComputationResult ComputeSize( SizeComputationResult ComputeSize(
gfxContext* aRenderingContext, mozilla::WritingMode aWM, gfxContext* aRenderingContext, mozilla::WritingMode aWM,

22
layout/generic/nsPlaceholderFrame.cpp
View File

@@ -46,7 +46,7 @@ NS_QUERYFRAME_TAIL_INHERITING(nsIFrame)
#endif #endif
/* virtual */ /* virtual */
void nsPlaceholderFrame::AddInlineMinISize(gfxContext* aRenderingContext, void nsPlaceholderFrame::AddInlineMinISize(const IntrinsicSizeInput& aInput,
InlineMinISizeData* aData) { InlineMinISizeData* aData) {
// Override AddInlineMinISize so that *nothing* happens. In // Override AddInlineMinISize so that *nothing* happens. In
// particular, we don't want to zero out |aData->mTrailingWhitespace|, // particular, we don't want to zero out |aData->mTrailingWhitespace|,
@@ -54,16 +54,12 @@ void nsPlaceholderFrame::AddInlineMinISize(gfxContext* aRenderingContext,
// whitespace, and we don't want to set aData->mSkipWhitespace to // whitespace, and we don't want to set aData->mSkipWhitespace to
// false. // false.
// ...but push floats onto the list // ...but push floats onto aData's list.
if (mOutOfFlowFrame->IsFloating()) { AddFloatToIntrinsicISizeData(aInput, IntrinsicISizeType::MinISize, aData);
const nscoord floatISize = nsLayoutUtils::IntrinsicForContainer(
aRenderingContext, mOutOfFlowFrame, IntrinsicISizeType::MinISize);
aData->mFloats.EmplaceBack(mOutOfFlowFrame, floatISize);
}
} }
/* virtual */ /* virtual */
void nsPlaceholderFrame::AddInlinePrefISize(gfxContext* aRenderingContext, void nsPlaceholderFrame::AddInlinePrefISize(const IntrinsicSizeInput& aInput,
InlinePrefISizeData* aData) { InlinePrefISizeData* aData) {
// Override AddInlinePrefISize so that *nothing* happens. In // Override AddInlinePrefISize so that *nothing* happens. In
// particular, we don't want to zero out |aData->mTrailingWhitespace|, // particular, we don't want to zero out |aData->mTrailingWhitespace|,
@@ -71,10 +67,16 @@ void nsPlaceholderFrame::AddInlinePrefISize(gfxContext* aRenderingContext,
// whitespace, and we don't want to set aData->mSkipWhitespace to // whitespace, and we don't want to set aData->mSkipWhitespace to
// false. // false.
// ...but push floats onto the list // ...but push floats onto aData's list.
AddFloatToIntrinsicISizeData(aInput, IntrinsicISizeType::PrefISize, aData);
}
void nsPlaceholderFrame::AddFloatToIntrinsicISizeData(
const IntrinsicSizeInput& aInput, IntrinsicISizeType aType,
InlineIntrinsicISizeData* aData) const {
if (mOutOfFlowFrame->IsFloating()) { if (mOutOfFlowFrame->IsFloating()) {
const nscoord floatISize = nsLayoutUtils::IntrinsicForContainer( const nscoord floatISize = nsLayoutUtils::IntrinsicForContainer(
aRenderingContext, mOutOfFlowFrame, IntrinsicISizeType::PrefISize); aInput.mContext, mOutOfFlowFrame, aType);
aData->mFloats.EmplaceBack(mOutOfFlowFrame, floatISize); aData->mFloats.EmplaceBack(mOutOfFlowFrame, floatISize);
} }
} }

10
layout/generic/nsPlaceholderFrame.h
View File

@@ -92,10 +92,9 @@ class nsPlaceholderFrame final : public nsIFrame {
mOutOfFlowFrame = aFrame; mOutOfFlowFrame = aFrame;
} }
// nsIFrame overrides void AddInlineMinISize(const mozilla::IntrinsicSizeInput& aInput,
void AddInlineMinISize(gfxContext* aRenderingContext,
InlineMinISizeData* aData) override; InlineMinISizeData* aData) override;
void AddInlinePrefISize(gfxContext* aRenderingContext, void AddInlinePrefISize(const mozilla::IntrinsicSizeInput& aInput,
InlinePrefISizeData* aData) override; InlinePrefISizeData* aData) override;
void Reflow(nsPresContext* aPresContext, ReflowOutput& aDesiredSize, void Reflow(nsPresContext* aPresContext, ReflowOutput& aDesiredSize,
@@ -181,6 +180,11 @@ class nsPlaceholderFrame final : public nsIFrame {
} }
protected: protected:
// A helper to implement AddInlineMinISize() and AddInlinePrefISize().
void AddFloatToIntrinsicISizeData(const mozilla::IntrinsicSizeInput& aInput,
mozilla::IntrinsicISizeType aType,
InlineIntrinsicISizeData* aData) const;
nsIFrame* mOutOfFlowFrame; nsIFrame* mOutOfFlowFrame;
}; };

24
layout/generic/nsRubyBaseContainerFrame.cpp
View File

@@ -126,7 +126,7 @@ static void GetIsLineBreakAllowed(nsIFrame* aFrame, bool aIsLineBreakable,
* happens across the boundary of those frames. * happens across the boundary of those frames.
*/ */
static nscoord CalculateColumnPrefISize( static nscoord CalculateColumnPrefISize(
gfxContext* aRenderingContext, const RubyColumnEnumerator& aEnumerator, const IntrinsicSizeInput& aInput, const RubyColumnEnumerator& aEnumerator,
nsIFrame::InlineIntrinsicISizeData* aBaseISizeData) { nsIFrame::InlineIntrinsicISizeData* aBaseISizeData) {
nscoord max = 0; nscoord max = 0;
uint32_t levelCount = aEnumerator.GetLevelCount(); uint32_t levelCount = aEnumerator.GetLevelCount();
@@ -143,7 +143,7 @@ static nscoord CalculateColumnPrefISize(
// ruby text container frame. // ruby text container frame.
data.SetLineContainer(frame->GetParent()); data.SetLineContainer(frame->GetParent());
} }
frame->AddInlinePrefISize(aRenderingContext, &data); frame->AddInlinePrefISize(aInput, &data);
MOZ_ASSERT(data.mPrevLines == 0, "Shouldn't have prev lines"); MOZ_ASSERT(data.mPrevLines == 0, "Shouldn't have prev lines");
max = std::max(max, data.mCurrentLine); max = std::max(max, data.mCurrentLine);
if (i == 0) { if (i == 0) {
@@ -159,8 +159,8 @@ static nscoord CalculateColumnPrefISize(
// computing min isize of ruby frame, which may cause problem. // computing min isize of ruby frame, which may cause problem.
// See bug 1134945. // See bug 1134945.
/* virtual */ /* virtual */
void nsRubyBaseContainerFrame::AddInlineMinISize(gfxContext* aRenderingContext, void nsRubyBaseContainerFrame::AddInlineMinISize(
InlineMinISizeData* aData) { const IntrinsicSizeInput& aInput, InlineMinISizeData* aData) {
AutoRubyTextContainerArray textContainers(this); AutoRubyTextContainerArray textContainers(this);
for (uint32_t i = 0, iend = textContainers.Length(); i < iend; i++) { for (uint32_t i = 0, iend = textContainers.Length(); i < iend; i++) {
@@ -171,7 +171,7 @@ void nsRubyBaseContainerFrame::AddInlineMinISize(gfxContext* aRenderingContext,
data.SetLineContainer(aData->LineContainer()); data.SetLineContainer(aData->LineContainer());
data.mSkipWhitespace = aData->mSkipWhitespace; data.mSkipWhitespace = aData->mSkipWhitespace;
data.mTrailingWhitespace = aData->mTrailingWhitespace; data.mTrailingWhitespace = aData->mTrailingWhitespace;
AddInlinePrefISize(aRenderingContext, &data); AddInlinePrefISize(aInput, &data);
aData->mCurrentLine += data.mCurrentLine; aData->mCurrentLine += data.mCurrentLine;
if (data.mCurrentLine > 0) { if (data.mCurrentLine > 0) {
aData->mAtStartOfLine = false; aData->mAtStartOfLine = false;
@@ -194,15 +194,14 @@ void nsRubyBaseContainerFrame::AddInlineMinISize(gfxContext* aRenderingContext,
nsIFrame* baseFrame = enumerator.GetFrameAtLevel(0); nsIFrame* baseFrame = enumerator.GetFrameAtLevel(0);
if (baseFrame) { if (baseFrame) {
gfxBreakPriority breakPriority = LineBreakBefore( gfxBreakPriority breakPriority = LineBreakBefore(
baseFrame, aRenderingContext->GetDrawTarget(), nullptr, nullptr); baseFrame, aInput.mContext->GetDrawTarget(), nullptr, nullptr);
if (breakPriority != gfxBreakPriority::eNoBreak) { if (breakPriority != gfxBreakPriority::eNoBreak) {
aData->OptionallyBreak(); aData->OptionallyBreak();
} }
} }
} }
firstFrame = false; firstFrame = false;
nscoord isize = nscoord isize = CalculateColumnPrefISize(aInput, enumerator, aData);
CalculateColumnPrefISize(aRenderingContext, enumerator, aData);
aData->mCurrentLine += isize; aData->mCurrentLine += isize;
if (isize > 0) { if (isize > 0) {
aData->mAtStartOfLine = false; aData->mAtStartOfLine = false;
@@ -212,23 +211,24 @@ void nsRubyBaseContainerFrame::AddInlineMinISize(gfxContext* aRenderingContext,
} }
/* virtual */ /* virtual */
void nsRubyBaseContainerFrame::AddInlinePrefISize(gfxContext* aRenderingContext, void nsRubyBaseContainerFrame::AddInlinePrefISize(
InlinePrefISizeData* aData) { const IntrinsicSizeInput& aInput, InlinePrefISizeData* aData) {
AutoRubyTextContainerArray textContainers(this); AutoRubyTextContainerArray textContainers(this);
const IntrinsicSizeInput input(aInput.mContext);
nscoord sum = 0; nscoord sum = 0;
for (nsIFrame* frame = this; frame; frame = frame->GetNextInFlow()) { for (nsIFrame* frame = this; frame; frame = frame->GetNextInFlow()) {
RubyColumnEnumerator enumerator( RubyColumnEnumerator enumerator(
static_cast<nsRubyBaseContainerFrame*>(frame), textContainers); static_cast<nsRubyBaseContainerFrame*>(frame), textContainers);
for (; !enumerator.AtEnd(); enumerator.Next()) { for (; !enumerator.AtEnd(); enumerator.Next()) {
sum += CalculateColumnPrefISize(aRenderingContext, enumerator, aData); sum += CalculateColumnPrefISize(input, enumerator, aData);
} }
} }
for (uint32_t i = 0, iend = textContainers.Length(); i < iend; i++) { for (uint32_t i = 0, iend = textContainers.Length(); i < iend; i++) {
if (textContainers[i]->IsSpanContainer()) { if (textContainers[i]->IsSpanContainer()) {
nsIFrame* frame = textContainers[i]->PrincipalChildList().FirstChild(); nsIFrame* frame = textContainers[i]->PrincipalChildList().FirstChild();
InlinePrefISizeData data; InlinePrefISizeData data;
frame->AddInlinePrefISize(aRenderingContext, &data); frame->AddInlinePrefISize(input, &data);
MOZ_ASSERT(data.mPrevLines == 0, "Shouldn't have prev lines"); MOZ_ASSERT(data.mPrevLines == 0, "Shouldn't have prev lines");
sum = std::max(sum, data.mCurrentLine); sum = std::max(sum, data.mCurrentLine);
} }

4
layout/generic/nsRubyBaseContainerFrame.h
View File

@@ -29,9 +29,9 @@ class nsRubyBaseContainerFrame final : public nsContainerFrame {
NS_DECL_QUERYFRAME NS_DECL_QUERYFRAME
bool CanContinueTextRun() const override; bool CanContinueTextRun() const override;
void AddInlineMinISize(gfxContext* aRenderingContext, void AddInlineMinISize(const mozilla::IntrinsicSizeInput& aInput,
InlineMinISizeData* aData) override; InlineMinISizeData* aData) override;
void AddInlinePrefISize(gfxContext* aRenderingContext, void AddInlinePrefISize(const mozilla::IntrinsicSizeInput& aInput,
InlinePrefISizeData* aData) override; InlinePrefISizeData* aData) override;
SizeComputationResult ComputeSize( SizeComputationResult ComputeSize(
gfxContext* aRenderingContext, mozilla::WritingMode aWM, gfxContext* aRenderingContext, mozilla::WritingMode aWM,

14
layout/generic/nsRubyFrame.cpp
View File

@@ -51,24 +51,26 @@ nsresult nsRubyFrame::GetFrameName(nsAString& aResult) const {
#endif #endif
/* virtual */ /* virtual */
void nsRubyFrame::AddInlineMinISize(gfxContext* aRenderingContext, void nsRubyFrame::AddInlineMinISize(const IntrinsicSizeInput& aInput,
InlineMinISizeData* aData) { InlineMinISizeData* aData) {
auto handleChildren = [aRenderingContext](auto frame, auto data) { auto handleChildren = [&](auto frame, auto data) {
const IntrinsicSizeInput input(aInput.mContext);
for (RubySegmentEnumerator e(static_cast<nsRubyFrame*>(frame)); !e.AtEnd(); for (RubySegmentEnumerator e(static_cast<nsRubyFrame*>(frame)); !e.AtEnd();
e.Next()) { e.Next()) {
e.GetBaseContainer()->AddInlineMinISize(aRenderingContext, data); e.GetBaseContainer()->AddInlineMinISize(input, data);
} }
}; };
DoInlineIntrinsicISize(aData, handleChildren); DoInlineIntrinsicISize(aData, handleChildren);
} }
/* virtual */ /* virtual */
void nsRubyFrame::AddInlinePrefISize(gfxContext* aRenderingContext, void nsRubyFrame::AddInlinePrefISize(const IntrinsicSizeInput& aInput,
InlinePrefISizeData* aData) { InlinePrefISizeData* aData) {
auto handleChildren = [aRenderingContext](auto frame, auto data) { auto handleChildren = [&](auto frame, auto data) {
const IntrinsicSizeInput input(aInput.mContext);
for (RubySegmentEnumerator e(static_cast<nsRubyFrame*>(frame)); !e.AtEnd(); for (RubySegmentEnumerator e(static_cast<nsRubyFrame*>(frame)); !e.AtEnd();
e.Next()) { e.Next()) {
e.GetBaseContainer()->AddInlinePrefISize(aRenderingContext, data); e.GetBaseContainer()->AddInlinePrefISize(input, data);
} }
}; };
DoInlineIntrinsicISize(aData, handleChildren); DoInlineIntrinsicISize(aData, handleChildren);

4
layout/generic/nsRubyFrame.h
View File

@@ -28,9 +28,9 @@ class nsRubyFrame final : public nsInlineFrame {
NS_DECL_FRAMEARENA_HELPERS(nsRubyFrame) NS_DECL_FRAMEARENA_HELPERS(nsRubyFrame)
NS_DECL_QUERYFRAME NS_DECL_QUERYFRAME
void AddInlineMinISize(gfxContext* aRenderingContext, void AddInlineMinISize(const mozilla::IntrinsicSizeInput& aInput,
InlineMinISizeData* aData) override; InlineMinISizeData* aData) override;
void AddInlinePrefISize(gfxContext* aRenderingContext, void AddInlinePrefISize(const mozilla::IntrinsicSizeInput& aInput,
InlinePrefISizeData* aData) override; InlinePrefISizeData* aData) override;
void Reflow(nsPresContext* aPresContext, ReflowOutput& aDesiredSize, void Reflow(nsPresContext* aPresContext, ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput, const ReflowInput& aReflowInput,

14
layout/generic/nsTextFrame.cpp
View File

@@ -4275,11 +4275,11 @@ class nsContinuingTextFrame final : public nsTextFrame {
return mFirstContinuation; return mFirstContinuation;
}; };
void AddInlineMinISize(gfxContext* aRenderingContext, void AddInlineMinISize(const IntrinsicSizeInput& aInput,
InlineMinISizeData* aData) final { InlineMinISizeData* aData) final {
// Do nothing, since the first-in-flow accounts for everything. // Do nothing, since the first-in-flow accounts for everything.
} }
void AddInlinePrefISize(gfxContext* aRenderingContext, void AddInlinePrefISize(const IntrinsicSizeInput& aInput,
InlinePrefISizeData* aData) final { InlinePrefISizeData* aData) final {
// Do nothing, since the first-in-flow accounts for everything. // Do nothing, since the first-in-flow accounts for everything.
} }
@@ -4404,7 +4404,7 @@ nsIFrame* nsContinuingTextFrame::FirstInFlow() const {
nscoord nsTextFrame::IntrinsicISize(const IntrinsicSizeInput& aInput, nscoord nsTextFrame::IntrinsicISize(const IntrinsicSizeInput& aInput,
IntrinsicISizeType aType) { IntrinsicISizeType aType) {
return IntrinsicISizeFromInline(aInput.mContext, aType); return IntrinsicISizeFromInline(aInput, aType);
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@@ -8863,7 +8863,7 @@ static bool IsUnreflowedLetterFrame(nsIFrame* aFrame) {
// XXX Need to do something here to avoid incremental reflow bugs due to // XXX Need to do something here to avoid incremental reflow bugs due to
// first-line changing min-width // first-line changing min-width
/* virtual */ /* virtual */
void nsTextFrame::AddInlineMinISize(gfxContext* aRenderingContext, void nsTextFrame::AddInlineMinISize(const IntrinsicSizeInput& aInput,
InlineMinISizeData* aData) { InlineMinISizeData* aData) {
// Check if this textframe belongs to a first-letter frame that has not yet // Check if this textframe belongs to a first-letter frame that has not yet
// been reflowed; if so, we need to deal with splitting off a continuation // been reflowed; if so, we need to deal with splitting off a continuation
@@ -8902,7 +8902,7 @@ void nsTextFrame::AddInlineMinISize(gfxContext* aRenderingContext,
} }
// This will process all the text frames that share the same textrun as f. // This will process all the text frames that share the same textrun as f.
f->AddInlineMinISizeForFlow(aRenderingContext, aData, trtype); f->AddInlineMinISizeForFlow(aInput.mContext, aData, trtype);
lastTextRun = f->GetTextRun(trtype); lastTextRun = f->GetTextRun(trtype);
} }
} }
@@ -9030,7 +9030,7 @@ void nsTextFrame::AddInlinePrefISizeForFlow(gfxContext* aRenderingContext,
// XXX Need to do something here to avoid incremental reflow bugs due to // XXX Need to do something here to avoid incremental reflow bugs due to
// first-line and first-letter changing pref-width // first-line and first-letter changing pref-width
/* virtual */ /* virtual */
void nsTextFrame::AddInlinePrefISize(gfxContext* aRenderingContext, void nsTextFrame::AddInlinePrefISize(const IntrinsicSizeInput& aInput,
InlinePrefISizeData* aData) { InlinePrefISizeData* aData) {
float inflation = nsLayoutUtils::FontSizeInflationFor(this); float inflation = nsLayoutUtils::FontSizeInflationFor(this);
TextRunType trtype = (inflation == 1.0f) ? eNotInflated : eInflated; TextRunType trtype = (inflation == 1.0f) ? eNotInflated : eInflated;
@@ -9062,7 +9062,7 @@ void nsTextFrame::AddInlinePrefISize(gfxContext* aRenderingContext,
} }
// This will process all the text frames that share the same textrun as f. // This will process all the text frames that share the same textrun as f.
f->AddInlinePrefISizeForFlow(aRenderingContext, aData, trtype); f->AddInlinePrefISizeForFlow(aInput.mContext, aData, trtype);
lastTextRun = f->GetTextRun(trtype); lastTextRun = f->GetTextRun(trtype);
} }
} }

4
layout/generic/nsTextFrame.h
View File

@@ -397,9 +397,9 @@ class nsTextFrame : public nsIFrame {
nscoord IntrinsicISize(const mozilla::IntrinsicSizeInput& aInput, nscoord IntrinsicISize(const mozilla::IntrinsicSizeInput& aInput,
mozilla::IntrinsicISizeType aType) final; mozilla::IntrinsicISizeType aType) final;
void AddInlineMinISize(gfxContext* aRenderingContext, void AddInlineMinISize(const mozilla::IntrinsicSizeInput& aInput,
InlineMinISizeData* aData) override; InlineMinISizeData* aData) override;
void AddInlinePrefISize(gfxContext* aRenderingContext, void AddInlinePrefISize(const mozilla::IntrinsicSizeInput& aInput,
InlinePrefISizeData* aData) override; InlinePrefISizeData* aData) override;
SizeComputationResult ComputeSize( SizeComputationResult ComputeSize(
gfxContext* aRenderingContext, mozilla::WritingMode aWM, gfxContext* aRenderingContext, mozilla::WritingMode aWM,