Diff
Modified: trunk/Source/WebCore/ChangeLog (250234 => 250235)
--- trunk/Source/WebCore/ChangeLog 2019-09-23 15:54:58 UTC (rev 250234)
+++ trunk/Source/WebCore/ChangeLog 2019-09-23 16:14:21 UTC (rev 250235)
@@ -1,3 +1,31 @@
+2019-09-23 Zalan Bujtas <za...@apple.com>
+
+ [LFC][IFC] Pass in the Used*Values to inline layout functions.
+ https://bugs.webkit.org/show_bug.cgi?id=202091
+ <rdar://problem/55601987>
+
+ Reviewed by Antti Koivisto.
+
+ Only the top level layout functions should generate constraint values.
+
+ * layout/inlineformatting/InlineFormattingContext.cpp:
+ (WebCore::Layout::InlineFormattingContext::layoutInFlowContent):
+ (WebCore::Layout::InlineFormattingContext::computedIntrinsicWidthConstraints):
+ (WebCore::Layout::InlineFormattingContext::computeMarginBorderAndPaddingForInlineContainer):
+ (WebCore::Layout::InlineFormattingContext::computeIntrinsicWidthForFormattingRoot):
+ (WebCore::Layout::InlineFormattingContext::computeHorizontalMargin):
+ (WebCore::Layout::InlineFormattingContext::computeWidthAndMargin):
+ (WebCore::Layout::InlineFormattingContext::computeHeightAndMargin):
+ (WebCore::Layout::InlineFormattingContext::layoutFormattingContextRoot):
+ (WebCore::Layout::InlineFormattingContext::computeWidthAndHeightForReplacedInlineBox):
+ * layout/inlineformatting/InlineFormattingContext.h:
+ (WebCore::Layout::InlineFormattingContext::InlineLayout::widthConstraint const):
+ * layout/inlineformatting/InlineFormattingContextLineLayout.cpp:
+ (WebCore::Layout::InlineFormattingContext::InlineLayout::InlineLayout):
+ (WebCore::Layout::InlineFormattingContext::InlineLayout::layout):
+ (WebCore::Layout::InlineFormattingContext::InlineLayout::computedIntrinsicWidth const):
+ (WebCore::Layout::InlineFormattingContext::InlineLayout::createDisplayRuns):
+
2019-09-23 Antti Koivisto <an...@apple.com>
Refcount simple line layout
Modified: trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContext.cpp (250234 => 250235)
--- trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContext.cpp 2019-09-23 15:54:58 UTC (rev 250234)
+++ trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContext.cpp 2019-09-23 16:14:21 UTC (rev 250235)
@@ -69,16 +69,19 @@
return;
LOG_WITH_STREAM(FormattingContextLayout, stream << "[Start] -> inline formatting context -> formatting root(" << &root() << ")");
- auto usedValues = UsedHorizontalValues { UsedHorizontalValues::Constraints { geometryForBox(root()) } };
+ auto& rootGeometry = geometryForBox(root());
+ auto usedHorizontalValues = UsedHorizontalValues { UsedHorizontalValues::Constraints { rootGeometry } };
+ auto usedVerticalValues = UsedVerticalValues { UsedVerticalValues::Constraints { rootGeometry } };
auto* layoutBox = root().firstInFlowOrFloatingChild();
- // Compute width/height for non-text content and margin/border/padding for inline containers.
+ // 1. Visit each inline box and partially compute their geometry (margins, paddings and borders).
+ // 2. Collect the inline items (flatten the the layout tree) and place them on lines in bidirectional order.
while (layoutBox) {
if (layoutBox->establishesFormattingContext())
- layoutFormattingContextRoot(*layoutBox, usedValues);
+ layoutFormattingContextRoot(*layoutBox, usedHorizontalValues, usedVerticalValues);
else if (is<Container>(*layoutBox))
- computeMarginBorderAndPaddingForInlineContainer(downcast<Container>(*layoutBox), usedValues);
+ computeMarginBorderAndPaddingForInlineContainer(downcast<Container>(*layoutBox), usedHorizontalValues);
else if (layoutBox->isReplaced())
- computeWidthAndHeightForReplacedInlineBox(*layoutBox, usedValues);
+ computeWidthAndHeightForReplacedInlineBox(*layoutBox, usedHorizontalValues, usedVerticalValues);
else {
ASSERT(layoutBox->isInlineLevelBox());
initializeMarginBorderAndPaddingForGenericInlineBox(*layoutBox);
@@ -91,7 +94,7 @@
formattingState().inlineRuns().clear();
collectInlineContent();
- InlineLayout(*this).layout(formattingState().inlineItems(), usedValues.constraints.width);
+ InlineLayout(*this, usedHorizontalValues).layout(formattingState().inlineItems());
LOG_WITH_STREAM(FormattingContextLayout, stream << "[End] -> inline formatting context -> formatting root(" << &root() << ")");
}
@@ -107,21 +110,21 @@
}
Vector<const Box*> formattingContextRootList;
- auto usedValues = UsedHorizontalValues { UsedHorizontalValues::Constraints { { }, { } } };
+ auto usedHorizontalValues = UsedHorizontalValues { UsedHorizontalValues::Constraints { { }, { } } };
auto* layoutBox = root().firstInFlowOrFloatingChild();
while (layoutBox) {
if (layoutBox->establishesFormattingContext()) {
formattingContextRootList.append(layoutBox);
- computeIntrinsicWidthForFormattingRoot(*layoutBox);
+ computeIntrinsicWidthForFormattingRoot(*layoutBox, usedHorizontalValues);
} else if (layoutBox->isReplaced() || is<Container>(*layoutBox)) {
- computeBorderAndPadding(*layoutBox, usedValues);
+ computeBorderAndPadding(*layoutBox, usedHorizontalValues);
// inline-block and replaced.
auto needsWidthComputation = layoutBox->isReplaced();
if (needsWidthComputation)
- computeWidthAndMargin(*layoutBox, usedValues);
+ computeWidthAndMargin(*layoutBox, usedHorizontalValues);
else {
// Simple inline container with no intrinsic width <span>.
- computeHorizontalMargin(*layoutBox, usedValues);
+ computeHorizontalMargin(*layoutBox, usedHorizontalValues);
}
}
layoutBox = nextInPreOrder(*layoutBox, root());
@@ -137,7 +140,8 @@
auto contentWidth = (availableWidth ? intrinsicWidths->maximum : intrinsicWidths->minimum) - displayBox.horizontalMarginBorderAndPadding();
displayBox.setContentBoxWidth(contentWidth);
}
- return InlineLayout(*this).computedIntrinsicWidth(formattingState().inlineItems(), availableWidth);
+ auto usedHorizontalValues = UsedHorizontalValues { UsedHorizontalValues::Constraints { { }, availableWidth } };
+ return InlineLayout(*this, usedHorizontalValues).computedIntrinsicWidth(formattingState().inlineItems());
};
auto constraints = geometry().constrainByMinMaxWidth(root(), { maximumLineWidth(0), maximumLineWidth(LayoutUnit::max()) });
@@ -156,21 +160,20 @@
displayBox.setPadding({ });
}
-void InlineFormattingContext::computeMarginBorderAndPaddingForInlineContainer(const Container& container, UsedHorizontalValues usedValues)
+void InlineFormattingContext::computeMarginBorderAndPaddingForInlineContainer(const Container& container, UsedHorizontalValues usedHorizontalValues)
{
- computeHorizontalMargin(container, usedValues);
- computeBorderAndPadding(container, usedValues);
+ computeHorizontalMargin(container, usedHorizontalValues);
+ computeBorderAndPadding(container, usedHorizontalValues);
// Inline containers (<span>) have 0 vertical margins.
formattingState().displayBox(container).setVerticalMargin({ { }, { } });
}
-void InlineFormattingContext::computeIntrinsicWidthForFormattingRoot(const Box& formattingRoot)
+void InlineFormattingContext::computeIntrinsicWidthForFormattingRoot(const Box& formattingRoot, UsedHorizontalValues usedHorizontalValues)
{
ASSERT(formattingRoot.establishesFormattingContext());
- auto usedValues = UsedHorizontalValues { UsedHorizontalValues::Constraints { { }, { } } };
- computeBorderAndPadding(formattingRoot, usedValues);
- computeHorizontalMargin(formattingRoot, usedValues);
+ computeBorderAndPadding(formattingRoot, usedHorizontalValues);
+ computeHorizontalMargin(formattingRoot, usedHorizontalValues);
auto constraints = IntrinsicWidthConstraints { };
if (auto fixedWidth = geometry().fixedValue(formattingRoot.style().logicalWidth()))
@@ -182,23 +185,23 @@
formattingState().setIntrinsicWidthConstraintsForBox(formattingRoot, constraints);
}
-void InlineFormattingContext::computeHorizontalMargin(const Box& layoutBox, UsedHorizontalValues usedValues)
+void InlineFormattingContext::computeHorizontalMargin(const Box& layoutBox, UsedHorizontalValues usedHorizontalValues)
{
- auto computedHorizontalMargin = geometry().computedHorizontalMargin(layoutBox, usedValues);
+ auto computedHorizontalMargin = geometry().computedHorizontalMargin(layoutBox, usedHorizontalValues);
auto& displayBox = formattingState().displayBox(layoutBox);
displayBox.setHorizontalComputedMargin(computedHorizontalMargin);
displayBox.setHorizontalMargin({ computedHorizontalMargin.start.valueOr(0), computedHorizontalMargin.end.valueOr(0) });
}
-void InlineFormattingContext::computeWidthAndMargin(const Box& layoutBox, UsedHorizontalValues usedValues)
+void InlineFormattingContext::computeWidthAndMargin(const Box& layoutBox, UsedHorizontalValues usedHorizontalValues)
{
WidthAndMargin widthAndMargin;
if (layoutBox.isFloatingPositioned())
- widthAndMargin = geometry().floatingWidthAndMargin(layoutBox, usedValues);
+ widthAndMargin = geometry().floatingWidthAndMargin(layoutBox, usedHorizontalValues);
else if (layoutBox.isInlineBlockBox())
- widthAndMargin = geometry().inlineBlockWidthAndMargin(layoutBox, usedValues);
+ widthAndMargin = geometry().inlineBlockWidthAndMargin(layoutBox, usedHorizontalValues);
else if (layoutBox.replaced())
- widthAndMargin = geometry().inlineReplacedWidthAndMargin(layoutBox, usedValues);
+ widthAndMargin = geometry().inlineReplacedWidthAndMargin(layoutBox, usedHorizontalValues);
else
ASSERT_NOT_REACHED();
@@ -208,12 +211,9 @@
displayBox.setHorizontalComputedMargin(widthAndMargin.computedMargin);
}
-void InlineFormattingContext::computeHeightAndMargin(const Box& layoutBox)
+void InlineFormattingContext::computeHeightAndMargin(const Box& layoutBox, UsedHorizontalValues usedHorizontalValues, UsedVerticalValues usedVerticalValues)
{
HeightAndMargin heightAndMargin;
- auto& containingBlockGeometry = geometryForBox(*layoutBox.containingBlock());
- auto usedHorizontalValues = UsedHorizontalValues { UsedHorizontalValues::Constraints { containingBlockGeometry } };
- auto usedVerticalValues = UsedVerticalValues { UsedVerticalValues::Constraints { containingBlockGeometry } };
if (layoutBox.isFloatingPositioned())
heightAndMargin = geometry().floatingHeightAndMargin(layoutBox, usedHorizontalValues, usedVerticalValues);
else if (layoutBox.isInlineBlockBox())
@@ -228,7 +228,7 @@
displayBox.setVerticalMargin({ heightAndMargin.nonCollapsedMargin, { } });
}
-void InlineFormattingContext::layoutFormattingContextRoot(const Box& root, UsedHorizontalValues usedHorizontalValues)
+void InlineFormattingContext::layoutFormattingContextRoot(const Box& root, UsedHorizontalValues usedHorizontalValues, UsedVerticalValues usedVerticalValues)
{
ASSERT(root.isFloatingPositioned() || root.isInlineBlockBox());
@@ -242,14 +242,14 @@
auto formattingContext = LayoutContext::createFormattingContext(rootContainer, layoutState());
formattingContext->layoutInFlowContent();
// Come back and finalize the root's height and margin.
- computeHeightAndMargin(rootContainer);
+ computeHeightAndMargin(rootContainer, usedHorizontalValues, usedVerticalValues);
// Now that we computed the root's height, we can go back and layout the out-of-flow content.
formattingContext->layoutOutOfFlowContent();
} else
- computeHeightAndMargin(root);
+ computeHeightAndMargin(root, usedHorizontalValues, usedVerticalValues);
}
-void InlineFormattingContext::computeWidthAndHeightForReplacedInlineBox(const Box& layoutBox, UsedHorizontalValues usedHorizontalValues)
+void InlineFormattingContext::computeWidthAndHeightForReplacedInlineBox(const Box& layoutBox, UsedHorizontalValues usedHorizontalValues, UsedVerticalValues usedVerticalValues)
{
ASSERT(!layoutBox.isContainer());
ASSERT(!layoutBox.establishesFormattingContext());
@@ -257,7 +257,7 @@
computeBorderAndPadding(layoutBox, usedHorizontalValues);
computeWidthAndMargin(layoutBox, usedHorizontalValues);
- computeHeightAndMargin(layoutBox);
+ computeHeightAndMargin(layoutBox, usedHorizontalValues, usedVerticalValues);
}
void InlineFormattingContext::collectInlineContent()
Modified: trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContext.h (250234 => 250235)
--- trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContext.h 2019-09-23 15:54:58 UTC (rev 250234)
+++ trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContext.h 2019-09-23 16:14:21 UTC (rev 250235)
@@ -53,9 +53,9 @@
class InlineLayout {
public:
- InlineLayout(InlineFormattingContext&);
- void layout(const InlineItems&, LayoutUnit widthConstraint);
- LayoutUnit computedIntrinsicWidth(const InlineItems&, LayoutUnit widthConstraint) const;
+ InlineLayout(InlineFormattingContext&, UsedHorizontalValues);
+ void layout(const InlineItems&);
+ LayoutUnit computedIntrinsicWidth(const InlineItems&) const;
private:
LayoutState& layoutState() const { return m_inlineFormattingContext.layoutState(); }
@@ -62,12 +62,15 @@
InlineFormattingContext& formattingContext() const { return m_inlineFormattingContext; }
const Container& formattingRoot() const { return m_inlineFormattingContext.root(); }
InlineFormattingState& formattingState() { return m_inlineFormattingContext.formattingState(); }
+ LayoutUnit widthConstraint() const { return m_usedHorizontalValues.constraints.width; }
+
LineContent placeInlineItems(const LineInput&) const;
- void createDisplayRuns(const Line::Content&, const Vector<WeakPtr<InlineItem>>& floats, LayoutUnit widthConstraint);
+ void createDisplayRuns(const Line::Content&, const Vector<WeakPtr<InlineItem>>& floats);
void alignRuns(TextAlignMode, InlineRuns&, unsigned firstRunIndex, LayoutUnit availableWidth) const;
private:
InlineFormattingContext& m_inlineFormattingContext;
+ UsedHorizontalValues m_usedHorizontalValues;
};
class Quirks : public FormattingContext::Quirks {
@@ -98,13 +101,13 @@
};
InlineFormattingContext::Geometry geometry() const { return Geometry(*this); }
- void layoutFormattingContextRoot(const Box&, UsedHorizontalValues);
+ void layoutFormattingContextRoot(const Box&, UsedHorizontalValues, UsedVerticalValues);
void computeMarginBorderAndPaddingForInlineContainer(const Container&, UsedHorizontalValues);
void initializeMarginBorderAndPaddingForGenericInlineBox(const Box&);
- void computeIntrinsicWidthForFormattingRoot(const Box&);
- void computeWidthAndHeightForReplacedInlineBox(const Box&, UsedHorizontalValues);
+ void computeIntrinsicWidthForFormattingRoot(const Box&, UsedHorizontalValues);
+ void computeWidthAndHeightForReplacedInlineBox(const Box&, UsedHorizontalValues, UsedVerticalValues);
void computeHorizontalMargin(const Box&, UsedHorizontalValues);
- void computeHeightAndMargin(const Box&);
+ void computeHeightAndMargin(const Box&, UsedHorizontalValues, UsedVerticalValues);
void computeWidthAndMargin(const Box&, UsedHorizontalValues);
void collectInlineContent();
Modified: trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContextLineLayout.cpp (250234 => 250235)
--- trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContextLineLayout.cpp 2019-09-23 15:54:58 UTC (rev 250234)
+++ trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContextLineLayout.cpp 2019-09-23 16:14:21 UTC (rev 250235)
@@ -269,12 +269,13 @@
{
}
-InlineFormattingContext::InlineLayout::InlineLayout(InlineFormattingContext& inlineFormattingContext)
+InlineFormattingContext::InlineLayout::InlineLayout(InlineFormattingContext& inlineFormattingContext, UsedHorizontalValues usedHorizontalValues)
: m_inlineFormattingContext(inlineFormattingContext)
+ , m_usedHorizontalValues(usedHorizontalValues)
{
}
-void InlineFormattingContext::InlineLayout::layout(const InlineItems& inlineItems, LayoutUnit widthConstraint)
+void InlineFormattingContext::InlineLayout::layout(const InlineItems& inlineItems)
{
auto& formattingContext = this->formattingContext();
auto& formattingRoot = this->formattingRoot();
@@ -323,10 +324,10 @@
IndexAndRange currentInlineItem;
auto quirks = formattingContext.quirks();
while (currentInlineItem.index < inlineItems.size()) {
- auto lineInput = LineInput { { { lineLogicalLeft, lineLogicalTop }, widthConstraint, quirks.lineHeightConstraints(formattingRoot) }, Line::SkipVerticalAligment::No, currentInlineItem, inlineItems };
+ auto lineInput = LineInput { { { lineLogicalLeft, lineLogicalTop }, widthConstraint(), quirks.lineHeightConstraints(formattingRoot) }, Line::SkipVerticalAligment::No, currentInlineItem, inlineItems };
applyFloatConstraint(lineInput);
auto lineContent = LineLayout(formattingContext, lineInput).layout();
- createDisplayRuns(*lineContent.runs, lineContent.floats, widthConstraint);
+ createDisplayRuns(*lineContent.runs, lineContent.floats);
if (!lineContent.lastCommitted) {
// Floats prevented us putting any content on the line.
ASSERT(lineInput.floatMinimumLogicalBottom);
@@ -339,7 +340,7 @@
}
}
-LayoutUnit InlineFormattingContext::InlineLayout::computedIntrinsicWidth(const InlineItems& inlineItems, LayoutUnit widthConstraint) const
+LayoutUnit InlineFormattingContext::InlineLayout::computedIntrinsicWidth(const InlineItems& inlineItems) const
{
auto& formattingContext = this->formattingContext();
LayoutUnit maximumLineWidth;
@@ -346,7 +347,7 @@
IndexAndRange currentInlineItem;
auto quirks = formattingContext.quirks();
while (currentInlineItem.index < inlineItems.size()) {
- auto lineContent = LineLayout(formattingContext, { { { }, widthConstraint, quirks.lineHeightConstraints(formattingRoot()) }, Line::SkipVerticalAligment::Yes, currentInlineItem, inlineItems }).layout();
+ auto lineContent = LineLayout(formattingContext, { { { }, widthConstraint(), quirks.lineHeightConstraints(formattingRoot()) }, Line::SkipVerticalAligment::Yes, currentInlineItem, inlineItems }).layout();
currentInlineItem = { lineContent.lastCommitted->index + 1, WTF::nullopt };
LayoutUnit floatsWidth;
for (auto& floatItem : lineContent.floats)
@@ -356,7 +357,7 @@
return maximumLineWidth;
}
-void InlineFormattingContext::InlineLayout::createDisplayRuns(const Line::Content& lineContent, const Vector<WeakPtr<InlineItem>>& floats, LayoutUnit widthConstraint)
+void InlineFormattingContext::InlineLayout::createDisplayRuns(const Line::Content& lineContent, const Vector<WeakPtr<InlineItem>>& floats)
{
auto& formattingContext = this->formattingContext();
auto& formattingState = this->formattingState();
@@ -402,12 +403,11 @@
continue;
}
- auto usedHorizontalValues = UsedHorizontalValues { UsedHorizontalValues::Constraints { formattingContext.geometryForBox(*layoutBox.containingBlock()) } };
// Inline level box (replaced or inline-block)
if (lineRun->isBox()) {
auto topLeft = logicalRect.topLeft();
if (layoutBox.isInFlowPositioned())
- topLeft += geometry.inFlowPositionedPositionOffset(layoutBox, usedHorizontalValues);
+ topLeft += geometry.inFlowPositionedPositionOffset(layoutBox, m_usedHorizontalValues);
displayBox.setTopLeft(topLeft);
lineBoxRect.expandHorizontally(logicalRect.width());
formattingState.addInlineRun(makeUnique<Display::Run>(logicalRect));
@@ -424,7 +424,7 @@
// Inline level container end (</span>)
if (lineRun->isContainerEnd()) {
if (layoutBox.isInFlowPositioned()) {
- auto inflowOffset = geometry.inFlowPositionedPositionOffset(layoutBox, usedHorizontalValues);
+ auto inflowOffset = geometry.inFlowPositionedPositionOffset(layoutBox, m_usedHorizontalValues);
displayBox.moveHorizontally(inflowOffset.width());
displayBox.moveVertically(inflowOffset.height());
}
@@ -467,7 +467,7 @@
}
// FIXME linebox needs to be ajusted after content alignment.
formattingState.addLineBox({ lineBoxRect, lineContent.baseline(), lineContent.baselineOffset() });
- alignRuns(formattingRoot().style().textAlign(), inlineDisplayRuns, previousLineLastRunIndex.valueOr(-1) + 1, widthConstraint - lineContent.logicalWidth());
+ alignRuns(formattingRoot().style().textAlign(), inlineDisplayRuns, previousLineLastRunIndex.valueOr(-1) + 1, widthConstraint() - lineContent.logicalWidth());
}
static Optional<LayoutUnit> horizontalAdjustmentForAlignment(TextAlignMode align, LayoutUnit remainingWidth)
