[LFC] Adjust computed height value when box sizing is border-box
https://bugs.webkit.org/show_bug.cgi?id=202965
<rdar://problem/56276771>
Reviewed by Antti Koivisto.
box-sizing: border-box; means the height value sets the size of the border box (and not the content box).
* layout/FormattingContext.cpp:
(WebCore::Layout::FormattingContext::computeOutOfFlowHorizontalGeometry):
(WebCore::Layout::FormattingContext::computeOutOfFlowVerticalGeometry):
* layout/FormattingContext.h:
* layout/FormattingContextGeometry.cpp:
(WebCore::Layout::FormattingContext::Geometry::computedContentHeight const):
(WebCore::Layout::FormattingContext::Geometry::outOfFlowNonReplacedVerticalGeometry const):
(WebCore::Layout::FormattingContext::Geometry::outOfFlowReplacedVerticalGeometry const):
(WebCore::Layout::FormattingContext::Geometry::outOfFlowReplacedHorizontalGeometry const):
(WebCore::Layout::FormattingContext::Geometry::complicatedCases const):
(WebCore::Layout::FormattingContext::Geometry::floatingNonReplacedWidthAndMargin):
(WebCore::Layout::FormattingContext::Geometry::floatingReplacedHeightAndMargin const):
(WebCore::Layout::FormattingContext::Geometry::floatingReplacedWidthAndMargin const):
(WebCore::Layout::FormattingContext::Geometry::floatingHeightAndMargin const):
(WebCore::Layout::FormattingContext::Geometry::floatingWidthAndMargin):
(WebCore::Layout::FormattingContext::Geometry::inlineReplacedHeightAndMargin const):
(WebCore::Layout::FormattingContext::Geometry::inlineReplacedWidthAndMargin const):
* layout/LayoutState.cpp:
(WebCore::Layout::LayoutState::displayBoxForLayoutBox):
* layout/LayoutUnits.h:
* layout/blockformatting/BlockFormattingContext.cpp:
(WebCore::Layout::BlockFormattingContext::computeWidthAndMargin):
(WebCore::Layout::BlockFormattingContext::computeHeightAndMargin):
* layout/blockformatting/BlockFormattingContext.h:
* layout/blockformatting/BlockFormattingContextGeometry.cpp:
(WebCore::Layout::BlockFormattingContext::Geometry::inFlowNonReplacedHeightAndMargin):
(WebCore::Layout::BlockFormattingContext::Geometry::inFlowNonReplacedWidthAndMargin const):
(WebCore::Layout::BlockFormattingContext::Geometry::inFlowReplacedWidthAndMargin const):
(WebCore::Layout::BlockFormattingContext::Geometry::inFlowHeightAndMargin):
(WebCore::Layout::BlockFormattingContext::Geometry::inFlowWidthAndMargin):
* layout/blockformatting/BlockFormattingContextQuirks.cpp:
(WebCore::Layout::BlockFormattingContext::Quirks::stretchedInFlowHeight):
* layout/displaytree/DisplayBox.cpp:
(WebCore::Display::Box::Box):
(WebCore::Display::Box::Style::Style): Deleted.
* layout/displaytree/DisplayBox.h:
* layout/inlineformatting/InlineFormattingContext.cpp:
(WebCore::Layout::InlineFormattingContext::computeWidthAndMargin):
(WebCore::Layout::InlineFormattingContext::computeHeightAndMargin):
* layout/inlineformatting/InlineFormattingContext.h:
* layout/inlineformatting/InlineFormattingContextGeometry.cpp:
(WebCore::Layout::InlineFormattingContext::Geometry::inlineBlockWidthAndMargin):
(WebCore::Layout::InlineFormattingContext::Geometry::inlineBlockHeightAndMargin const):
* layout/tableformatting/TableFormattingContext.cpp:
(WebCore::Layout::TableFormattingContext::layoutTableCellBox):
* layout/tableformatting/TableFormattingContext.h:
* layout/tableformatting/TableFormattingContextGeometry.cpp:
(WebCore::Layout::TableFormattingContext::Geometry::tableCellHeightAndMargin const):
git-svn-id: http://svn.webkit.org/repository/webkit/trunk@251135 268f45cc-cd09-0410-ab3c-d52691b4dbfc
diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
index 9a8fa5c..e440763 100644
--- a/Source/WebCore/ChangeLog
+++ b/Source/WebCore/ChangeLog
@@ -1,3 +1,62 @@
+2019-10-15 Zalan Bujtas <zalan@apple.com>
+
+ [LFC] Adjust computed height value when box sizing is border-box
+ https://bugs.webkit.org/show_bug.cgi?id=202965
+ <rdar://problem/56276771>
+
+ Reviewed by Antti Koivisto.
+
+ box-sizing: border-box; means the height value sets the size of the border box (and not the content box).
+
+ * layout/FormattingContext.cpp:
+ (WebCore::Layout::FormattingContext::computeOutOfFlowHorizontalGeometry):
+ (WebCore::Layout::FormattingContext::computeOutOfFlowVerticalGeometry):
+ * layout/FormattingContext.h:
+ * layout/FormattingContextGeometry.cpp:
+ (WebCore::Layout::FormattingContext::Geometry::computedContentHeight const):
+ (WebCore::Layout::FormattingContext::Geometry::outOfFlowNonReplacedVerticalGeometry const):
+ (WebCore::Layout::FormattingContext::Geometry::outOfFlowReplacedVerticalGeometry const):
+ (WebCore::Layout::FormattingContext::Geometry::outOfFlowReplacedHorizontalGeometry const):
+ (WebCore::Layout::FormattingContext::Geometry::complicatedCases const):
+ (WebCore::Layout::FormattingContext::Geometry::floatingNonReplacedWidthAndMargin):
+ (WebCore::Layout::FormattingContext::Geometry::floatingReplacedHeightAndMargin const):
+ (WebCore::Layout::FormattingContext::Geometry::floatingReplacedWidthAndMargin const):
+ (WebCore::Layout::FormattingContext::Geometry::floatingHeightAndMargin const):
+ (WebCore::Layout::FormattingContext::Geometry::floatingWidthAndMargin):
+ (WebCore::Layout::FormattingContext::Geometry::inlineReplacedHeightAndMargin const):
+ (WebCore::Layout::FormattingContext::Geometry::inlineReplacedWidthAndMargin const):
+ * layout/LayoutState.cpp:
+ (WebCore::Layout::LayoutState::displayBoxForLayoutBox):
+ * layout/LayoutUnits.h:
+ * layout/blockformatting/BlockFormattingContext.cpp:
+ (WebCore::Layout::BlockFormattingContext::computeWidthAndMargin):
+ (WebCore::Layout::BlockFormattingContext::computeHeightAndMargin):
+ * layout/blockformatting/BlockFormattingContext.h:
+ * layout/blockformatting/BlockFormattingContextGeometry.cpp:
+ (WebCore::Layout::BlockFormattingContext::Geometry::inFlowNonReplacedHeightAndMargin):
+ (WebCore::Layout::BlockFormattingContext::Geometry::inFlowNonReplacedWidthAndMargin const):
+ (WebCore::Layout::BlockFormattingContext::Geometry::inFlowReplacedWidthAndMargin const):
+ (WebCore::Layout::BlockFormattingContext::Geometry::inFlowHeightAndMargin):
+ (WebCore::Layout::BlockFormattingContext::Geometry::inFlowWidthAndMargin):
+ * layout/blockformatting/BlockFormattingContextQuirks.cpp:
+ (WebCore::Layout::BlockFormattingContext::Quirks::stretchedInFlowHeight):
+ * layout/displaytree/DisplayBox.cpp:
+ (WebCore::Display::Box::Box):
+ (WebCore::Display::Box::Style::Style): Deleted.
+ * layout/displaytree/DisplayBox.h:
+ * layout/inlineformatting/InlineFormattingContext.cpp:
+ (WebCore::Layout::InlineFormattingContext::computeWidthAndMargin):
+ (WebCore::Layout::InlineFormattingContext::computeHeightAndMargin):
+ * layout/inlineformatting/InlineFormattingContext.h:
+ * layout/inlineformatting/InlineFormattingContextGeometry.cpp:
+ (WebCore::Layout::InlineFormattingContext::Geometry::inlineBlockWidthAndMargin):
+ (WebCore::Layout::InlineFormattingContext::Geometry::inlineBlockHeightAndMargin const):
+ * layout/tableformatting/TableFormattingContext.cpp:
+ (WebCore::Layout::TableFormattingContext::layoutTableCellBox):
+ * layout/tableformatting/TableFormattingContext.h:
+ * layout/tableformatting/TableFormattingContextGeometry.cpp:
+ (WebCore::Layout::TableFormattingContext::Geometry::tableCellHeightAndMargin const):
+
2019-10-15 Wenson Hsieh <wenson_hsieh@apple.com>
[Clipboard API] Implement getType() for ClipboardItems created from bindings
diff --git a/Source/WebCore/layout/FormattingContext.cpp b/Source/WebCore/layout/FormattingContext.cpp
index bb540b4..39afeea 100644
--- a/Source/WebCore/layout/FormattingContext.cpp
+++ b/Source/WebCore/layout/FormattingContext.cpp
@@ -89,21 +89,21 @@
auto horizontalGeometry = compute({ });
if (auto maxWidth = geometry().computedValueIfNotAuto(layoutBox.style().logicalMaxWidth(), containingBlockWidth)) {
auto maxHorizontalGeometry = compute(maxWidth);
- if (horizontalGeometry.widthAndMargin.width > maxHorizontalGeometry.widthAndMargin.width)
+ if (horizontalGeometry.contentWidthAndMargin.contentWidth > maxHorizontalGeometry.contentWidthAndMargin.contentWidth)
horizontalGeometry = maxHorizontalGeometry;
}
if (auto minWidth = geometry().computedValueIfNotAuto(layoutBox.style().logicalMinWidth(), containingBlockWidth)) {
auto minHorizontalGeometry = compute(minWidth);
- if (horizontalGeometry.widthAndMargin.width < minHorizontalGeometry.widthAndMargin.width)
+ if (horizontalGeometry.contentWidthAndMargin.contentWidth < minHorizontalGeometry.contentWidthAndMargin.contentWidth)
horizontalGeometry = minHorizontalGeometry;
}
auto& displayBox = formattingState().displayBox(layoutBox);
- displayBox.setLeft(horizontalGeometry.left + horizontalGeometry.widthAndMargin.usedMargin.start);
- displayBox.setContentBoxWidth(horizontalGeometry.widthAndMargin.width);
- displayBox.setHorizontalMargin(horizontalGeometry.widthAndMargin.usedMargin);
- displayBox.setHorizontalComputedMargin(horizontalGeometry.widthAndMargin.computedMargin);
+ displayBox.setLeft(horizontalGeometry.left + horizontalGeometry.contentWidthAndMargin.usedMargin.start);
+ displayBox.setContentBoxWidth(horizontalGeometry.contentWidthAndMargin.contentWidth);
+ displayBox.setHorizontalMargin(horizontalGeometry.contentWidthAndMargin.usedMargin);
+ displayBox.setHorizontalComputedMargin(horizontalGeometry.contentWidthAndMargin.computedMargin);
}
void FormattingContext::computeOutOfFlowVerticalGeometry(const Box& layoutBox)
@@ -121,21 +121,21 @@
if (auto maxHeight = geometry().computedMaxHeight(layoutBox, containingBlockHeight)) {
auto usedValuesForMaxHeight = UsedVerticalValues { outOfFlowVerticalConstraints(containingBlockGeometry), maxHeight };
auto maxVerticalGeometry = compute(usedHorizontalValues, usedValuesForMaxHeight);
- if (verticalGeometry.heightAndMargin.height > maxVerticalGeometry.heightAndMargin.height)
+ if (verticalGeometry.contentHeightAndMargin.contentHeight > maxVerticalGeometry.contentHeightAndMargin.contentHeight)
verticalGeometry = maxVerticalGeometry;
}
if (auto minHeight = geometry().computedMinHeight(layoutBox, containingBlockHeight)) {
auto usedValuesForMinHeight = UsedVerticalValues { outOfFlowVerticalConstraints(containingBlockGeometry), minHeight };
auto minVerticalGeometry = compute(usedHorizontalValues, usedValuesForMinHeight);
- if (verticalGeometry.heightAndMargin.height < minVerticalGeometry.heightAndMargin.height)
+ if (verticalGeometry.contentHeightAndMargin.contentHeight < minVerticalGeometry.contentHeightAndMargin.contentHeight)
verticalGeometry = minVerticalGeometry;
}
auto& displayBox = formattingState().displayBox(layoutBox);
- auto nonCollapsedVerticalMargin = verticalGeometry.heightAndMargin.nonCollapsedMargin;
+ auto nonCollapsedVerticalMargin = verticalGeometry.contentHeightAndMargin.nonCollapsedMargin;
displayBox.setTop(verticalGeometry.top + nonCollapsedVerticalMargin.before);
- displayBox.setContentBoxHeight(verticalGeometry.heightAndMargin.height);
+ displayBox.setContentBoxHeight(verticalGeometry.contentHeightAndMargin.contentHeight);
// Margins of absolutely positioned boxes do not collapse
displayBox.setVerticalMargin({ nonCollapsedVerticalMargin, { } });
}
diff --git a/Source/WebCore/layout/FormattingContext.h b/Source/WebCore/layout/FormattingContext.h
index 516f101..d02c8c2 100644
--- a/Source/WebCore/layout/FormattingContext.h
+++ b/Source/WebCore/layout/FormattingContext.h
@@ -50,12 +50,12 @@
struct ComputedHorizontalMargin;
struct ComputedVerticalMargin;
struct Edges;
-struct HeightAndMargin;
+struct ContentHeightAndMargin;
struct HorizontalGeometry;
struct UsedHorizontalValues;
struct UsedVerticalValues;
struct VerticalGeometry;
-struct WidthAndMargin;
+struct ContentWidthAndMargin;
class FormattingContext {
WTF_MAKE_ISO_ALLOCATED(FormattingContext);
@@ -110,15 +110,15 @@
VerticalGeometry outOfFlowVerticalGeometry(const Box&, UsedHorizontalValues, UsedVerticalValues) const;
HorizontalGeometry outOfFlowHorizontalGeometry(const Box&, UsedHorizontalValues, UsedVerticalValues);
- HeightAndMargin floatingHeightAndMargin(const Box&, UsedHorizontalValues, UsedVerticalValues) const;
- WidthAndMargin floatingWidthAndMargin(const Box&, UsedHorizontalValues);
+ ContentHeightAndMargin floatingHeightAndMargin(const Box&, UsedHorizontalValues, UsedVerticalValues) const;
+ ContentWidthAndMargin floatingWidthAndMargin(const Box&, UsedHorizontalValues);
- HeightAndMargin inlineReplacedHeightAndMargin(const Box&, UsedHorizontalValues, UsedVerticalValues) const;
- WidthAndMargin inlineReplacedWidthAndMargin(const Box&, UsedHorizontalValues, Optional<UsedVerticalValues> = WTF::nullopt) const;
+ ContentHeightAndMargin inlineReplacedHeightAndMargin(const Box&, UsedHorizontalValues, UsedVerticalValues) const;
+ ContentWidthAndMargin inlineReplacedWidthAndMargin(const Box&, UsedHorizontalValues, Optional<UsedVerticalValues> = WTF::nullopt) const;
LayoutSize inFlowPositionedPositionOffset(const Box&, UsedHorizontalValues) const;
- HeightAndMargin complicatedCases(const Box&, UsedHorizontalValues, UsedVerticalValues) const;
+ ContentHeightAndMargin complicatedCases(const Box&, UsedHorizontalValues, UsedVerticalValues) const;
LayoutUnit shrinkToFitWidth(const Box&, LayoutUnit availableWidth);
Edges computedBorder(const Box&) const;
@@ -142,7 +142,8 @@
Geometry(const FormattingContext&);
enum class HeightType { Min, Max, Normal };
- Optional<LayoutUnit> computedHeightValue(const Box&, HeightType, Optional<LayoutUnit> containingBlockHeight = WTF::nullopt) const;
+ Optional<LayoutUnit> computedHeightValue(const Box&, HeightType, Optional<LayoutUnit> containingBlockHeight) const;
+ Optional<LayoutUnit> computedContentHeight(const Box&, Optional<LayoutUnit> containingBlockHeight = WTF::nullopt) const;
const LayoutState& layoutState() const { return m_formattingContext.layoutState(); }
LayoutState& layoutState() { return m_formattingContext.layoutState(); }
@@ -155,10 +156,10 @@
VerticalGeometry outOfFlowNonReplacedVerticalGeometry(const Box&, UsedHorizontalValues, UsedVerticalValues) const;
HorizontalGeometry outOfFlowNonReplacedHorizontalGeometry(const Box&, UsedHorizontalValues);
- HeightAndMargin floatingReplacedHeightAndMargin(const Box&, UsedHorizontalValues, UsedVerticalValues) const;
- WidthAndMargin floatingReplacedWidthAndMargin(const Box&, UsedHorizontalValues) const;
+ ContentHeightAndMargin floatingReplacedHeightAndMargin(const Box&, UsedHorizontalValues, UsedVerticalValues) const;
+ ContentWidthAndMargin floatingReplacedWidthAndMargin(const Box&, UsedHorizontalValues) const;
- WidthAndMargin floatingNonReplacedWidthAndMargin(const Box&, UsedHorizontalValues);
+ ContentWidthAndMargin floatingNonReplacedWidthAndMargin(const Box&, UsedHorizontalValues);
LayoutUnit staticVerticalPositionForOutOfFlowPositioned(const Box&, UsedVerticalValues) const;
LayoutUnit staticHorizontalPositionForOutOfFlowPositioned(const Box&, UsedHorizontalValues) const;
diff --git a/Source/WebCore/layout/FormattingContextGeometry.cpp b/Source/WebCore/layout/FormattingContextGeometry.cpp
index 8892483..f576d56 100644
--- a/Source/WebCore/layout/FormattingContextGeometry.cpp
+++ b/Source/WebCore/layout/FormattingContextGeometry.cpp
@@ -85,6 +85,17 @@
return valueForLength(height, *containingBlockHeight);
}
+Optional<LayoutUnit> FormattingContext::Geometry::computedContentHeight(const Box& layoutBox, Optional<LayoutUnit> containingBlockHeight) const
+{
+ if (auto height = computedHeightValue(layoutBox, HeightType::Normal, containingBlockHeight)) {
+ if (layoutBox.style().boxSizing() == BoxSizing::ContentBox)
+ return height;
+ auto& boxGeometry = formattingContext().geometryForBox(layoutBox);
+ return *height - (boxGeometry.verticalBorder() + boxGeometry.verticalPadding().valueOr(0));
+ }
+ return { };
+}
+
LayoutUnit FormattingContext::Geometry::contentHeightForFormattingContextRoot(const Box& layoutBox) const
{
ASSERT(isHeightAuto(layoutBox) && (layoutBox.establishesFormattingContext() || layoutBox.isDocumentBox()));
@@ -300,37 +311,33 @@
auto top = computedValueIfNotAuto(style.logicalTop(), containingBlockWidth);
auto bottom = computedValueIfNotAuto(style.logicalBottom(), containingBlockWidth);
- auto height = usedVerticalValues.height ? usedVerticalValues.height.value() : computedHeightValue(layoutBox, HeightType::Normal, containingBlockHeight);
+ auto height = usedVerticalValues.height ? usedVerticalValues.height.value() : computedContentHeight(layoutBox, containingBlockHeight);
auto computedVerticalMargin = Geometry::computedVerticalMargin(layoutBox, usedHorizontalValues);
UsedVerticalMargin::NonCollapsedValues usedVerticalMargin;
auto paddingTop = boxGeometry.paddingTop().valueOr(0);
auto paddingBottom = boxGeometry.paddingBottom().valueOr(0);
auto borderTop = boxGeometry.borderTop();
auto borderBottom = boxGeometry.borderBottom();
- auto contentHeight = [&] {
- ASSERT(height);
- return style.boxSizing() == BoxSizing::ContentBox ? *height : *height - (borderTop + paddingTop + paddingBottom + borderBottom);
- };
if (!top && !height && !bottom)
top = staticVerticalPositionForOutOfFlowPositioned(layoutBox, usedVerticalValues);
if (top && height && bottom) {
if (!computedVerticalMargin.before && !computedVerticalMargin.after) {
- auto marginBeforeAndAfter = containingBlockHeight - (*top + borderTop + paddingTop + contentHeight() + paddingBottom + borderBottom + *bottom);
+ auto marginBeforeAndAfter = containingBlockHeight - (*top + borderTop + paddingTop + *height + paddingBottom + borderBottom + *bottom);
usedVerticalMargin = { marginBeforeAndAfter / 2, marginBeforeAndAfter / 2 };
} else if (!computedVerticalMargin.before) {
usedVerticalMargin.after = *computedVerticalMargin.after;
- usedVerticalMargin.before = containingBlockHeight - (*top + borderTop + paddingTop + contentHeight() + paddingBottom + borderBottom + usedVerticalMargin.after + *bottom);
+ usedVerticalMargin.before = containingBlockHeight - (*top + borderTop + paddingTop + *height + paddingBottom + borderBottom + usedVerticalMargin.after + *bottom);
} else if (!computedVerticalMargin.after) {
usedVerticalMargin.before = *computedVerticalMargin.before;
- usedVerticalMargin.after = containingBlockHeight - (*top + usedVerticalMargin.before + borderTop + paddingTop + contentHeight() + paddingBottom + borderBottom + *bottom);
+ usedVerticalMargin.after = containingBlockHeight - (*top + usedVerticalMargin.before + borderTop + paddingTop + *height + paddingBottom + borderBottom + *bottom);
} else
usedVerticalMargin = { *computedVerticalMargin.before, *computedVerticalMargin.after };
// Over-constrained?
- auto boxHeight = *top + usedVerticalMargin.before + borderTop + paddingTop + contentHeight() + paddingBottom + borderBottom + usedVerticalMargin.after + *bottom;
+ auto boxHeight = *top + usedVerticalMargin.before + borderTop + paddingTop + *height + paddingBottom + borderBottom + usedVerticalMargin.after + *bottom;
if (boxHeight != containingBlockHeight)
- bottom = containingBlockHeight - (*top + usedVerticalMargin.before + borderTop + paddingTop + contentHeight() + paddingBottom + borderBottom + usedVerticalMargin.after);
+ bottom = containingBlockHeight - (*top + usedVerticalMargin.before + borderTop + paddingTop + *height + paddingBottom + borderBottom + usedVerticalMargin.after);
}
if (!top && !height && bottom) {
@@ -344,7 +351,7 @@
// #2
top = staticVerticalPositionForOutOfFlowPositioned(layoutBox, usedVerticalValues);
usedVerticalMargin = { computedVerticalMargin.before.valueOr(0), computedVerticalMargin.after.valueOr(0) };
- bottom = containingBlockHeight - (*top + usedVerticalMargin.before + borderTop + paddingTop + contentHeight() + paddingBottom + borderBottom + usedVerticalMargin.after);
+ bottom = containingBlockHeight - (*top + usedVerticalMargin.before + borderTop + paddingTop + *height + paddingBottom + borderBottom + usedVerticalMargin.after);
}
if (!height && !bottom && top) {
@@ -357,7 +364,7 @@
if (!top && height && bottom) {
// #4
usedVerticalMargin = { computedVerticalMargin.before.valueOr(0), computedVerticalMargin.after.valueOr(0) };
- top = containingBlockHeight - (usedVerticalMargin.before + borderTop + paddingTop + contentHeight() + paddingBottom + borderBottom + usedVerticalMargin.after + *bottom);
+ top = containingBlockHeight - (usedVerticalMargin.before + borderTop + paddingTop + *height + paddingBottom + borderBottom + usedVerticalMargin.after + *bottom);
}
if (!height && top && bottom) {
@@ -369,7 +376,7 @@
if (!bottom && top && height) {
// #6
usedVerticalMargin = { computedVerticalMargin.before.valueOr(0), computedVerticalMargin.after.valueOr(0) };
- bottom = containingBlockHeight - (*top + usedVerticalMargin.before + borderTop + paddingTop + contentHeight() + paddingBottom + borderBottom + usedVerticalMargin.after);
+ bottom = containingBlockHeight - (*top + usedVerticalMargin.before + borderTop + paddingTop + *height + paddingBottom + borderBottom + usedVerticalMargin.after);
}
ASSERT(top);
@@ -383,7 +390,7 @@
*bottom += containingBlockPaddingVerticalEdge;
LOG_WITH_STREAM(FormattingContextLayout, stream << "[Position][Height][Margin] -> out-of-flow non-replaced -> top(" << *top << "px) bottom(" << *bottom << "px) height(" << *height << "px) margin(" << usedVerticalMargin.before << "px, " << usedVerticalMargin.after << "px) layoutBox(" << &layoutBox << ")");
- return { *top, *bottom, { contentHeight(), usedVerticalMargin } };
+ return { *top, *bottom, { *height, usedVerticalMargin } };
}
HorizontalGeometry FormattingContext::Geometry::outOfFlowNonReplacedHorizontalGeometry(const Box& layoutBox, UsedHorizontalValues usedHorizontalValues)
@@ -557,7 +564,7 @@
auto top = computedValueIfNotAuto(style.logicalTop(), containingBlockWidth);
auto bottom = computedValueIfNotAuto(style.logicalBottom(), containingBlockWidth);
- auto height = inlineReplacedHeightAndMargin(layoutBox, usedHorizontalValues, usedVerticalValues).height;
+ auto height = inlineReplacedHeightAndMargin(layoutBox, usedHorizontalValues, usedVerticalValues).contentHeight;
auto computedVerticalMargin = Geometry::computedVerticalMargin(layoutBox, usedHorizontalValues);
Optional<LayoutUnit> usedMarginBefore = computedVerticalMargin.before;
Optional<LayoutUnit> usedMarginAfter = computedVerticalMargin.after;
@@ -645,7 +652,7 @@
auto computedHorizontalMargin = Geometry::computedHorizontalMargin(layoutBox, usedHorizontalValues);
Optional<LayoutUnit> usedMarginStart = computedHorizontalMargin.start;
Optional<LayoutUnit> usedMarginEnd = computedHorizontalMargin.end;
- auto width = inlineReplacedWidthAndMargin(layoutBox, usedHorizontalValues, usedVerticalValues).width;
+ auto width = inlineReplacedWidthAndMargin(layoutBox, usedHorizontalValues, usedVerticalValues).contentWidth;
auto paddingLeft = boxGeometry.paddingLeft().valueOr(0);
auto paddingRight = boxGeometry.paddingRight().valueOr(0);
auto borderLeft = boxGeometry.borderLeft();
@@ -720,7 +727,7 @@
return { *left, *right, { width, { *usedMarginStart, *usedMarginEnd }, computedHorizontalMargin } };
}
-HeightAndMargin FormattingContext::Geometry::complicatedCases(const Box& layoutBox, UsedHorizontalValues usedHorizontalValues, UsedVerticalValues usedVerticalValues) const
+ContentHeightAndMargin FormattingContext::Geometry::complicatedCases(const Box& layoutBox, UsedHorizontalValues usedHorizontalValues, UsedVerticalValues usedVerticalValues) const
{
ASSERT(!layoutBox.replaced());
// TODO: Use complicated-case for document renderer for now (see BlockFormattingContext::Geometry::inFlowHeightAndMargin).
@@ -735,7 +742,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 = usedVerticalValues.height ? usedVerticalValues.height.value() : computedHeightValue(layoutBox, HeightType::Normal);
+ auto height = usedVerticalValues.height ? usedVerticalValues.height.value() : computedContentHeight(layoutBox);
auto computedVerticalMargin = Geometry::computedVerticalMargin(layoutBox, usedHorizontalValues);
// #1
auto usedVerticalMargin = UsedVerticalMargin::NonCollapsedValues { computedVerticalMargin.before.valueOr(0), computedVerticalMargin.after.valueOr(0) };
@@ -748,10 +755,10 @@
ASSERT(height);
LOG_WITH_STREAM(FormattingContextLayout, stream << "[Height][Margin] -> floating non-replaced -> height(" << *height << "px) margin(" << usedVerticalMargin.before << "px, " << usedVerticalMargin.after << "px) -> layoutBox(" << &layoutBox << ")");
- return HeightAndMargin { *height, usedVerticalMargin };
+ return ContentHeightAndMargin { *height, usedVerticalMargin };
}
-WidthAndMargin FormattingContext::Geometry::floatingNonReplacedWidthAndMargin(const Box& layoutBox, UsedHorizontalValues usedHorizontalValues)
+ContentWidthAndMargin FormattingContext::Geometry::floatingNonReplacedWidthAndMargin(const Box& layoutBox, UsedHorizontalValues usedHorizontalValues)
{
ASSERT(layoutBox.isFloatingPositioned() && !layoutBox.replaced());
@@ -770,10 +777,10 @@
width = shrinkToFitWidth(layoutBox, usedHorizontalValues.constraints.width);
LOG_WITH_STREAM(FormattingContextLayout, stream << "[Width][Margin] -> floating non-replaced -> width(" << *width << "px) margin(" << usedHorizontallMargin.start << "px, " << usedHorizontallMargin.end << "px) -> layoutBox(" << &layoutBox << ")");
- return WidthAndMargin { *width, usedHorizontallMargin, computedHorizontalMargin };
+ return ContentWidthAndMargin { *width, usedHorizontallMargin, computedHorizontalMargin };
}
-HeightAndMargin FormattingContext::Geometry::floatingReplacedHeightAndMargin(const Box& layoutBox, UsedHorizontalValues usedHorizontalValues, UsedVerticalValues usedVerticalValues) const
+ContentHeightAndMargin FormattingContext::Geometry::floatingReplacedHeightAndMargin(const Box& layoutBox, UsedHorizontalValues usedHorizontalValues, UsedVerticalValues usedVerticalValues) const
{
ASSERT(layoutBox.isFloatingPositioned() && layoutBox.replaced());
@@ -783,7 +790,7 @@
return inlineReplacedHeightAndMargin(layoutBox, usedHorizontalValues, usedVerticalValues);
}
-WidthAndMargin FormattingContext::Geometry::floatingReplacedWidthAndMargin(const Box& layoutBox, UsedHorizontalValues usedHorizontalValues) const
+ContentWidthAndMargin FormattingContext::Geometry::floatingReplacedWidthAndMargin(const Box& layoutBox, UsedHorizontalValues usedHorizontalValues) const
{
ASSERT(layoutBox.isFloatingPositioned() && layoutBox.replaced());
@@ -816,7 +823,7 @@
return outOfFlowReplacedHorizontalGeometry(layoutBox, usedHorizontalValues, usedVerticalValues);
}
-HeightAndMargin FormattingContext::Geometry::floatingHeightAndMargin(const Box& layoutBox, UsedHorizontalValues usedHorizontalValues, UsedVerticalValues usedVerticalValues) const
+ContentHeightAndMargin FormattingContext::Geometry::floatingHeightAndMargin(const Box& layoutBox, UsedHorizontalValues usedHorizontalValues, UsedVerticalValues usedVerticalValues) const
{
ASSERT(layoutBox.isFloatingPositioned());
@@ -825,7 +832,7 @@
return floatingReplacedHeightAndMargin(layoutBox, usedHorizontalValues, usedVerticalValues);
}
-WidthAndMargin FormattingContext::Geometry::floatingWidthAndMargin(const Box& layoutBox, UsedHorizontalValues usedValues)
+ContentWidthAndMargin FormattingContext::Geometry::floatingWidthAndMargin(const Box& layoutBox, UsedHorizontalValues usedValues)
{
ASSERT(layoutBox.isFloatingPositioned());
@@ -834,7 +841,7 @@
return floatingReplacedWidthAndMargin(layoutBox, usedValues);
}
-HeightAndMargin FormattingContext::Geometry::inlineReplacedHeightAndMargin(const Box& layoutBox, UsedHorizontalValues usedHorizontalValues, UsedVerticalValues usedVerticalValues) const
+ContentHeightAndMargin FormattingContext::Geometry::inlineReplacedHeightAndMargin(const Box& layoutBox, UsedHorizontalValues usedHorizontalValues, UsedVerticalValues usedVerticalValues) const
{
ASSERT((layoutBox.isOutOfFlowPositioned() || layoutBox.isFloatingPositioned() || layoutBox.isInFlow()) && layoutBox.replaced());
@@ -855,7 +862,7 @@
auto& style = layoutBox.style();
auto replaced = layoutBox.replaced();
- auto height = usedVerticalValues.height ? usedVerticalValues.height.value() : computedHeightValue(layoutBox, HeightType::Normal, usedVerticalValues.constraints.height);
+ auto height = usedVerticalValues.height ? usedVerticalValues.height.value() : computedContentHeight(layoutBox, usedVerticalValues.constraints.height);
auto heightIsAuto = !usedVerticalValues.height && isHeightAuto(layoutBox);
auto widthIsAuto = style.logicalWidth().isAuto();
@@ -880,7 +887,7 @@
return { *height, usedVerticalMargin };
}
-WidthAndMargin FormattingContext::Geometry::inlineReplacedWidthAndMargin(const Box& layoutBox, UsedHorizontalValues usedHorizontalValues, Optional<UsedVerticalValues> usedVerticalValues) const
+ContentWidthAndMargin FormattingContext::Geometry::inlineReplacedWidthAndMargin(const Box& layoutBox, UsedHorizontalValues usedHorizontalValues, Optional<UsedVerticalValues> usedVerticalValues) const
{
ASSERT((layoutBox.isOutOfFlowPositioned() || layoutBox.isFloatingPositioned() || layoutBox.isInFlow()) && layoutBox.replaced());
@@ -924,7 +931,7 @@
auto width = computedValueIfNotAuto(usedHorizontalValues.width ? Length { usedHorizontalValues.width.value(), Fixed } : style.logicalWidth(), containingBlockWidth);
auto heightIsAuto = isHeightAuto(layoutBox);
- auto height = computedHeightValue(layoutBox, HeightType::Normal, usedVerticalValues ? usedVerticalValues->constraints.height : WTF::nullopt);
+ auto height = computedContentHeight(layoutBox, usedVerticalValues ? usedVerticalValues->constraints.height : WTF::nullopt);
if (!width && heightIsAuto && replaced->hasIntrinsicWidth()) {
// #1
diff --git a/Source/WebCore/layout/LayoutState.cpp b/Source/WebCore/layout/LayoutState.cpp
index 2968210..66662d8 100644
--- a/Source/WebCore/layout/LayoutState.cpp
+++ b/Source/WebCore/layout/LayoutState.cpp
@@ -47,8 +47,8 @@
Display::Box& LayoutState::displayBoxForLayoutBox(const Box& layoutBox)
{
- return *m_layoutToDisplayBox.ensure(&layoutBox, [&layoutBox] {
- return makeUnique<Display::Box>(layoutBox.style());
+ return *m_layoutToDisplayBox.ensure(&layoutBox, [] {
+ return makeUnique<Display::Box>();
}).iterator->value;
}
diff --git a/Source/WebCore/layout/LayoutUnits.h b/Source/WebCore/layout/LayoutUnits.h
index 5b0eb72..dbe9400 100644
--- a/Source/WebCore/layout/LayoutUnits.h
+++ b/Source/WebCore/layout/LayoutUnits.h
@@ -118,27 +118,27 @@
VerticalEdges vertical;
};
-struct WidthAndMargin {
- LayoutUnit width;
+struct ContentWidthAndMargin {
+ LayoutUnit contentWidth;
UsedHorizontalMargin usedMargin;
ComputedHorizontalMargin computedMargin;
};
-struct HeightAndMargin {
- LayoutUnit height;
+struct ContentHeightAndMargin {
+ LayoutUnit contentHeight;
UsedVerticalMargin::NonCollapsedValues nonCollapsedMargin;
};
struct HorizontalGeometry {
LayoutUnit left;
LayoutUnit right;
- WidthAndMargin widthAndMargin;
+ ContentWidthAndMargin contentWidthAndMargin;
};
struct VerticalGeometry {
LayoutUnit top;
LayoutUnit bottom;
- HeightAndMargin heightAndMargin;
+ ContentHeightAndMargin contentHeightAndMargin;
};
struct UsedHorizontalValues {
diff --git a/Source/WebCore/layout/blockformatting/BlockFormattingContext.cpp b/Source/WebCore/layout/blockformatting/BlockFormattingContext.cpp
index feabb2e..7f11d18 100644
--- a/Source/WebCore/layout/blockformatting/BlockFormattingContext.cpp
+++ b/Source/WebCore/layout/blockformatting/BlockFormattingContext.cpp
@@ -360,7 +360,7 @@
availableWidth = containingBlockGeometry.contentBoxWidth();
auto constraints = UsedHorizontalValues::Constraints { containingBlockGeometry.contentBoxLeft(), availableWidth };
- auto compute = [&](Optional<LayoutUnit> usedWidth) -> WidthAndMargin {
+ auto compute = [&](Optional<LayoutUnit> usedWidth) -> ContentWidthAndMargin {
auto usedValues = UsedHorizontalValues { constraints, usedWidth, { } };
if (layoutBox.isInFlow())
return geometry().inFlowWidthAndMargin(layoutBox, usedValues);
@@ -372,29 +372,29 @@
return { };
};
- auto widthAndMargin = compute({ });
+ auto contentWidthAndMargin = compute({ });
if (auto maxWidth = geometry().computedValueIfNotAuto(layoutBox.style().logicalMaxWidth(), availableWidth)) {
auto maxWidthAndMargin = compute(maxWidth);
- if (widthAndMargin.width > maxWidthAndMargin.width)
- widthAndMargin = maxWidthAndMargin;
+ if (contentWidthAndMargin.contentWidth > maxWidthAndMargin.contentWidth)
+ contentWidthAndMargin = maxWidthAndMargin;
}
auto minWidth = geometry().computedValueIfNotAuto(layoutBox.style().logicalMinWidth(), availableWidth).valueOr(0);
auto minWidthAndMargin = compute(minWidth);
- if (widthAndMargin.width < minWidthAndMargin.width)
- widthAndMargin = minWidthAndMargin;
+ if (contentWidthAndMargin.contentWidth < minWidthAndMargin.contentWidth)
+ contentWidthAndMargin = minWidthAndMargin;
auto& displayBox = formattingState().displayBox(layoutBox);
- displayBox.setContentBoxWidth(widthAndMargin.width);
- displayBox.setHorizontalMargin(widthAndMargin.usedMargin);
- displayBox.setHorizontalComputedMargin(widthAndMargin.computedMargin);
+ displayBox.setContentBoxWidth(contentWidthAndMargin.contentWidth);
+ displayBox.setHorizontalMargin(contentWidthAndMargin.usedMargin);
+ displayBox.setHorizontalComputedMargin(contentWidthAndMargin.computedMargin);
}
void BlockFormattingContext::computeHeightAndMargin(const Box& layoutBox)
{
auto& containingBlockGeometry = geometryForBox(*layoutBox.containingBlock());
- auto compute = [&](auto usedVerticalValues) -> HeightAndMargin {
+ auto compute = [&](auto usedVerticalValues) -> ContentHeightAndMargin {
auto usedHorizontalValues = UsedHorizontalValues { UsedHorizontalValues::Constraints { containingBlockGeometry } };
if (layoutBox.isInFlow())
@@ -408,36 +408,36 @@
};
auto verticalConstraints = UsedVerticalValues::Constraints { containingBlockGeometry };
- auto heightAndMargin = compute(UsedVerticalValues { verticalConstraints });
+ auto contentHeightAndMargin = compute(UsedVerticalValues { verticalConstraints });
if (auto maxHeight = geometry().computedMaxHeight(layoutBox)) {
- if (heightAndMargin.height > *maxHeight) {
+ if (contentHeightAndMargin.contentHeight > *maxHeight) {
auto maxHeightAndMargin = compute(UsedVerticalValues { verticalConstraints, maxHeight });
// Used height should remain the same.
- ASSERT((layoutState().inQuirksMode() && (layoutBox.isBodyBox() || layoutBox.isDocumentBox())) || maxHeightAndMargin.height == *maxHeight);
- heightAndMargin = { *maxHeight, maxHeightAndMargin.nonCollapsedMargin };
+ ASSERT((layoutState().inQuirksMode() && (layoutBox.isBodyBox() || layoutBox.isDocumentBox())) || maxHeightAndMargin.contentHeight == *maxHeight);
+ contentHeightAndMargin = { *maxHeight, maxHeightAndMargin.nonCollapsedMargin };
}
}
if (auto minHeight = geometry().computedMinHeight(layoutBox)) {
- if (heightAndMargin.height < *minHeight) {
+ if (contentHeightAndMargin.contentHeight < *minHeight) {
auto minHeightAndMargin = compute(UsedVerticalValues { verticalConstraints, minHeight });
// Used height should remain the same.
- ASSERT((layoutState().inQuirksMode() && (layoutBox.isBodyBox() || layoutBox.isDocumentBox())) || minHeightAndMargin.height == *minHeight);
- heightAndMargin = { *minHeight, minHeightAndMargin.nonCollapsedMargin };
+ ASSERT((layoutState().inQuirksMode() && (layoutBox.isBodyBox() || layoutBox.isDocumentBox())) || minHeightAndMargin.contentHeight == *minHeight);
+ contentHeightAndMargin = { *minHeight, minHeightAndMargin.nonCollapsedMargin };
}
}
// 1. Compute collapsed margins.
// 2. Adjust vertical position using the collapsed values
// 3. Adjust previous in-flow sibling margin after using this margin.
- auto collapsedMargin = marginCollapse().collapsedVerticalValues(layoutBox, heightAndMargin.nonCollapsedMargin);
- auto verticalMargin = UsedVerticalMargin { heightAndMargin.nonCollapsedMargin, collapsedMargin };
+ auto collapsedMargin = marginCollapse().collapsedVerticalValues(layoutBox, contentHeightAndMargin.nonCollapsedMargin);
+ auto verticalMargin = UsedVerticalMargin { contentHeightAndMargin.nonCollapsedMargin, collapsedMargin };
auto& displayBox = formattingState().displayBox(layoutBox);
// Out of flow boxes don't need vertical adjustment after margin collapsing.
if (layoutBox.isOutOfFlowPositioned()) {
ASSERT(!hasEstimatedMarginBefore(layoutBox));
- displayBox.setContentBoxHeight(heightAndMargin.height);
+ displayBox.setContentBoxHeight(contentHeightAndMargin.contentHeight);
displayBox.setVerticalMargin(verticalMargin);
return;
}
@@ -445,7 +445,7 @@
ASSERT(!hasEstimatedMarginBefore(layoutBox) || estimatedMarginBefore(layoutBox).usedValue() == verticalMargin.before());
removeEstimatedMarginBefore(layoutBox);
displayBox.setTop(verticalPositionWithMargin(layoutBox, verticalMargin));
- displayBox.setContentBoxHeight(heightAndMargin.height);
+ displayBox.setContentBoxHeight(contentHeightAndMargin.contentHeight);
displayBox.setVerticalMargin(verticalMargin);
auto marginCollapse = this->marginCollapse();
diff --git a/Source/WebCore/layout/blockformatting/BlockFormattingContext.h b/Source/WebCore/layout/blockformatting/BlockFormattingContext.h
index 8861db4..fa032f4 100644
--- a/Source/WebCore/layout/blockformatting/BlockFormattingContext.h
+++ b/Source/WebCore/layout/blockformatting/BlockFormattingContext.h
@@ -74,8 +74,8 @@
// This class implements positioning and sizing for boxes participating in a block formatting context.
class Geometry : public FormattingContext::Geometry {
public:
- HeightAndMargin inFlowHeightAndMargin(const Box&, UsedHorizontalValues, UsedVerticalValues);
- WidthAndMargin inFlowWidthAndMargin(const Box&, UsedHorizontalValues);
+ ContentHeightAndMargin inFlowHeightAndMargin(const Box&, UsedHorizontalValues, UsedVerticalValues);
+ ContentWidthAndMargin inFlowWidthAndMargin(const Box&, UsedHorizontalValues);
Point staticPosition(const Box&, UsedHorizontalValues, UsedVerticalValues) const;
LayoutUnit staticVerticalPosition(const Box&, UsedVerticalValues) const;
@@ -87,9 +87,9 @@
friend class BlockFormattingContext;
Geometry(const BlockFormattingContext&);
- HeightAndMargin inFlowNonReplacedHeightAndMargin(const Box&, UsedHorizontalValues, UsedVerticalValues);
- WidthAndMargin inFlowNonReplacedWidthAndMargin(const Box&, UsedHorizontalValues) const;
- WidthAndMargin inFlowReplacedWidthAndMargin(const Box&, UsedHorizontalValues) const;
+ ContentHeightAndMargin inFlowNonReplacedHeightAndMargin(const Box&, UsedHorizontalValues, UsedVerticalValues);
+ ContentWidthAndMargin inFlowNonReplacedWidthAndMargin(const Box&, UsedHorizontalValues) const;
+ ContentWidthAndMargin inFlowReplacedWidthAndMargin(const Box&, UsedHorizontalValues) const;
Point staticPositionForOutOfFlowPositioned(const Box&) const;
const BlockFormattingContext& formattingContext() const { return downcast<BlockFormattingContext>(FormattingContext::Geometry::formattingContext()); }
@@ -140,7 +140,7 @@
class Quirks : public FormattingContext::Quirks {
public:
bool needsStretching(const Box&) const;
- HeightAndMargin stretchedInFlowHeight(const Box&, HeightAndMargin);
+ ContentHeightAndMargin stretchedInFlowHeight(const Box&, ContentHeightAndMargin);
bool shouldIgnoreCollapsedQuirkMargin(const Box&) const;
bool shouldIgnoreMarginBefore(const Box&) const;
diff --git a/Source/WebCore/layout/blockformatting/BlockFormattingContextGeometry.cpp b/Source/WebCore/layout/blockformatting/BlockFormattingContextGeometry.cpp
index 811b163..f275109 100644
--- a/Source/WebCore/layout/blockformatting/BlockFormattingContextGeometry.cpp
+++ b/Source/WebCore/layout/blockformatting/BlockFormattingContextGeometry.cpp
@@ -37,12 +37,12 @@
namespace WebCore {
namespace Layout {
-HeightAndMargin BlockFormattingContext::Geometry::inFlowNonReplacedHeightAndMargin(const Box& layoutBox, UsedHorizontalValues usedHorizontalValues, UsedVerticalValues usedValues)
+ContentHeightAndMargin BlockFormattingContext::Geometry::inFlowNonReplacedHeightAndMargin(const Box& layoutBox, UsedHorizontalValues usedHorizontalValues, UsedVerticalValues usedValues)
{
ASSERT(layoutBox.isInFlow() && !layoutBox.replaced());
ASSERT(layoutBox.isOverflowVisible());
- auto compute = [&]() -> HeightAndMargin {
+ auto compute = [&]() -> ContentHeightAndMargin {
// 10.6.3 Block-level non-replaced elements in normal flow when 'overflow' computes to 'visible'
//
@@ -61,13 +61,10 @@
auto computedVerticalMargin = Geometry::computedVerticalMargin(layoutBox, usedHorizontalValues);
auto nonCollapsedMargin = UsedVerticalMargin::NonCollapsedValues { computedVerticalMargin.before.valueOr(0), computedVerticalMargin.after.valueOr(0) };
auto borderAndPaddingTop = boxGeometry.borderTop() + boxGeometry.paddingTop().valueOr(0);
- auto height = usedValues.height ? usedValues.height.value() : computedHeightValue(layoutBox, HeightType::Normal);
+ auto height = usedValues.height ? usedValues.height.value() : computedContentHeight(layoutBox);
- if (height) {
- auto borderAndPaddingBottom = boxGeometry.borderBottom() + boxGeometry.paddingBottom().valueOr(0);
- auto contentHeight = layoutBox.style().boxSizing() == BoxSizing::ContentBox ? *height : *height - (borderAndPaddingTop + borderAndPaddingBottom);
- return { contentHeight, nonCollapsedMargin };
- }
+ if (height)
+ return { *height, nonCollapsedMargin };
if (!is<Container>(layoutBox) || !downcast<Container>(layoutBox).hasInFlowChild())
return { 0, nonCollapsedMargin };
@@ -103,12 +100,12 @@
return { 0, nonCollapsedMargin };
};
- auto heightAndMargin = compute();
- LOG_WITH_STREAM(FormattingContextLayout, stream << "[Height][Margin] -> inflow non-replaced -> height(" << heightAndMargin.height << "px) margin(" << heightAndMargin.nonCollapsedMargin.before << "px, " << heightAndMargin.nonCollapsedMargin.after << "px) -> layoutBox(" << &layoutBox << ")");
- return heightAndMargin;
+ auto contentHeightAndMargin = compute();
+ LOG_WITH_STREAM(FormattingContextLayout, stream << "[Height][Margin] -> inflow non-replaced -> height(" << contentHeightAndMargin.contentHeight << "px) margin(" << contentHeightAndMargin.nonCollapsedMargin.before << "px, " << contentHeightAndMargin.nonCollapsedMargin.after << "px) -> layoutBox(" << &layoutBox << ")");
+ return contentHeightAndMargin;
}
-WidthAndMargin BlockFormattingContext::Geometry::inFlowNonReplacedWidthAndMargin(const Box& layoutBox, UsedHorizontalValues usedHorizontalValues) const
+ContentWidthAndMargin BlockFormattingContext::Geometry::inFlowNonReplacedWidthAndMargin(const Box& layoutBox, UsedHorizontalValues usedHorizontalValues) const
{
ASSERT(layoutBox.isInFlow());
@@ -195,15 +192,15 @@
ASSERT(width);
- return WidthAndMargin { contentWidth(), usedHorizontalMargin, computedHorizontalMargin };
+ return ContentWidthAndMargin { contentWidth(), usedHorizontalMargin, computedHorizontalMargin };
};
- auto widthAndMargin = compute();
- LOG_WITH_STREAM(FormattingContextLayout, stream << "[Width][Margin] -> inflow non-replaced -> width(" << widthAndMargin.width << "px) margin(" << widthAndMargin.usedMargin.start << "px, " << widthAndMargin.usedMargin.end << "px) -> layoutBox(" << &layoutBox << ")");
- return widthAndMargin;
+ auto contentWidthAndMargin = compute();
+ LOG_WITH_STREAM(FormattingContextLayout, stream << "[Width][Margin] -> inflow non-replaced -> width(" << contentWidthAndMargin.contentWidth << "px) margin(" << contentWidthAndMargin.usedMargin.start << "px, " << contentWidthAndMargin.usedMargin.end << "px) -> layoutBox(" << &layoutBox << ")");
+ return contentWidthAndMargin;
}
-WidthAndMargin BlockFormattingContext::Geometry::inFlowReplacedWidthAndMargin(const Box& layoutBox, UsedHorizontalValues usedValues) const
+ContentWidthAndMargin BlockFormattingContext::Geometry::inFlowReplacedWidthAndMargin(const Box& layoutBox, UsedHorizontalValues usedValues) const
{
ASSERT(layoutBox.isInFlow() && layoutBox.replaced());
@@ -213,7 +210,7 @@
// 2. Then the rules for non-replaced block-level elements are applied to determine the margins.
// #1
- usedValues.width = inlineReplacedWidthAndMargin(layoutBox, usedValues).width;
+ usedValues.width = inlineReplacedWidthAndMargin(layoutBox, usedValues).contentWidth;
// #2
auto nonReplacedWidthAndMargin = inFlowNonReplacedWidthAndMargin(layoutBox, usedValues);
@@ -246,7 +243,7 @@
return { staticHorizontalPosition(layoutBox, usedHorizontalValues), staticVerticalPosition(layoutBox, usedVerticalValues) };
}
-HeightAndMargin BlockFormattingContext::Geometry::inFlowHeightAndMargin(const Box& layoutBox, UsedHorizontalValues usedHorizontalValues, UsedVerticalValues usedVerticalValues)
+ContentHeightAndMargin BlockFormattingContext::Geometry::inFlowHeightAndMargin(const Box& layoutBox, UsedHorizontalValues usedHorizontalValues, UsedVerticalValues usedVerticalValues)
{
ASSERT(layoutBox.isInFlow());
@@ -255,30 +252,30 @@
if (layoutBox.replaced())
return inlineReplacedHeightAndMargin(layoutBox, usedHorizontalValues, usedVerticalValues);
- HeightAndMargin heightAndMargin;
+ ContentHeightAndMargin contentHeightAndMargin;
// FIXME: Let's special case the table height computation for now -> figure out whether tables fall into the "inFlowNonReplacedHeightAndMargin" category.
if (layoutBox.establishesTableFormattingContext())
- heightAndMargin = complicatedCases(layoutBox, usedHorizontalValues, usedVerticalValues);
+ contentHeightAndMargin = complicatedCases(layoutBox, usedHorizontalValues, usedVerticalValues);
else if (layoutBox.isOverflowVisible() && !layoutBox.isDocumentBox()) {
// TODO: Figure out the case for the document element. Let's just complicated-case it for now.
- heightAndMargin = inFlowNonReplacedHeightAndMargin(layoutBox, usedHorizontalValues, usedVerticalValues);
+ contentHeightAndMargin = inFlowNonReplacedHeightAndMargin(layoutBox, usedHorizontalValues, usedVerticalValues);
} 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(layoutBox, usedHorizontalValues, usedVerticalValues);
+ contentHeightAndMargin = complicatedCases(layoutBox, usedHorizontalValues, usedVerticalValues);
}
auto quirks = formattingContext().quirks();
if (!quirks.needsStretching(layoutBox))
- return heightAndMargin;
+ return contentHeightAndMargin;
- heightAndMargin = quirks.stretchedInFlowHeight(layoutBox, heightAndMargin);
+ contentHeightAndMargin = quirks.stretchedInFlowHeight(layoutBox, contentHeightAndMargin);
- LOG_WITH_STREAM(FormattingContextLayout, stream << "[Height][Margin] -> inflow non-replaced -> streched to viewport -> height(" << heightAndMargin.height << "px) margin(" << heightAndMargin.nonCollapsedMargin.before << "px, " << heightAndMargin.nonCollapsedMargin.after << "px) -> layoutBox(" << &layoutBox << ")");
- return heightAndMargin;
+ LOG_WITH_STREAM(FormattingContextLayout, stream << "[Height][Margin] -> inflow non-replaced -> streched to viewport -> height(" << contentHeightAndMargin.contentHeight << "px) margin(" << contentHeightAndMargin.nonCollapsedMargin.before << "px, " << contentHeightAndMargin.nonCollapsedMargin.after << "px) -> layoutBox(" << &layoutBox << ")");
+ return contentHeightAndMargin;
}
-WidthAndMargin BlockFormattingContext::Geometry::inFlowWidthAndMargin(const Box& layoutBox, UsedHorizontalValues usedHorizontalValues)
+ContentWidthAndMargin BlockFormattingContext::Geometry::inFlowWidthAndMargin(const Box& layoutBox, UsedHorizontalValues usedHorizontalValues)
{
ASSERT(layoutBox.isInFlow());
diff --git a/Source/WebCore/layout/blockformatting/BlockFormattingContextQuirks.cpp b/Source/WebCore/layout/blockformatting/BlockFormattingContextQuirks.cpp
index 32495f8..5d96c2b 100644
--- a/Source/WebCore/layout/blockformatting/BlockFormattingContextQuirks.cpp
+++ b/Source/WebCore/layout/blockformatting/BlockFormattingContextQuirks.cpp
@@ -60,7 +60,7 @@
return layoutBox.style().logicalHeight().isAuto();
}
-HeightAndMargin BlockFormattingContext::Quirks::stretchedInFlowHeight(const Box& layoutBox, HeightAndMargin heightAndMargin)
+ContentHeightAndMargin BlockFormattingContext::Quirks::stretchedInFlowHeight(const Box& layoutBox, ContentHeightAndMargin contentHeightAndMargin)
{
ASSERT(layoutBox.isInFlow());
ASSERT(layoutBox.isDocumentBox() || layoutBox.isBodyBox());
@@ -76,7 +76,7 @@
LayoutUnit totalVerticalMargin;
if (layoutBox.isDocumentBox()) {
// Document box's margins do not collapse.
- auto verticalMargin = heightAndMargin.nonCollapsedMargin;
+ auto verticalMargin = contentHeightAndMargin.nonCollapsedMargin;
totalVerticalMargin = verticalMargin.before + verticalMargin.after;
} else if (layoutBox.isBodyBox()) {
// Here is the quirky part for body box:
@@ -88,17 +88,17 @@
auto& bodyBoxGeometry = formattingContext.geometryForBox(layoutBox);
strechedHeight -= bodyBoxGeometry.verticalBorder() + bodyBoxGeometry.verticalPadding().valueOr(0);
- auto nonCollapsedMargin = heightAndMargin.nonCollapsedMargin;
+ auto nonCollapsedMargin = contentHeightAndMargin.nonCollapsedMargin;
auto collapsedMargin = formattingContext.marginCollapse().collapsedVerticalValues(layoutBox, nonCollapsedMargin);
totalVerticalMargin = collapsedMargin.before.valueOr(nonCollapsedMargin.before);
totalVerticalMargin += collapsedMargin.isCollapsedThrough ? nonCollapsedMargin.after : collapsedMargin.after.valueOr(nonCollapsedMargin.after);
}
// Stretch but never overstretch with the margins.
- if (heightAndMargin.height + totalVerticalMargin < strechedHeight)
- heightAndMargin.height = strechedHeight - totalVerticalMargin;
+ if (contentHeightAndMargin.contentHeight + totalVerticalMargin < strechedHeight)
+ contentHeightAndMargin.contentHeight = strechedHeight - totalVerticalMargin;
- return heightAndMargin;
+ return contentHeightAndMargin;
}
bool BlockFormattingContext::Quirks::shouldIgnoreCollapsedQuirkMargin(const Box& layoutBox) const
diff --git a/Source/WebCore/layout/displaytree/DisplayBox.cpp b/Source/WebCore/layout/displaytree/DisplayBox.cpp
index 6ade406..84a993a 100644
--- a/Source/WebCore/layout/displaytree/DisplayBox.cpp
+++ b/Source/WebCore/layout/displaytree/DisplayBox.cpp
@@ -28,7 +28,6 @@
#if ENABLE(LAYOUT_FORMATTING_CONTEXT)
-#include "RenderStyle.h"
#include <wtf/IsoMallocInlines.h>
namespace WebCore {
@@ -36,14 +35,8 @@
WTF_MAKE_ISO_ALLOCATED_IMPL(Box);
-Box::Box(const RenderStyle& style)
- : m_style(style)
-{
-}
-
Box::Box(const Box& other)
- : m_style(other.m_style)
- , m_topLeft(other.m_topLeft)
+ : m_topLeft(other.m_topLeft)
, m_contentWidth(other.m_contentWidth)
, m_contentHeight(other.m_contentHeight)
, m_horizontalMargin(other.m_horizontalMargin)
@@ -72,11 +65,6 @@
{
}
-Box::Style::Style(const RenderStyle& style)
- : boxSizing(style.boxSizing())
-{
-}
-
Rect Box::marginBox() const
{
auto borderBox = this->borderBox();
diff --git a/Source/WebCore/layout/displaytree/DisplayBox.h b/Source/WebCore/layout/displaytree/DisplayBox.h
index 2c31ca7..1f89128 100644
--- a/Source/WebCore/layout/displaytree/DisplayBox.h
+++ b/Source/WebCore/layout/displaytree/DisplayBox.h
@@ -29,20 +29,16 @@
#include "DisplayRect.h"
#include "LayoutUnits.h"
-#include "RenderStyleConstants.h"
#include <wtf/IsoMalloc.h>
namespace WebCore {
-
-class RenderStyle;
-
namespace Display {
class Box {
WTF_MAKE_ISO_ALLOCATED(Box);
public:
- Box(const RenderStyle&);
Box(const Box&);
+ Box() = default;
~Box();
LayoutUnit top() const;
@@ -138,12 +134,6 @@
void setPadding(Optional<Layout::Edges>);
private:
- struct Style {
- Style(const RenderStyle&);
-
- BoxSizing boxSizing { BoxSizing::ContentBox };
- };
-
#if !ASSERT_DISABLED
void invalidateMargin();
void invalidateBorder() { m_hasValidBorder = false; }
@@ -164,8 +154,6 @@
void setHasValidContentWidth() { m_hasValidContentWidth = true; }
#endif
- const Style m_style;
-
LayoutPoint m_topLeft;
LayoutUnit m_contentWidth;
LayoutUnit m_contentHeight;
diff --git a/Source/WebCore/layout/inlineformatting/InlineFormattingContext.cpp b/Source/WebCore/layout/inlineformatting/InlineFormattingContext.cpp
index e61bf03..d4d89e85 100644
--- a/Source/WebCore/layout/inlineformatting/InlineFormattingContext.cpp
+++ b/Source/WebCore/layout/inlineformatting/InlineFormattingContext.cpp
@@ -269,37 +269,37 @@
void InlineFormattingContext::computeWidthAndMargin(const Box& layoutBox, UsedHorizontalValues usedHorizontalValues)
{
- WidthAndMargin widthAndMargin;
+ ContentWidthAndMargin contentWidthAndMargin;
if (layoutBox.isFloatingPositioned())
- widthAndMargin = geometry().floatingWidthAndMargin(layoutBox, usedHorizontalValues);
+ contentWidthAndMargin = geometry().floatingWidthAndMargin(layoutBox, usedHorizontalValues);
else if (layoutBox.isInlineBlockBox())
- widthAndMargin = geometry().inlineBlockWidthAndMargin(layoutBox, usedHorizontalValues);
+ contentWidthAndMargin = geometry().inlineBlockWidthAndMargin(layoutBox, usedHorizontalValues);
else if (layoutBox.replaced())
- widthAndMargin = geometry().inlineReplacedWidthAndMargin(layoutBox, usedHorizontalValues);
+ contentWidthAndMargin = geometry().inlineReplacedWidthAndMargin(layoutBox, usedHorizontalValues);
else
ASSERT_NOT_REACHED();
auto& displayBox = formattingState().displayBox(layoutBox);
- displayBox.setContentBoxWidth(widthAndMargin.width);
- displayBox.setHorizontalMargin(widthAndMargin.usedMargin);
- displayBox.setHorizontalComputedMargin(widthAndMargin.computedMargin);
+ displayBox.setContentBoxWidth(contentWidthAndMargin.contentWidth);
+ displayBox.setHorizontalMargin(contentWidthAndMargin.usedMargin);
+ displayBox.setHorizontalComputedMargin(contentWidthAndMargin.computedMargin);
}
void InlineFormattingContext::computeHeightAndMargin(const Box& layoutBox, UsedHorizontalValues usedHorizontalValues, UsedVerticalValues usedVerticalValues)
{
- HeightAndMargin heightAndMargin;
+ ContentHeightAndMargin contentHeightAndMargin;
if (layoutBox.isFloatingPositioned())
- heightAndMargin = geometry().floatingHeightAndMargin(layoutBox, usedHorizontalValues, usedVerticalValues);
+ contentHeightAndMargin = geometry().floatingHeightAndMargin(layoutBox, usedHorizontalValues, usedVerticalValues);
else if (layoutBox.isInlineBlockBox())
- heightAndMargin = geometry().inlineBlockHeightAndMargin(layoutBox, usedHorizontalValues, usedVerticalValues);
+ contentHeightAndMargin = geometry().inlineBlockHeightAndMargin(layoutBox, usedHorizontalValues, usedVerticalValues);
else if (layoutBox.replaced())
- heightAndMargin = geometry().inlineReplacedHeightAndMargin(layoutBox, usedHorizontalValues, usedVerticalValues);
+ contentHeightAndMargin = geometry().inlineReplacedHeightAndMargin(layoutBox, usedHorizontalValues, usedVerticalValues);
else
ASSERT_NOT_REACHED();
auto& displayBox = formattingState().displayBox(layoutBox);
- displayBox.setContentBoxHeight(heightAndMargin.height);
- displayBox.setVerticalMargin({ heightAndMargin.nonCollapsedMargin, { } });
+ displayBox.setContentBoxHeight(contentHeightAndMargin.contentHeight);
+ displayBox.setVerticalMargin({ contentHeightAndMargin.nonCollapsedMargin, { } });
}
void InlineFormattingContext::computeWidthAndHeightForReplacedInlineBox(const Box& layoutBox, UsedHorizontalValues usedHorizontalValues, UsedVerticalValues usedVerticalValues)
diff --git a/Source/WebCore/layout/inlineformatting/InlineFormattingContext.h b/Source/WebCore/layout/inlineformatting/InlineFormattingContext.h
index 7c11619..b698843 100644
--- a/Source/WebCore/layout/inlineformatting/InlineFormattingContext.h
+++ b/Source/WebCore/layout/inlineformatting/InlineFormattingContext.h
@@ -63,8 +63,8 @@
class Geometry : public FormattingContext::Geometry {
public:
- HeightAndMargin inlineBlockHeightAndMargin(const Box&, UsedHorizontalValues, UsedVerticalValues) const;
- WidthAndMargin inlineBlockWidthAndMargin(const Box&, UsedHorizontalValues);
+ ContentHeightAndMargin inlineBlockHeightAndMargin(const Box&, UsedHorizontalValues, UsedVerticalValues) const;
+ ContentWidthAndMargin inlineBlockWidthAndMargin(const Box&, UsedHorizontalValues);
private:
friend class InlineFormattingContext;
diff --git a/Source/WebCore/layout/inlineformatting/InlineFormattingContextGeometry.cpp b/Source/WebCore/layout/inlineformatting/InlineFormattingContextGeometry.cpp
index dafe1c5..626ee4e 100644
--- a/Source/WebCore/layout/inlineformatting/InlineFormattingContextGeometry.cpp
+++ b/Source/WebCore/layout/inlineformatting/InlineFormattingContextGeometry.cpp
@@ -35,7 +35,7 @@
namespace WebCore {
namespace Layout {
-WidthAndMargin InlineFormattingContext::Geometry::inlineBlockWidthAndMargin(const Box& formattingContextRoot, UsedHorizontalValues usedHorizontalValues)
+ContentWidthAndMargin InlineFormattingContext::Geometry::inlineBlockWidthAndMargin(const Box& formattingContextRoot, UsedHorizontalValues usedHorizontalValues)
{
ASSERT(formattingContextRoot.isInFlow());
@@ -57,10 +57,10 @@
// #2
auto computedHorizontalMargin = Geometry::computedHorizontalMargin(formattingContextRoot, usedHorizontalValues);
- return WidthAndMargin { *width, { computedHorizontalMargin.start.valueOr(0_lu), computedHorizontalMargin.end.valueOr(0_lu) }, computedHorizontalMargin };
+ return ContentWidthAndMargin { *width, { computedHorizontalMargin.start.valueOr(0_lu), computedHorizontalMargin.end.valueOr(0_lu) }, computedHorizontalMargin };
}
-HeightAndMargin InlineFormattingContext::Geometry::inlineBlockHeightAndMargin(const Box& layoutBox, UsedHorizontalValues usedHorizontalValues, UsedVerticalValues usedVerticalValues) const
+ContentHeightAndMargin InlineFormattingContext::Geometry::inlineBlockHeightAndMargin(const Box& layoutBox, UsedHorizontalValues usedHorizontalValues, UsedVerticalValues usedVerticalValues) const
{
ASSERT(layoutBox.isInFlow());
diff --git a/Source/WebCore/layout/tableformatting/TableFormattingContext.cpp b/Source/WebCore/layout/tableformatting/TableFormattingContext.cpp
index 06421b6..2ee019c 100644
--- a/Source/WebCore/layout/tableformatting/TableFormattingContext.cpp
+++ b/Source/WebCore/layout/tableformatting/TableFormattingContext.cpp
@@ -99,7 +99,7 @@
if (is<Container>(cellLayoutBox))
LayoutContext::createFormattingContext(downcast<Container>(cellLayoutBox), layoutState())->layoutInFlowContent();
cellDisplayBox.setVerticalMargin({ { }, { } });
- cellDisplayBox.setContentBoxHeight(geometry().tableCellHeightAndMargin(cellLayoutBox).height);
+ cellDisplayBox.setContentBoxHeight(geometry().tableCellHeightAndMargin(cellLayoutBox).contentHeight);
// FIXME: Check what to do with out-of-flow content.
}
diff --git a/Source/WebCore/layout/tableformatting/TableFormattingContext.h b/Source/WebCore/layout/tableformatting/TableFormattingContext.h
index 983319d..4a6e603 100644
--- a/Source/WebCore/layout/tableformatting/TableFormattingContext.h
+++ b/Source/WebCore/layout/tableformatting/TableFormattingContext.h
@@ -46,7 +46,7 @@
private:
class Geometry : public FormattingContext::Geometry {
public:
- HeightAndMargin tableCellHeightAndMargin(const Box&) const;
+ ContentHeightAndMargin tableCellHeightAndMargin(const Box&) const;
private:
friend class TableFormattingContext;
diff --git a/Source/WebCore/layout/tableformatting/TableFormattingContextGeometry.cpp b/Source/WebCore/layout/tableformatting/TableFormattingContextGeometry.cpp
index fec22f8..421195e 100644
--- a/Source/WebCore/layout/tableformatting/TableFormattingContextGeometry.cpp
+++ b/Source/WebCore/layout/tableformatting/TableFormattingContextGeometry.cpp
@@ -33,16 +33,16 @@
namespace WebCore {
namespace Layout {
-HeightAndMargin TableFormattingContext::Geometry::tableCellHeightAndMargin(const Box& layoutBox) const
+ContentHeightAndMargin TableFormattingContext::Geometry::tableCellHeightAndMargin(const Box& layoutBox) const
{
ASSERT(layoutBox.isInFlow());
- auto height = computedHeightValue(layoutBox, HeightType::Normal);
+ auto height = computedContentHeight(layoutBox);
if (!height)
height = contentHeightForFormattingContextRoot(layoutBox);
// Margins don't apply to internal table elements.
- return HeightAndMargin { *height, { } };
+ return ContentHeightAndMargin { *height, { } };
}
}
