Diff
Modified: trunk/Source/WebCore/ChangeLog (241121 => 241122)
--- trunk/Source/WebCore/ChangeLog 2019-02-07 16:07:03 UTC (rev 241121)
+++ trunk/Source/WebCore/ChangeLog 2019-02-07 16:33:07 UTC (rev 241122)
@@ -1,3 +1,72 @@
+2019-02-07 Zalan Bujtas <za...@apple.com>
+
+ [LFC] Use dedicated data structures for optional used values (input to geometry functions)
+ https://bugs.webkit.org/show_bug.cgi?id=194376
+
+ Reviewed by Antti Koivisto.
+
+ This is in preparation for being able to pass in the containing block's width as an optional used value.
+ During layout we always have a valid width for the containing block, however it's not the case while computing the preferred width.
+
+ * layout/FormattingContext.cpp:
+ (WebCore::Layout::FormattingContext::computeOutOfFlowHorizontalGeometry const):
+ (WebCore::Layout::FormattingContext::computeOutOfFlowVerticalGeometry const):
+ * layout/FormattingContext.h:
+ (WebCore::Layout::FormattingContext::Geometry::outOfFlowVerticalGeometry): Deleted.
+ (WebCore::Layout::FormattingContext::Geometry::outOfFlowHorizontalGeometry): Deleted.
+ (WebCore::Layout::FormattingContext::Geometry::floatingHeightAndMargin): Deleted.
+ (WebCore::Layout::FormattingContext::Geometry::floatingWidthAndMargin): Deleted.
+ (WebCore::Layout::FormattingContext::Geometry::inlineReplacedHeightAndMargin): Deleted.
+ (WebCore::Layout::FormattingContext::Geometry::inlineReplacedWidthAndMargin): Deleted.
+ (): Deleted.
+ (WebCore::Layout::FormattingContext::Geometry::complicatedCases): Deleted.
+ (WebCore::Layout::FormattingContext::Geometry::outOfFlowReplacedVerticalGeometry): Deleted.
+ (WebCore::Layout::FormattingContext::Geometry::outOfFlowReplacedHorizontalGeometry): Deleted.
+ (WebCore::Layout::FormattingContext::Geometry::outOfFlowNonReplacedVerticalGeometry): Deleted.
+ (WebCore::Layout::FormattingContext::Geometry::outOfFlowNonReplacedHorizontalGeometry): Deleted.
+ (WebCore::Layout::FormattingContext::Geometry::floatingReplacedHeightAndMargin): Deleted.
+ (WebCore::Layout::FormattingContext::Geometry::floatingReplacedWidthAndMargin): Deleted.
+ (WebCore::Layout::FormattingContext::Geometry::floatingNonReplacedWidthAndMargin): Deleted.
+ * layout/FormattingContextGeometry.cpp:
+ (WebCore::Layout::FormattingContext::Geometry::outOfFlowNonReplacedVerticalGeometry):
+ (WebCore::Layout::FormattingContext::Geometry::outOfFlowNonReplacedHorizontalGeometry):
+ (WebCore::Layout::FormattingContext::Geometry::outOfFlowReplacedVerticalGeometry):
+ (WebCore::Layout::FormattingContext::Geometry::outOfFlowReplacedHorizontalGeometry):
+ (WebCore::Layout::FormattingContext::Geometry::complicatedCases):
+ (WebCore::Layout::FormattingContext::Geometry::floatingNonReplacedWidthAndMargin):
+ (WebCore::Layout::FormattingContext::Geometry::floatingReplacedHeightAndMargin):
+ (WebCore::Layout::FormattingContext::Geometry::floatingReplacedWidthAndMargin):
+ (WebCore::Layout::FormattingContext::Geometry::outOfFlowVerticalGeometry):
+ (WebCore::Layout::FormattingContext::Geometry::outOfFlowHorizontalGeometry):
+ (WebCore::Layout::FormattingContext::Geometry::floatingHeightAndMargin):
+ (WebCore::Layout::FormattingContext::Geometry::floatingWidthAndMargin):
+ (WebCore::Layout::FormattingContext::Geometry::inlineReplacedHeightAndMargin):
+ (WebCore::Layout::FormattingContext::Geometry::inlineReplacedWidthAndMargin):
+ * layout/LayoutUnits.h:
+ * layout/blockformatting/BlockFormattingContext.cpp:
+ (WebCore::Layout::BlockFormattingContext::computeWidthAndMargin const):
+ (WebCore::Layout::BlockFormattingContext::computeHeightAndMargin const):
+ * layout/blockformatting/BlockFormattingContext.h:
+ (WebCore::Layout::BlockFormattingContext::Geometry::inFlowHeightAndMargin): Deleted.
+ (WebCore::Layout::BlockFormattingContext::Geometry::inFlowWidthAndMargin): Deleted.
+ (WebCore::Layout::BlockFormattingContext::Geometry::inFlowNonReplacedHeightAndMargin): Deleted.
+ (WebCore::Layout::BlockFormattingContext::Geometry::inFlowNonReplacedWidthAndMargin): Deleted.
+ (WebCore::Layout::BlockFormattingContext::Geometry::inFlowReplacedWidthAndMargin): Deleted.
+ * layout/blockformatting/BlockFormattingContextGeometry.cpp:
+ (WebCore::Layout::BlockFormattingContext::Geometry::inFlowNonReplacedHeightAndMargin):
+ (WebCore::Layout::BlockFormattingContext::Geometry::inFlowNonReplacedWidthAndMargin):
+ (WebCore::Layout::BlockFormattingContext::Geometry::inFlowReplacedWidthAndMargin):
+ (WebCore::Layout::BlockFormattingContext::Geometry::inFlowHeightAndMargin):
+ (WebCore::Layout::BlockFormattingContext::Geometry::inFlowWidthAndMargin):
+ * layout/inlineformatting/InlineFormattingContext.cpp:
+ (WebCore::Layout::InlineFormattingContext::computeWidthAndMargin const):
+ (WebCore::Layout::InlineFormattingContext::computeHeightAndMargin const):
+ * layout/inlineformatting/InlineFormattingContextGeometry.cpp:
+ (WebCore::Layout::InlineFormattingContext::Geometry::inlineBlockWidthAndMargin):
+ (WebCore::Layout::InlineFormattingContext::Geometry::inlineBlockHeightAndMargin):
+ * page/FrameViewLayoutContext.cpp:
+ (WebCore::layoutUsingFormattingContext):
+
2019-02-07 Antti Koivisto <an...@apple.com>
Infinite recursion via CachedResource::~CachedResource
Modified: trunk/Source/WebCore/layout/FormattingContext.cpp (241121 => 241122)
--- trunk/Source/WebCore/layout/FormattingContext.cpp 2019-02-07 16:07:03 UTC (rev 241121)
+++ trunk/Source/WebCore/layout/FormattingContext.cpp 2019-02-07 16:33:07 UTC (rev 241122)
@@ -68,8 +68,8 @@
{
auto& layoutState = this->layoutState();
- auto compute = [&](Optional<LayoutUnit> usedWidth) {
- return Geometry::outOfFlowHorizontalGeometry(layoutState, layoutBox, usedWidth);
+ auto compute = [&](UsedHorizontalValues usedValues) {
+ return Geometry::outOfFlowHorizontalGeometry(layoutState, layoutBox, usedValues);
};
auto horizontalGeometry = compute({ });
@@ -76,13 +76,13 @@
auto containingBlockWidth = layoutState.displayBoxForLayoutBox(*layoutBox.containingBlock()).contentBoxWidth();
if (auto maxWidth = Geometry::computedValueIfNotAuto(layoutBox.style().logicalMaxWidth(), containingBlockWidth)) {
- auto maxHorizontalGeometry = compute(maxWidth);
+ auto maxHorizontalGeometry = compute({ *maxWidth, { } });
if (horizontalGeometry.widthAndMargin.width > maxHorizontalGeometry.widthAndMargin.width)
horizontalGeometry = maxHorizontalGeometry;
}
if (auto minWidth = Geometry::computedValueIfNotAuto(layoutBox.style().logicalMinWidth(), containingBlockWidth)) {
- auto minHorizontalGeometry = compute(minWidth);
+ auto minHorizontalGeometry = compute({ *minWidth, { } });
if (horizontalGeometry.widthAndMargin.width < minHorizontalGeometry.widthAndMargin.width)
horizontalGeometry = minHorizontalGeometry;
}
@@ -98,19 +98,19 @@
{
auto& layoutState = this->layoutState();
- auto compute = [&](Optional<LayoutUnit> usedHeight) {
- return Geometry::outOfFlowVerticalGeometry(layoutState, layoutBox, usedHeight);
+ auto compute = [&](UsedVerticalValues usedValues) {
+ return Geometry::outOfFlowVerticalGeometry(layoutState, layoutBox, usedValues);
};
auto verticalGeometry = compute({ });
if (auto maxHeight = Geometry::computedMaxHeight(layoutState, layoutBox)) {
- auto maxVerticalGeometry = compute(maxHeight);
+ auto maxVerticalGeometry = compute({ *maxHeight });
if (verticalGeometry.heightAndMargin.height > maxVerticalGeometry.heightAndMargin.height)
verticalGeometry = maxVerticalGeometry;
}
if (auto minHeight = Geometry::computedMinHeight(layoutState, layoutBox)) {
- auto minVerticalGeometry = compute(minHeight);
+ auto minVerticalGeometry = compute({ *minHeight });
if (verticalGeometry.heightAndMargin.height < minVerticalGeometry.heightAndMargin.height)
verticalGeometry = minVerticalGeometry;
}
Modified: trunk/Source/WebCore/layout/FormattingContext.h (241121 => 241122)
--- trunk/Source/WebCore/layout/FormattingContext.h 2019-02-07 16:07:03 UTC (rev 241121)
+++ trunk/Source/WebCore/layout/FormattingContext.h 2019-02-07 16:33:07 UTC (rev 241122)
@@ -78,19 +78,18 @@
// This class implements generic positioning and sizing.
class Geometry {
public:
- static VerticalGeometry outOfFlowVerticalGeometry(const LayoutState&, const Box&, Optional<LayoutUnit> usedHeight = { });
- static HorizontalGeometry outOfFlowHorizontalGeometry(LayoutState&, const Box&, Optional<LayoutUnit> usedWidth = { });
+ static VerticalGeometry outOfFlowVerticalGeometry(const LayoutState&, const Box&, UsedVerticalValues);
+ static HorizontalGeometry outOfFlowHorizontalGeometry(LayoutState&, const Box&, UsedHorizontalValues);
- static HeightAndMargin floatingHeightAndMargin(const LayoutState&, const Box&, Optional<LayoutUnit> usedHeight = { });
- static WidthAndMargin floatingWidthAndMargin(LayoutState&, const Box&, Optional<LayoutUnit> usedWidth = { });
+ static HeightAndMargin floatingHeightAndMargin(const LayoutState&, const Box&, UsedVerticalValues);
+ static WidthAndMargin floatingWidthAndMargin(LayoutState&, const Box&, UsedHorizontalValues);
- static HeightAndMargin inlineReplacedHeightAndMargin(const LayoutState&, const Box&, Optional<LayoutUnit> usedHeight = { });
- static WidthAndMargin inlineReplacedWidthAndMargin(const LayoutState&, const Box&, Optional<LayoutUnit> usedWidth = { },
- Optional<LayoutUnit> precomputedMarginStart = { }, Optional<LayoutUnit> precomputedMarginEnd = { });
+ static HeightAndMargin inlineReplacedHeightAndMargin(const LayoutState&, const Box&, UsedVerticalValues);
+ static WidthAndMargin inlineReplacedWidthAndMargin(const LayoutState&, const Box&, UsedHorizontalValues);
static LayoutSize inFlowPositionedPositionOffset(const LayoutState&, const Box&);
- static HeightAndMargin complicatedCases(const LayoutState&, const Box&, Optional<LayoutUnit> usedHeight = { });
+ static HeightAndMargin complicatedCases(const LayoutState&, const Box&, UsedVerticalValues);
static LayoutUnit shrinkToFitWidth(LayoutState&, const Box&);
static Edges computedBorder(const LayoutState&, const Box&);
@@ -110,16 +109,16 @@
static Optional<LayoutUnit> computedHeightValue(const LayoutState&, const Box&, HeightType);
private:
- static VerticalGeometry outOfFlowReplacedVerticalGeometry(const LayoutState&, const Box&, Optional<LayoutUnit> usedHeight = { });
- static HorizontalGeometry outOfFlowReplacedHorizontalGeometry(const LayoutState&, const Box&, Optional<LayoutUnit> usedWidth = { });
+ static VerticalGeometry outOfFlowReplacedVerticalGeometry(const LayoutState&, const Box&, UsedVerticalValues);
+ static HorizontalGeometry outOfFlowReplacedHorizontalGeometry(const LayoutState&, const Box&, UsedHorizontalValues);
- static VerticalGeometry outOfFlowNonReplacedVerticalGeometry(const LayoutState&, const Box&, Optional<LayoutUnit> usedHeight = { });
- static HorizontalGeometry outOfFlowNonReplacedHorizontalGeometry(LayoutState&, const Box&, Optional<LayoutUnit> usedWidth = { });
+ static VerticalGeometry outOfFlowNonReplacedVerticalGeometry(const LayoutState&, const Box&, UsedVerticalValues);
+ static HorizontalGeometry outOfFlowNonReplacedHorizontalGeometry(LayoutState&, const Box&, UsedHorizontalValues);
- static HeightAndMargin floatingReplacedHeightAndMargin(const LayoutState&, const Box&, Optional<LayoutUnit> usedHeight = { });
- static WidthAndMargin floatingReplacedWidthAndMargin(const LayoutState&, const Box&, Optional<LayoutUnit> usedWidth = { });
+ static HeightAndMargin floatingReplacedHeightAndMargin(const LayoutState&, const Box&, UsedVerticalValues);
+ static WidthAndMargin floatingReplacedWidthAndMargin(const LayoutState&, const Box&, UsedHorizontalValues);
- static WidthAndMargin floatingNonReplacedWidthAndMargin(LayoutState&, const Box&, Optional<LayoutUnit> usedWidth = { });
+ static WidthAndMargin floatingNonReplacedWidthAndMargin(LayoutState&, const Box&, UsedHorizontalValues);
};
class Quirks {
Modified: trunk/Source/WebCore/layout/FormattingContextGeometry.cpp (241121 => 241122)
--- trunk/Source/WebCore/layout/FormattingContextGeometry.cpp 2019-02-07 16:07:03 UTC (rev 241121)
+++ trunk/Source/WebCore/layout/FormattingContextGeometry.cpp 2019-02-07 16:33:07 UTC (rev 241122)
@@ -251,7 +251,7 @@
return std::min(std::max(instrinsicWidthConstraints.minimum, availableWidth), instrinsicWidthConstraints.maximum);
}
-VerticalGeometry FormattingContext::Geometry::outOfFlowNonReplacedVerticalGeometry(const LayoutState& layoutState, const Box& layoutBox, Optional<LayoutUnit> usedHeight)
+VerticalGeometry FormattingContext::Geometry::outOfFlowNonReplacedVerticalGeometry(const LayoutState& layoutState, const Box& layoutBox, UsedVerticalValues usedValues)
{
ASSERT(layoutBox.isOutOfFlowPositioned() && !layoutBox.replaced());
@@ -288,7 +288,7 @@
auto top = computedValueIfNotAuto(style.logicalTop(), containingBlockWidth);
auto bottom = computedValueIfNotAuto(style.logicalBottom(), containingBlockWidth);
auto isStaticallyPositioned = !top && !bottom;
- auto height = usedHeight ? usedHeight.value() : computedHeightValue(layoutState, layoutBox, HeightType::Normal);
+ auto height = usedValues.height ? usedValues.height.value() : computedHeightValue(layoutState, layoutBox, HeightType::Normal);
auto computedVerticalMargin = Geometry::computedVerticalMargin(layoutState, layoutBox);
UsedVerticalMargin::NonCollapsedValues usedVerticalMargin;
auto paddingTop = displayBox.paddingTop().valueOr(0);
@@ -376,7 +376,7 @@
return { *top, *bottom, { contentHeight(), usedVerticalMargin } };
}
-HorizontalGeometry FormattingContext::Geometry::outOfFlowNonReplacedHorizontalGeometry(LayoutState& layoutState, const Box& layoutBox, Optional<LayoutUnit> usedWidth)
+HorizontalGeometry FormattingContext::Geometry::outOfFlowNonReplacedHorizontalGeometry(LayoutState& layoutState, const Box& layoutBox, UsedHorizontalValues usedValues)
{
ASSERT(layoutBox.isOutOfFlowPositioned() && !layoutBox.replaced());
@@ -416,7 +416,7 @@
auto left = computedValueIfNotAuto(style.logicalLeft(), containingBlockWidth);
auto right = computedValueIfNotAuto(style.logicalRight(), containingBlockWidth);
auto isStaticallyPositioned = !left && !right;
- auto width = computedValueIfNotAuto(usedWidth ? Length { usedWidth.value(), Fixed } : style.logicalWidth(), containingBlockWidth);
+ auto width = computedValueIfNotAuto(usedValues.width ? Length { usedValues.width.value(), Fixed } : style.logicalWidth(), containingBlockWidth);
auto computedHorizontalMargin = Geometry::computedHorizontalMargin(layoutState, layoutBox);
UsedHorizontalMargin usedHorizontalMargin;
auto paddingLeft = displayBox.paddingLeft().valueOr(0);
@@ -530,7 +530,7 @@
return { *left, *right, { contentWidth(), usedHorizontalMargin, computedHorizontalMargin } };
}
-VerticalGeometry FormattingContext::Geometry::outOfFlowReplacedVerticalGeometry(const LayoutState& layoutState, const Box& layoutBox, Optional<LayoutUnit> usedHeight)
+VerticalGeometry FormattingContext::Geometry::outOfFlowReplacedVerticalGeometry(const LayoutState& layoutState, const Box& layoutBox, UsedVerticalValues usedValues)
{
ASSERT(layoutBox.isOutOfFlowPositioned() && layoutBox.replaced());
@@ -553,7 +553,7 @@
auto top = computedValueIfNotAuto(style.logicalTop(), containingBlockWidth);
auto bottom = computedValueIfNotAuto(style.logicalBottom(), containingBlockWidth);
auto isStaticallyPositioned = !top && !bottom;
- auto height = inlineReplacedHeightAndMargin(layoutState, layoutBox, usedHeight).height;
+ auto height = inlineReplacedHeightAndMargin(layoutState, layoutBox, usedValues).height;
auto computedVerticalMargin = Geometry::computedVerticalMargin(layoutState, layoutBox);
Optional<LayoutUnit> usedMarginBefore = computedVerticalMargin.before;
Optional<LayoutUnit> usedMarginAfter = computedVerticalMargin.after;
@@ -614,7 +614,7 @@
return { *top, *bottom, { height, { *usedMarginBefore, *usedMarginAfter } } };
}
-HorizontalGeometry FormattingContext::Geometry::outOfFlowReplacedHorizontalGeometry(const LayoutState& layoutState, const Box& layoutBox, Optional<LayoutUnit> usedWidth)
+HorizontalGeometry FormattingContext::Geometry::outOfFlowReplacedHorizontalGeometry(const LayoutState& layoutState, const Box& layoutBox, UsedHorizontalValues usedValues)
{
ASSERT(layoutBox.isOutOfFlowPositioned() && layoutBox.replaced());
@@ -645,7 +645,7 @@
auto computedHorizontalMargin = Geometry::computedHorizontalMargin(layoutState, layoutBox);
Optional<LayoutUnit> usedMarginStart = computedHorizontalMargin.start;
Optional<LayoutUnit> usedMarginEnd = computedHorizontalMargin.end;
- auto width = inlineReplacedWidthAndMargin(layoutState, layoutBox, usedWidth).width;
+ auto width = inlineReplacedWidthAndMargin(layoutState, layoutBox, usedValues).width;
auto paddingLeft = displayBox.paddingLeft().valueOr(0);
auto paddingRight = displayBox.paddingRight().valueOr(0);
auto borderLeft = displayBox.borderLeft();
@@ -722,7 +722,7 @@
return { *left, *right, { width, { *usedMarginStart, *usedMarginEnd }, computedHorizontalMargin } };
}
-HeightAndMargin FormattingContext::Geometry::complicatedCases(const LayoutState& layoutState, const Box& layoutBox, Optional<LayoutUnit> usedHeight)
+HeightAndMargin FormattingContext::Geometry::complicatedCases(const LayoutState& layoutState, const Box& layoutBox, UsedVerticalValues usedValues)
{
ASSERT(!layoutBox.replaced());
// TODO: Use complicated-case for document renderer for now (see BlockFormattingContext::Geometry::inFlowHeightAndMargin).
@@ -737,7 +737,7 @@
// 1. If 'margin-top', or 'margin-bottom' are 'auto', their used value is 0.
// 2. If 'height' is 'auto', the height depends on the element's descendants per 10.6.7.
- auto height = usedHeight ? usedHeight.value() : computedHeightValue(layoutState, layoutBox, HeightType::Normal);
+ auto height = usedValues.height ? usedValues.height.value() : computedHeightValue(layoutState, layoutBox, HeightType::Normal);
auto computedVerticalMargin = Geometry::computedVerticalMargin(layoutState, layoutBox);
// #1
auto usedVerticalMargin = UsedVerticalMargin::NonCollapsedValues { computedVerticalMargin.before.valueOr(0), computedVerticalMargin.after.valueOr(0) };
@@ -753,7 +753,7 @@
return HeightAndMargin { *height, usedVerticalMargin };
}
-WidthAndMargin FormattingContext::Geometry::floatingNonReplacedWidthAndMargin(LayoutState& layoutState, const Box& layoutBox, Optional<LayoutUnit> usedWidth)
+WidthAndMargin FormattingContext::Geometry::floatingNonReplacedWidthAndMargin(LayoutState& layoutState, const Box& layoutBox, UsedHorizontalValues usedValues)
{
ASSERT(layoutBox.isFloatingPositioned() && !layoutBox.replaced());
@@ -769,7 +769,7 @@
// #1
auto usedHorizontallMargin = UsedHorizontalMargin { computedHorizontalMargin.start.valueOr(0), computedHorizontalMargin.end.valueOr(0) };
// #2
- auto width = computedValueIfNotAuto(usedWidth ? Length { usedWidth.value(), Fixed } : layoutBox.style().logicalWidth(), containingBlockWidth);
+ auto width = computedValueIfNotAuto(usedValues.width ? Length { usedValues.width.value(), Fixed } : layoutBox.style().logicalWidth(), containingBlockWidth);
if (!width)
width = shrinkToFitWidth(layoutState, layoutBox);
@@ -777,7 +777,7 @@
return WidthAndMargin { *width, usedHorizontallMargin, computedHorizontalMargin };
}
-HeightAndMargin FormattingContext::Geometry::floatingReplacedHeightAndMargin(const LayoutState& layoutState, const Box& layoutBox, Optional<LayoutUnit> usedHeight)
+HeightAndMargin FormattingContext::Geometry::floatingReplacedHeightAndMargin(const LayoutState& layoutState, const Box& layoutBox, UsedVerticalValues usedValues)
{
ASSERT(layoutBox.isFloatingPositioned() && layoutBox.replaced());
@@ -784,10 +784,10 @@
// 10.6.2 Inline replaced elements, block-level replaced elements in normal flow, 'inline-block'
// replaced elements in normal flow and floating replaced elements
LOG_WITH_STREAM(FormattingContextLayout, stream << "[Height][Margin] -> floating replaced -> redirected to inline replaced");
- return inlineReplacedHeightAndMargin(layoutState, layoutBox, usedHeight);
+ return inlineReplacedHeightAndMargin(layoutState, layoutBox, usedValues);
}
-WidthAndMargin FormattingContext::Geometry::floatingReplacedWidthAndMargin(const LayoutState& layoutState, const Box& layoutBox, Optional<LayoutUnit> usedWidth)
+WidthAndMargin FormattingContext::Geometry::floatingReplacedWidthAndMargin(const LayoutState& layoutState, const Box& layoutBox, UsedHorizontalValues usedValues)
{
ASSERT(layoutBox.isFloatingPositioned() && layoutBox.replaced());
@@ -798,46 +798,46 @@
auto computedHorizontalMargin = Geometry::computedHorizontalMargin(layoutState, layoutBox);
LOG_WITH_STREAM(FormattingContextLayout, stream << "[Height][Margin] -> floating replaced -> redirected to inline replaced");
- return inlineReplacedWidthAndMargin(layoutState, layoutBox, usedWidth, computedHorizontalMargin.start, computedHorizontalMargin.end);
+ return inlineReplacedWidthAndMargin(layoutState, layoutBox, { usedValues.width, UsedHorizontalMargin { computedHorizontalMargin.start.valueOr(0), computedHorizontalMargin.end.valueOr(0) } });
}
-VerticalGeometry FormattingContext::Geometry::outOfFlowVerticalGeometry(const LayoutState& layoutState, const Box& layoutBox, Optional<LayoutUnit> usedHeight)
+VerticalGeometry FormattingContext::Geometry::outOfFlowVerticalGeometry(const LayoutState& layoutState, const Box& layoutBox, UsedVerticalValues usedValues)
{
ASSERT(layoutBox.isOutOfFlowPositioned());
if (!layoutBox.replaced())
- return outOfFlowNonReplacedVerticalGeometry(layoutState, layoutBox, usedHeight);
- return outOfFlowReplacedVerticalGeometry(layoutState, layoutBox, usedHeight);
+ return outOfFlowNonReplacedVerticalGeometry(layoutState, layoutBox, usedValues);
+ return outOfFlowReplacedVerticalGeometry(layoutState, layoutBox, usedValues);
}
-HorizontalGeometry FormattingContext::Geometry::outOfFlowHorizontalGeometry(LayoutState& layoutState, const Box& layoutBox, Optional<LayoutUnit> usedWidth)
+HorizontalGeometry FormattingContext::Geometry::outOfFlowHorizontalGeometry(LayoutState& layoutState, const Box& layoutBox, UsedHorizontalValues usedValues)
{
ASSERT(layoutBox.isOutOfFlowPositioned());
if (!layoutBox.replaced())
- return outOfFlowNonReplacedHorizontalGeometry(layoutState, layoutBox, usedWidth);
- return outOfFlowReplacedHorizontalGeometry(layoutState, layoutBox, usedWidth);
+ return outOfFlowNonReplacedHorizontalGeometry(layoutState, layoutBox, usedValues);
+ return outOfFlowReplacedHorizontalGeometry(layoutState, layoutBox, usedValues);
}
-HeightAndMargin FormattingContext::Geometry::floatingHeightAndMargin(const LayoutState& layoutState, const Box& layoutBox, Optional<LayoutUnit> usedHeight)
+HeightAndMargin FormattingContext::Geometry::floatingHeightAndMargin(const LayoutState& layoutState, const Box& layoutBox, UsedVerticalValues usedValues)
{
ASSERT(layoutBox.isFloatingPositioned());
if (!layoutBox.replaced())
- return complicatedCases(layoutState, layoutBox, usedHeight);
- return floatingReplacedHeightAndMargin(layoutState, layoutBox, usedHeight);
+ return complicatedCases(layoutState, layoutBox, usedValues);
+ return floatingReplacedHeightAndMargin(layoutState, layoutBox, usedValues);
}
-WidthAndMargin FormattingContext::Geometry::floatingWidthAndMargin(LayoutState& layoutState, const Box& layoutBox, Optional<LayoutUnit> usedWidth)
+WidthAndMargin FormattingContext::Geometry::floatingWidthAndMargin(LayoutState& layoutState, const Box& layoutBox, UsedHorizontalValues usedValues)
{
ASSERT(layoutBox.isFloatingPositioned());
if (!layoutBox.replaced())
- return floatingNonReplacedWidthAndMargin(layoutState, layoutBox, usedWidth);
- return floatingReplacedWidthAndMargin(layoutState, layoutBox, usedWidth);
+ return floatingNonReplacedWidthAndMargin(layoutState, layoutBox, usedValues);
+ return floatingReplacedWidthAndMargin(layoutState, layoutBox, usedValues);
}
-HeightAndMargin FormattingContext::Geometry::inlineReplacedHeightAndMargin(const LayoutState& layoutState, const Box& layoutBox, Optional<LayoutUnit> usedHeight)
+HeightAndMargin FormattingContext::Geometry::inlineReplacedHeightAndMargin(const LayoutState& layoutState, const Box& layoutBox, UsedVerticalValues usedValues)
{
ASSERT((layoutBox.isOutOfFlowPositioned() || layoutBox.isFloatingPositioned() || layoutBox.isInFlow()) && layoutBox.replaced());
@@ -857,8 +857,8 @@
auto& style = layoutBox.style();
auto replaced = layoutBox.replaced();
- auto height = usedHeight ? usedHeight.value() : computedHeightValue(layoutState, layoutBox, HeightType::Normal);
- auto heightIsAuto = !usedHeight && isHeightAuto(layoutBox);
+ auto height = usedValues.height ? usedValues.height.value() : computedHeightValue(layoutState, layoutBox, HeightType::Normal);
+ auto heightIsAuto = !usedValues.height && isHeightAuto(layoutBox);
auto widthIsAuto = style.logicalWidth().isAuto();
if (heightIsAuto && widthIsAuto && replaced->hasIntrinsicHeight()) {
@@ -882,8 +882,7 @@
return { *height, usedVerticalMargin };
}
-WidthAndMargin FormattingContext::Geometry::inlineReplacedWidthAndMargin(const LayoutState& layoutState, const Box& layoutBox,
- Optional<LayoutUnit> usedWidth, Optional<LayoutUnit> precomputedMarginStart, Optional<LayoutUnit> precomputedMarginEnd)
+WidthAndMargin FormattingContext::Geometry::inlineReplacedWidthAndMargin(const LayoutState& layoutState, const Box& layoutBox, UsedHorizontalValues usedValues)
{
ASSERT((layoutBox.isOutOfFlowPositioned() || layoutBox.isFloatingPositioned() || layoutBox.isInFlow()) && layoutBox.replaced());
@@ -912,17 +911,21 @@
auto computedHorizontalMargin = Geometry::computedHorizontalMargin(layoutState, layoutBox);
auto usedMarginStart = [&] {
- return precomputedMarginStart.valueOr(computedHorizontalMargin.start.valueOr(0_lu));
+ if (usedValues.margin)
+ return usedValues.margin->start;
+ return computedHorizontalMargin.start.valueOr(0_lu);
};
auto usedMarginEnd = [&] {
- return precomputedMarginEnd.valueOr(computedHorizontalMargin.end.valueOr(0_lu));
+ if (usedValues.margin)
+ return usedValues.margin->end;
+ return computedHorizontalMargin.end.valueOr(0_lu);
};
auto replaced = layoutBox.replaced();
ASSERT(replaced);
- auto width = computedValueIfNotAuto(usedWidth ? Length { usedWidth.value(), Fixed } : style.logicalWidth(), containingBlockWidth);
+ auto width = computedValueIfNotAuto(usedValues.width ? Length { usedValues.width.value(), Fixed } : style.logicalWidth(), containingBlockWidth);
auto heightIsAuto = isHeightAuto(layoutBox);
auto height = computedHeightValue(layoutState, layoutBox, HeightType::Normal);
Modified: trunk/Source/WebCore/layout/LayoutUnits.h (241121 => 241122)
--- trunk/Source/WebCore/layout/LayoutUnits.h 2019-02-07 16:07:03 UTC (rev 241121)
+++ trunk/Source/WebCore/layout/LayoutUnits.h 2019-02-07 16:33:07 UTC (rev 241122)
@@ -124,6 +124,15 @@
HeightAndMargin heightAndMargin;
};
+struct UsedHorizontalValues {
+ Optional<LayoutUnit> width;
+ Optional<UsedHorizontalMargin> margin;
+};
+
+struct UsedVerticalValues {
+ Optional<LayoutUnit> height;
+};
+
}
}
#endif
Modified: trunk/Source/WebCore/layout/blockformatting/BlockFormattingContext.cpp (241121 => 241122)
--- trunk/Source/WebCore/layout/blockformatting/BlockFormattingContext.cpp 2019-02-07 16:07:03 UTC (rev 241121)
+++ trunk/Source/WebCore/layout/blockformatting/BlockFormattingContext.cpp 2019-02-07 16:33:07 UTC (rev 241122)
@@ -299,13 +299,13 @@
{
auto& layoutState = this->layoutState();
- auto compute = [&](Optional<LayoutUnit> usedWidth) -> WidthAndMargin {
+ auto compute = [&](UsedHorizontalValues usedValues) -> WidthAndMargin {
if (layoutBox.isInFlow())
- return Geometry::inFlowWidthAndMargin(layoutState, layoutBox, usedWidth);
+ return Geometry::inFlowWidthAndMargin(layoutState, layoutBox, usedValues);
if (layoutBox.isFloatingPositioned())
- return Geometry::floatingWidthAndMargin(layoutState, layoutBox, usedWidth);
+ return Geometry::floatingWidthAndMargin(layoutState, layoutBox, usedValues);
ASSERT_NOT_REACHED();
return { };
@@ -315,13 +315,13 @@
auto containingBlockWidth = layoutState.displayBoxForLayoutBox(*layoutBox.containingBlock()).contentBoxWidth();
if (auto maxWidth = Geometry::computedValueIfNotAuto(layoutBox.style().logicalMaxWidth(), containingBlockWidth)) {
- auto maxWidthAndMargin = compute(maxWidth);
+ auto maxWidthAndMargin = compute({ *maxWidth, { } });
if (widthAndMargin.width > maxWidthAndMargin.width)
widthAndMargin = maxWidthAndMargin;
}
auto minWidth = Geometry::computedValueIfNotAuto(layoutBox.style().logicalMinWidth(), containingBlockWidth).valueOr(0);
- auto minWidthAndMargin = compute(minWidth);
+ auto minWidthAndMargin = compute({ minWidth, { } });
if (widthAndMargin.width < minWidthAndMargin.width)
widthAndMargin = minWidthAndMargin;
@@ -335,13 +335,13 @@
{
auto& layoutState = this->layoutState();
- auto compute = [&](Optional<LayoutUnit> usedHeight) -> HeightAndMargin {
+ auto compute = [&](UsedVerticalValues usedValues) -> HeightAndMargin {
if (layoutBox.isInFlow())
- return Geometry::inFlowHeightAndMargin(layoutState, layoutBox, usedHeight);
+ return Geometry::inFlowHeightAndMargin(layoutState, layoutBox, usedValues);
if (layoutBox.isFloatingPositioned())
- return Geometry::floatingHeightAndMargin(layoutState, layoutBox, usedHeight);
+ return Geometry::floatingHeightAndMargin(layoutState, layoutBox, usedValues);
ASSERT_NOT_REACHED();
return { };
@@ -350,7 +350,7 @@
auto heightAndMargin = compute({ });
if (auto maxHeight = Geometry::computedMaxHeight(layoutState, layoutBox)) {
if (heightAndMargin.height > *maxHeight) {
- auto maxHeightAndMargin = compute(maxHeight);
+ auto maxHeightAndMargin = compute({ *maxHeight });
// Used height should remain the same.
ASSERT((layoutState.inQuirksMode() && (layoutBox.isBodyBox() || layoutBox.isDocumentBox())) || maxHeightAndMargin.height == *maxHeight);
heightAndMargin = { *maxHeight, maxHeightAndMargin.nonCollapsedMargin };
@@ -359,7 +359,7 @@
if (auto minHeight = Geometry::computedMinHeight(layoutState, layoutBox)) {
if (heightAndMargin.height < *minHeight) {
- auto minHeightAndMargin = compute(minHeight);
+ auto minHeightAndMargin = compute({ *minHeight });
// Used height should remain the same.
ASSERT((layoutState.inQuirksMode() && (layoutBox.isBodyBox() || layoutBox.isDocumentBox())) || minHeightAndMargin.height == *minHeight);
heightAndMargin = { *minHeight, minHeightAndMargin.nonCollapsedMargin };
Modified: trunk/Source/WebCore/layout/blockformatting/BlockFormattingContext.h (241121 => 241122)
--- trunk/Source/WebCore/layout/blockformatting/BlockFormattingContext.h 2019-02-07 16:07:03 UTC (rev 241121)
+++ trunk/Source/WebCore/layout/blockformatting/BlockFormattingContext.h 2019-02-07 16:33:07 UTC (rev 241122)
@@ -73,8 +73,8 @@
// This class implements positioning and sizing for boxes participating in a block formatting context.
class Geometry : public FormattingContext::Geometry {
public:
- static HeightAndMargin inFlowHeightAndMargin(const LayoutState&, const Box&, Optional<LayoutUnit> usedHeight = { });
- static WidthAndMargin inFlowWidthAndMargin(const LayoutState&, const Box&, Optional<LayoutUnit> usedWidth = { });
+ static HeightAndMargin inFlowHeightAndMargin(const LayoutState&, const Box&, UsedVerticalValues);
+ static WidthAndMargin inFlowWidthAndMargin(const LayoutState&, const Box&, UsedHorizontalValues);
static Point staticPosition(const LayoutState&, const Box&);
@@ -82,9 +82,9 @@
static InstrinsicWidthConstraints instrinsicWidthConstraints(const LayoutState&, const Box&);
private:
- static HeightAndMargin inFlowNonReplacedHeightAndMargin(const LayoutState&, const Box&, Optional<LayoutUnit> usedHeight = { });
- static WidthAndMargin inFlowNonReplacedWidthAndMargin(const LayoutState&, const Box&, Optional<LayoutUnit> usedWidth = { });
- static WidthAndMargin inFlowReplacedWidthAndMargin(const LayoutState&, const Box&, Optional<LayoutUnit> usedWidth = { });
+ static HeightAndMargin inFlowNonReplacedHeightAndMargin(const LayoutState&, const Box&, UsedVerticalValues);
+ static WidthAndMargin inFlowNonReplacedWidthAndMargin(const LayoutState&, const Box&, UsedHorizontalValues);
+ static WidthAndMargin inFlowReplacedWidthAndMargin(const LayoutState&, const Box&, UsedHorizontalValues);
static Point staticPositionForOutOfFlowPositioned(const LayoutState&, const Box&);
};
Modified: trunk/Source/WebCore/layout/blockformatting/BlockFormattingContextGeometry.cpp (241121 => 241122)
--- trunk/Source/WebCore/layout/blockformatting/BlockFormattingContextGeometry.cpp 2019-02-07 16:07:03 UTC (rev 241121)
+++ trunk/Source/WebCore/layout/blockformatting/BlockFormattingContextGeometry.cpp 2019-02-07 16:33:07 UTC (rev 241122)
@@ -37,7 +37,7 @@
namespace WebCore {
namespace Layout {
-HeightAndMargin BlockFormattingContext::Geometry::inFlowNonReplacedHeightAndMargin(const LayoutState& layoutState, const Box& layoutBox, Optional<LayoutUnit> usedHeight)
+HeightAndMargin BlockFormattingContext::Geometry::inFlowNonReplacedHeightAndMargin(const LayoutState& layoutState, const Box& layoutBox, UsedVerticalValues usedValues)
{
ASSERT(layoutBox.isInFlow() && !layoutBox.replaced());
ASSERT(layoutBox.isOverflowVisible());
@@ -61,7 +61,7 @@
auto computedVerticalMargin = Geometry::computedVerticalMargin(layoutState, layoutBox);
auto nonCollapsedMargin = UsedVerticalMargin::NonCollapsedValues { computedVerticalMargin.before.valueOr(0), computedVerticalMargin.after.valueOr(0) };
auto borderAndPaddingTop = displayBox.borderTop() + displayBox.paddingTop().valueOr(0);
- auto height = usedHeight ? usedHeight.value() : computedHeightValue(layoutState, layoutBox, HeightType::Normal);
+ auto height = usedValues.height ? usedValues.height.value() : computedHeightValue(layoutState, layoutBox, HeightType::Normal);
if (height) {
auto borderAndPaddingBottom = displayBox.borderBottom() + displayBox.paddingBottom().valueOr(0);
@@ -107,7 +107,7 @@
return heightAndMargin;
}
-WidthAndMargin BlockFormattingContext::Geometry::inFlowNonReplacedWidthAndMargin(const LayoutState& layoutState, const Box& layoutBox, Optional<LayoutUnit> usedWidth)
+WidthAndMargin BlockFormattingContext::Geometry::inFlowNonReplacedWidthAndMargin(const LayoutState& layoutState, const Box& layoutBox, UsedHorizontalValues usedValues)
{
ASSERT(layoutBox.isInFlow());
@@ -139,7 +139,7 @@
auto containingBlockWidth = layoutState.displayBoxForLayoutBox(*containingBlock).contentBoxWidth();
auto& displayBox = layoutState.displayBoxForLayoutBox(layoutBox);
- auto width = computedValueIfNotAuto(usedWidth ? Length { usedWidth.value(), Fixed } : style.logicalWidth(), containingBlockWidth);
+ auto width = computedValueIfNotAuto(usedValues.width ? Length { usedValues.width.value(), Fixed } : style.logicalWidth(), containingBlockWidth);
auto computedHorizontalMargin = Geometry::computedHorizontalMargin(layoutState, layoutBox);
UsedHorizontalMargin usedHorizontalMargin;
auto borderLeft = displayBox.borderLeft();
@@ -203,7 +203,7 @@
return widthAndMargin;
}
-WidthAndMargin BlockFormattingContext::Geometry::inFlowReplacedWidthAndMargin(const LayoutState& layoutState, const Box& layoutBox, Optional<LayoutUnit> usedWidth)
+WidthAndMargin BlockFormattingContext::Geometry::inFlowReplacedWidthAndMargin(const LayoutState& layoutState, const Box& layoutBox, UsedHorizontalValues usedValues)
{
ASSERT(layoutBox.isInFlow() && layoutBox.replaced());
@@ -213,12 +213,12 @@
// 2. Then the rules for non-replaced block-level elements are applied to determine the margins.
// #1
- auto width = inlineReplacedWidthAndMargin(layoutState, layoutBox, usedWidth).width;
+ usedValues.width = inlineReplacedWidthAndMargin(layoutState, layoutBox, usedValues).width;
// #2
- auto nonReplacedWidthAndMargin = inFlowNonReplacedWidthAndMargin(layoutState, layoutBox, width);
+ auto nonReplacedWidthAndMargin = inFlowNonReplacedWidthAndMargin(layoutState, layoutBox, usedValues);
- LOG_WITH_STREAM(FormattingContextLayout, stream << "[Width][Margin] -> inflow replaced -> width(" << width << "px) margin(" << nonReplacedWidthAndMargin.usedMargin.start << "px, " << nonReplacedWidthAndMargin.usedMargin.end << "px) -> layoutBox(" << &layoutBox << ")");
- return { width, nonReplacedWidthAndMargin.usedMargin, nonReplacedWidthAndMargin.computedMargin };
+ LOG_WITH_STREAM(FormattingContextLayout, stream << "[Width][Margin] -> inflow replaced -> width(" << *usedValues.width << "px) margin(" << nonReplacedWidthAndMargin.usedMargin.start << "px, " << nonReplacedWidthAndMargin.usedMargin.end << "px) -> layoutBox(" << &layoutBox << ")");
+ return { *usedValues.width, nonReplacedWidthAndMargin.usedMargin, nonReplacedWidthAndMargin.computedMargin };
}
Point BlockFormattingContext::Geometry::staticPosition(const LayoutState& layoutState, const Box& layoutBox)
@@ -242,7 +242,7 @@
return { left, top };
}
-HeightAndMargin BlockFormattingContext::Geometry::inFlowHeightAndMargin(const LayoutState& layoutState, const Box& layoutBox, Optional<LayoutUnit> usedHeight)
+HeightAndMargin BlockFormattingContext::Geometry::inFlowHeightAndMargin(const LayoutState& layoutState, const Box& layoutBox, UsedVerticalValues usedValues)
{
ASSERT(layoutBox.isInFlow());
@@ -249,16 +249,16 @@
// 10.6.2 Inline replaced elements, block-level replaced elements in normal flow, 'inline-block'
// replaced elements in normal flow and floating replaced elements
if (layoutBox.replaced())
- return inlineReplacedHeightAndMargin(layoutState, layoutBox, usedHeight);
+ return inlineReplacedHeightAndMargin(layoutState, layoutBox, usedValues);
HeightAndMargin heightAndMargin;
// TODO: Figure out the case for the document element. Let's just complicated-case it for now.
if (layoutBox.isOverflowVisible() && !layoutBox.isDocumentBox())
- heightAndMargin = inFlowNonReplacedHeightAndMargin(layoutState, layoutBox, usedHeight);
+ heightAndMargin = inFlowNonReplacedHeightAndMargin(layoutState, layoutBox, usedValues);
else {
// 10.6.6 Complicated cases
// Block-level, non-replaced elements in normal flow when 'overflow' does not compute to 'visible' (except if the 'overflow' property's value has been propagated to the viewport).
- heightAndMargin = complicatedCases(layoutState, layoutBox, usedHeight);
+ heightAndMargin = complicatedCases(layoutState, layoutBox, usedValues);
}
if (!Quirks::needsStretching(layoutState, layoutBox))
@@ -270,13 +270,13 @@
return heightAndMargin;
}
-WidthAndMargin BlockFormattingContext::Geometry::inFlowWidthAndMargin(const LayoutState& layoutState, const Box& layoutBox, Optional<LayoutUnit> usedWidth)
+WidthAndMargin BlockFormattingContext::Geometry::inFlowWidthAndMargin(const LayoutState& layoutState, const Box& layoutBox, UsedHorizontalValues usedValues)
{
ASSERT(layoutBox.isInFlow());
if (!layoutBox.replaced())
- return inFlowNonReplacedWidthAndMargin(layoutState, layoutBox, usedWidth);
- return inFlowReplacedWidthAndMargin(layoutState, layoutBox, usedWidth);
+ return inFlowNonReplacedWidthAndMargin(layoutState, layoutBox, usedValues);
+ return inFlowReplacedWidthAndMargin(layoutState, layoutBox, usedValues);
}
bool BlockFormattingContext::Geometry::instrinsicWidthConstraintsNeedChildrenWidth(const Box& layoutBox)
Modified: trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContext.cpp (241121 => 241122)
--- trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContext.cpp 2019-02-07 16:07:03 UTC (rev 241121)
+++ trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContext.cpp 2019-02-07 16:33:07 UTC (rev 241122)
@@ -108,11 +108,11 @@
WidthAndMargin widthAndMargin;
if (layoutBox.isFloatingPositioned())
- widthAndMargin = Geometry::floatingWidthAndMargin(layoutState, layoutBox);
+ widthAndMargin = Geometry::floatingWidthAndMargin(layoutState, layoutBox, { });
else if (layoutBox.isInlineBlockBox())
widthAndMargin = Geometry::inlineBlockWidthAndMargin(layoutState, layoutBox);
else if (layoutBox.replaced())
- widthAndMargin = Geometry::inlineReplacedWidthAndMargin(layoutState, layoutBox);
+ widthAndMargin = Geometry::inlineReplacedWidthAndMargin(layoutState, layoutBox, { });
else
ASSERT_NOT_REACHED();
@@ -128,11 +128,11 @@
HeightAndMargin heightAndMargin;
if (layoutBox.isFloatingPositioned())
- heightAndMargin = Geometry::floatingHeightAndMargin(layoutState, layoutBox);
+ heightAndMargin = Geometry::floatingHeightAndMargin(layoutState, layoutBox, { });
else if (layoutBox.isInlineBlockBox())
heightAndMargin = Geometry::inlineBlockHeightAndMargin(layoutState, layoutBox);
else if (layoutBox.replaced())
- heightAndMargin = Geometry::inlineReplacedHeightAndMargin(layoutState, layoutBox);
+ heightAndMargin = Geometry::inlineReplacedHeightAndMargin(layoutState, layoutBox, { });
else
ASSERT_NOT_REACHED();
Modified: trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContextGeometry.cpp (241121 => 241122)
--- trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContextGeometry.cpp 2019-02-07 16:07:03 UTC (rev 241121)
+++ trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContextGeometry.cpp 2019-02-07 16:33:07 UTC (rev 241122)
@@ -46,7 +46,7 @@
// Exactly as inline replaced elements.
if (formattingContextRoot.replaced())
- return inlineReplacedWidthAndMargin(layoutState, formattingContextRoot);
+ return inlineReplacedWidthAndMargin(layoutState, formattingContextRoot, { });
// 10.3.9 'Inline-block', non-replaced elements in normal flow
@@ -71,11 +71,11 @@
// 10.6.2 Inline replaced elements, block-level replaced elements in normal flow, 'inline-block' replaced elements in normal flow and floating replaced elements
if (layoutBox.replaced())
- return inlineReplacedHeightAndMargin(layoutState, layoutBox);
+ return inlineReplacedHeightAndMargin(layoutState, layoutBox, { });
// 10.6.6 Complicated cases
// - 'Inline-block', non-replaced elements.
- return complicatedCases(layoutState, layoutBox);
+ return complicatedCases(layoutState, layoutBox, { });
}
}
