Changeset 260824 in webkit
- Timestamp:
- Apr 28, 2020 7:44:42 AM (4 years ago)
- Location:
- trunk/Source/WebCore
- Files:
-
- 15 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/Source/WebCore/ChangeLog
r260822 r260824 1 2020-04-28 Zalan Bujtas <zalan@apple.com> 2 3 [LFC] Introduce FormattingContext::ConstraintsForInFlowContent 4 https://bugs.webkit.org/show_bug.cgi?id=211113 5 6 Reviewed by Antti Koivisto. 7 8 This makes the layoutInFlowContent() related code look simpler. 9 10 * layout/FormattingContext.cpp: 11 (WebCore::Layout::FormattingContext::layoutOutOfFlowContent): 12 * layout/FormattingContext.h: 13 * layout/LayoutContext.cpp: 14 (WebCore::Layout::LayoutContext::layoutFormattingContextSubtree): 15 * layout/blockformatting/BlockFormattingContext.cpp: 16 (WebCore::Layout::BlockFormattingContext::layoutInFlowContent): 17 * layout/blockformatting/BlockFormattingContext.h: 18 * layout/inlineformatting/InlineFormattingContext.cpp: 19 (WebCore::Layout::InlineFormattingContext::layoutInFlowContent): 20 (WebCore::Layout::InlineFormattingContext::lineLayout): 21 * layout/inlineformatting/InlineFormattingContext.h: 22 * layout/integration/LayoutIntegrationLineLayout.cpp: 23 (WebCore::LayoutIntegration::LineLayout::layout): 24 * layout/tableformatting/TableFormattingContext.cpp: 25 (WebCore::Layout::TableFormattingContext::layoutInFlowContent): 26 (WebCore::Layout::TableFormattingContext::layoutCell): 27 * layout/tableformatting/TableFormattingContext.h: 28 1 29 2020-04-28 Philippe Normand <pnormand@igalia.com> 2 30 -
trunk/Source/WebCore/layout/FormattingContext.cpp
r260510 r260824 171 171 172 172 if (containerBox.hasInFlowOrFloatingChild()) { 173 auto horizontalConstraintsForInFlowContent = Geometry::horizontalConstraintsForInFlow(containerDisplayBox);174 auto verticalConstraintsForInFlowContent = Geometry::verticalConstraintsForInFlow(containerDisplayBox);175 173 auto formattingContext = LayoutContext::createFormattingContext(containerBox, layoutState()); 176 formattingContext->layoutInFlowContent(invalidationState, horizontalConstraintsForInFlowContent, verticalConstraintsForInFlowContent);174 formattingContext->layoutInFlowContent(invalidationState, Geometry::constraintsForInFlowContent(containerDisplayBox)); 177 175 } 178 176 computeOutOfFlowVerticalGeometry(containerBox, horizontalConstraints, verticalConstraints); -
trunk/Source/WebCore/layout/FormattingContext.h
r260510 r260824 66 66 virtual ~FormattingContext(); 67 67 68 virtual void layoutInFlowContent(InvalidationState&, const HorizontalConstraints&, const VerticalConstraints&) = 0; 68 struct ConstraintsForInFlowContent { 69 HorizontalConstraints horizontal; 70 VerticalConstraints vertical; 71 }; 72 virtual void layoutInFlowContent(InvalidationState&, const ConstraintsForInFlowContent&) = 0; 69 73 void layoutOutOfFlowContent(InvalidationState&, const OutOfFlowHorizontalConstraints&, const VerticalConstraints&); 70 74 … … 149 153 static OutOfFlowHorizontalConstraints horizontalConstraintsForOutOfFlow(const Display::Box& containingBlockGeometry); 150 154 static VerticalConstraints verticalConstraintsForOutOfFlow(const Display::Box& containingBlockGeometry); 151 static HorizontalConstraints horizontalConstraintsForInFlow(const Display::Box& containingBlockGeometry); 152 static VerticalConstraints verticalConstraintsForInFlow(const Display::Box& containingBlockGeometry); 155 static FormattingContext::ConstraintsForInFlowContent constraintsForInFlowContent(const Display::Box& containingBlockGeometry); 153 156 154 157 protected: -
trunk/Source/WebCore/layout/FormattingContextGeometry.cpp
r260510 r260824 1111 1111 } 1112 1112 1113 HorizontalConstraints FormattingContext::Geometry::horizontalConstraintsForInFlow(const Display::Box& containingBlockGeometry) 1114 { 1115 return HorizontalConstraints { containingBlockGeometry.contentBoxLeft(), containingBlockGeometry.contentBoxWidth() }; 1116 } 1117 1118 VerticalConstraints FormattingContext::Geometry::verticalConstraintsForInFlow(const Display::Box& containingBlockGeometry) 1119 { 1120 return VerticalConstraints { containingBlockGeometry.contentBoxTop(), { } }; 1113 FormattingContext::ConstraintsForInFlowContent FormattingContext::Geometry::constraintsForInFlowContent(const Display::Box& containingBlockGeometry) 1114 { 1115 return { { containingBlockGeometry.contentBoxLeft(), containingBlockGeometry.contentBoxWidth() }, { containingBlockGeometry.contentBoxTop(), { } } }; 1121 1116 } 1122 1117 -
trunk/Source/WebCore/layout/FormattingContextQuirks.cpp
r258904 r260824 54 54 55 55 auto& containingBlockDisplayBox = formattingContext.geometryForBox(containingBlock->containingBlock(), FormattingContext::EscapeReason::FindFixedHeightAncestorQuirk); 56 auto horizontalConstraints = Geometry:: horizontalConstraintsForInFlow(containingBlockDisplayBox);56 auto horizontalConstraints = Geometry::constraintsForInFlowContent(containingBlockDisplayBox).horizontal; 57 57 auto verticalMargin = formattingContext.geometry().computedVerticalMargin(*containingBlock, horizontalConstraints); 58 58 auto verticalPadding = boxGeometry.paddingTop().valueOr(0) + boxGeometry.paddingBottom().valueOr(0); -
trunk/Source/WebCore/layout/LayoutContext.cpp
r257064 r260824 100 100 101 101 if (formattingContextRoot.hasInFlowOrFloatingChild()) { 102 auto horizontalConstraints = HorizontalConstraints { displayBox.contentBoxLeft(), displayBox.contentBoxWidth() }; 103 auto verticalConstraints = VerticalConstraints { displayBox.contentBoxTop(), { } }; 104 formattingContext->layoutInFlowContent(invalidationState, horizontalConstraints, verticalConstraints); 102 auto constraintsForInFlowContent = FormattingContext::ConstraintsForInFlowContent { { displayBox.contentBoxLeft(), displayBox.contentBoxWidth() }, { displayBox.contentBoxTop(), { } } }; 103 formattingContext->layoutInFlowContent(invalidationState, constraintsForInFlowContent); 105 104 } 106 105 -
trunk/Source/WebCore/layout/blockformatting/BlockFormattingContext.cpp
r259241 r260824 53 53 } 54 54 55 void BlockFormattingContext::layoutInFlowContent(InvalidationState& invalidationState, const HorizontalConstraints& rootHorizontalConstraints, const VerticalConstraints& rootVerticalConstraints)55 void BlockFormattingContext::layoutInFlowContent(InvalidationState& invalidationState, const ConstraintsForInFlowContent& constraints) 56 56 { 57 57 // 9.4.1 Block formatting contexts … … 92 92 }; 93 93 94 auto horizontalConstraintsForLayoutBox = [&] (const auto& layoutBox) {94 auto constraintsForLayoutBox = [&] (const auto& layoutBox) { 95 95 auto& containingBlock = layoutBox.containingBlock(); 96 96 if (&containingBlock == &formattingRoot) 97 return rootHorizontalConstraints; 98 return Geometry::horizontalConstraintsForInFlow(geometryForBox(containingBlock)); 99 }; 100 101 auto verticalConstraintsForLayoutBox = [&] (const auto& layoutBox) { 102 auto& containingBlock = layoutBox.containingBlock(); 103 if (&containingBlock == &formattingRoot) 104 return rootVerticalConstraints; 105 return Geometry::verticalConstraintsForInFlow(geometryForBox(containingBlock)); 97 return constraints; 98 return Geometry::constraintsForInFlowContent(geometryForBox(containingBlock)); 106 99 }; 107 100 … … 117 110 while (true) { 118 111 auto& layoutBox = *layoutQueue.last(); 119 auto horizontalConstraints = horizontalConstraintsForLayoutBox(layoutBox); 120 auto verticalConstraints = verticalConstraintsForLayoutBox(layoutBox); 121 122 computeBorderAndPadding(layoutBox, horizontalConstraints); 123 computeStaticVerticalPosition(layoutBox, verticalConstraints); 124 125 auto horizontalConstraintsPair = ConstraintsPair<HorizontalConstraints> { rootHorizontalConstraints, horizontalConstraints }; 126 auto verticalConstraintsPair = ConstraintsPair<VerticalConstraints> { rootVerticalConstraints, verticalConstraints }; 127 computeWidthAndMargin(floatingContext, layoutBox, horizontalConstraintsPair, verticalConstraintsPair); 128 computeStaticHorizontalPosition(layoutBox, horizontalConstraints); 112 auto containingBlockConstraints = constraintsForLayoutBox(layoutBox); 113 114 computeBorderAndPadding(layoutBox, containingBlockConstraints.horizontal); 115 computeStaticVerticalPosition(layoutBox, containingBlockConstraints.vertical); 116 117 computeWidthAndMargin(floatingContext, layoutBox, { constraints, containingBlockConstraints }); 118 computeStaticHorizontalPosition(layoutBox, containingBlockConstraints.horizontal); 129 119 130 120 if (layoutBox.establishesFormattingContext()) { … … 133 123 if (containerBox.establishesInlineFormattingContext()) { 134 124 // IFCs inherit floats from parent FCs. We need final vertical position to find intruding floats. 135 precomputeVerticalPositionForBoxAndAncestors(containerBox, horizontalConstraintsPair, verticalConstraintsPair);125 precomputeVerticalPositionForBoxAndAncestors(containerBox, { constraints, containingBlockConstraints }); 136 126 if (containerBox.hasFloatClear()) { 137 127 // Roots with clear set are special because they both inherit floats but avoid them the same time. … … 141 131 } 142 132 } 143 auto& rootDisplayBox = geometryForBox(containerBox);144 auto horizontalConstraintsForInFlowContent = Geometry::horizontalConstraintsForInFlow(rootDisplayBox);145 auto verticalConstraintsForInFlowContent = Geometry::verticalConstraintsForInFlow(rootDisplayBox);146 133 // Layout the inflow descendants of this formatting context root. 147 LayoutContext::createFormattingContext(containerBox, layoutState())->layoutInFlowContent(invalidationState, horizontalConstraintsForInFlowContent, verticalConstraintsForInFlowContent);134 LayoutContext::createFormattingContext(containerBox, layoutState())->layoutInFlowContent(invalidationState, Geometry::constraintsForInFlowContent(geometryForBox(containerBox))); 148 135 } 149 136 break; … … 156 143 while (!layoutQueue.isEmpty()) { 157 144 auto& layoutBox = *layoutQueue.takeLast(); 158 auto horizontalConstraints = horizontalConstraintsForLayoutBox(layoutBox); 159 auto verticalConstraints = verticalConstraintsForLayoutBox(layoutBox); 145 auto containingBlockConstraints = constraintsForLayoutBox(layoutBox); 160 146 161 147 // All inflow descendants (if there are any) are laid out by now. Let's compute the box's height. 162 computeHeightAndMargin(layoutBox, horizontalConstraints, verticalConstraints);148 computeHeightAndMargin(layoutBox, containingBlockConstraints); 163 149 164 150 auto establishesFormattingContext = layoutBox.establishesFormattingContext(); … … 175 161 // Resolve final positions. 176 162 if (layoutBox.isFloatAvoider()) { 177 auto horizontalConstraintsPair = ConstraintsPair<HorizontalConstraints> { rootHorizontalConstraints, horizontalConstraints }; 178 auto verticalConstraintsPair = ConstraintsPair<VerticalConstraints> { rootVerticalConstraints, verticalConstraints }; 179 computePositionToAvoidFloats(floatingContext, layoutBox, horizontalConstraintsPair, verticalConstraintsPair); 163 computePositionToAvoidFloats(floatingContext, layoutBox, { constraints, containingBlockConstraints }); 180 164 if (layoutBox.isFloatingPositioned()) 181 165 floatingContext.append(layoutBox); 182 166 } 183 167 if (!establishesFormattingContext && is<ContainerBox>(layoutBox)) 184 placeInFlowPositionedChildren(downcast<ContainerBox>(layoutBox), horizontalConstraints);168 placeInFlowPositionedChildren(downcast<ContainerBox>(layoutBox), containingBlockConstraints.horizontal); 185 169 186 170 if (appendNextToLayoutQueue(layoutBox, LayoutDirection::Sibling)) … … 189 173 } 190 174 // Place the inflow positioned children. 191 placeInFlowPositionedChildren(formattingRoot, rootHorizontalConstraints);175 placeInFlowPositionedChildren(formattingRoot, constraints.horizontal); 192 176 LOG_WITH_STREAM(FormattingContextLayout, stream << "[End] -> block formatting context -> formatting root(" << &root() << ")"); 193 177 } 194 178 195 Optional<LayoutUnit> BlockFormattingContext::usedAvailableWidthForFloatAvoider(const FloatingContext& floatingContext, const Box& layoutBox, const ConstraintsPair <HorizontalConstraints>& horizontalConstraints, const ConstraintsPair<VerticalConstraints>& verticalConstraints)179 Optional<LayoutUnit> BlockFormattingContext::usedAvailableWidthForFloatAvoider(const FloatingContext& floatingContext, const Box& layoutBox, const ConstraintsPair& constraintsPair) 196 180 { 197 181 // Normally the available width for an in-flow block level box is the width of the containing block's content box. … … 207 191 ASSERT(layoutBox.establishesFormattingContext()); 208 192 // Vertical static position is not computed yet for this formatting context root, so let's just pre-compute it for now. 209 precomputeVerticalPositionForBoxAndAncestors(layoutBox, horizontalConstraints, verticalConstraints);193 precomputeVerticalPositionForBoxAndAncestors(layoutBox, constraintsPair); 210 194 211 195 auto mapLogicalTopToFormattingContextRoot = [&] { … … 224 208 return { }; 225 209 // Shrink the available space if the floats are actually intruding at this vertical position. 226 auto availableWidth = horizontalConstraints.containingBlock.logicalWidth;210 auto availableWidth = constraintsPair.containingBlock.horizontal.logicalWidth; 227 211 if (constraints.left) 228 212 availableWidth -= constraints.left->x; 229 213 if (constraints.right) { 230 214 // FIXME: Map the logicalRight to the root's coordinate system. 231 availableWidth -= std::max(0_lu, horizontalConstraints.containingBlock.logicalRight() - constraints.right->x);215 availableWidth -= std::max(0_lu, constraintsPair.containingBlock.horizontal.logicalRight() - constraints.right->x); 232 216 } 233 217 return availableWidth; … … 256 240 } 257 241 258 void BlockFormattingContext::precomputeVerticalPositionForAncestors(const Box& layoutBox, const ConstraintsPair <HorizontalConstraints>& horizontalConstraints, const ConstraintsPair<VerticalConstraints>& verticalConstraints)242 void BlockFormattingContext::precomputeVerticalPositionForAncestors(const Box& layoutBox, const ConstraintsPair& constraintsPair) 259 243 { 260 244 ASSERT(layoutBox.isFloatAvoider()); 261 precomputeVerticalPositionForBoxAndAncestors(layoutBox.containingBlock(), horizontalConstraints, verticalConstraints);262 } 263 264 void BlockFormattingContext::precomputeVerticalPositionForBoxAndAncestors(const Box& layoutBox, const ConstraintsPair <HorizontalConstraints>& horizontalConstraints, const ConstraintsPair<VerticalConstraints>& verticalConstraints)245 precomputeVerticalPositionForBoxAndAncestors(layoutBox.containingBlock(), constraintsPair); 246 } 247 248 void BlockFormattingContext::precomputeVerticalPositionForBoxAndAncestors(const Box& layoutBox, const ConstraintsPair& constraintsPair) 265 249 { 266 250 // In order to figure out whether a box should avoid a float, we need to know the final positions of both (ignore relative positioning for now). … … 275 259 // FIXME: we currently don't account for the "clear" property when computing the final position for an ancestor. 276 260 for (auto* ancestor = &layoutBox; ancestor && ancestor != &root(); ancestor = &ancestor->containingBlock()) { 277 auto horizontalConstraintsForAncestor = [&] {261 auto constraintsForAncestor = [&] { 278 262 auto& containingBlock = ancestor->containingBlock(); 279 return &containingBlock == &root() ? horizontalConstraints.root : Geometry::horizontalConstraintsForInFlow(geometryForBox(containingBlock)); 280 }; 281 auto verticalConstraintsForAncestor = [&] { 282 auto& containingBlock = ancestor->containingBlock(); 283 return &containingBlock == &root() ? verticalConstraints.root : Geometry::verticalConstraintsForInFlow(geometryForBox(containingBlock)); 284 }; 285 286 auto computedVerticalMargin = geometry().computedVerticalMargin(*ancestor, horizontalConstraintsForAncestor()); 263 return &containingBlock == &root() ? constraintsPair.formattingContextRoot : Geometry::constraintsForInFlowContent(geometryForBox(containingBlock)); 264 }(); 265 266 auto computedVerticalMargin = geometry().computedVerticalMargin(*ancestor, constraintsForAncestor.horizontal); 287 267 auto usedNonCollapsedMargin = UsedVerticalMargin::NonCollapsedValues { computedVerticalMargin.before.valueOr(0), computedVerticalMargin.after.valueOr(0) }; 288 268 auto precomputedMarginBefore = marginCollapse().precomputedMarginBefore(*ancestor, usedNonCollapsedMargin); … … 294 274 auto verticalMargin = UsedVerticalMargin { nonCollapsedValues, collapsedValues }; 295 275 displayBox.setVerticalMargin(verticalMargin); 296 displayBox.setTop(verticalPositionWithMargin(*ancestor, verticalMargin, verticalConstraintsForAncestor()));276 displayBox.setTop(verticalPositionWithMargin(*ancestor, verticalMargin, constraintsForAncestor.vertical)); 297 277 #if ASSERT_ENABLED 298 278 setPrecomputedMarginBefore(*ancestor, precomputedMarginBefore); … … 302 282 } 303 283 304 void BlockFormattingContext::computePositionToAvoidFloats(const FloatingContext& floatingContext, const Box& layoutBox, const ConstraintsPair <HorizontalConstraints>& horizontalConstraints, const ConstraintsPair<VerticalConstraints>& verticalConstraints)284 void BlockFormattingContext::computePositionToAvoidFloats(const FloatingContext& floatingContext, const Box& layoutBox, const ConstraintsPair& constraintsPair) 305 285 { 306 286 ASSERT(layoutBox.isFloatAvoider()); … … 310 290 // However according to the BFC rules, at this point of the layout flow we don't yet have computed vertical positions for the ancestors. 311 291 if (layoutBox.isFloatingPositioned()) { 312 precomputeVerticalPositionForAncestors(layoutBox, horizontalConstraints, verticalConstraints);313 formattingState().displayBox(layoutBox).setTopLeft(floatingContext.positionForFloat(layoutBox, horizontalConstraints.containingBlock));292 precomputeVerticalPositionForAncestors(layoutBox, constraintsPair); 293 formattingState().displayBox(layoutBox).setTopLeft(floatingContext.positionForFloat(layoutBox, constraintsPair.containingBlock.horizontal)); 314 294 return; 315 295 } … … 317 297 if (floatingContext.isEmpty()) 318 298 return; 319 precomputeVerticalPositionForAncestors(layoutBox, horizontalConstraints, verticalConstraints);299 precomputeVerticalPositionForAncestors(layoutBox, constraintsPair); 320 300 if (layoutBox.hasFloatClear()) 321 301 return computeVerticalPositionForFloatClear(floatingContext, layoutBox); … … 345 325 } 346 326 347 void BlockFormattingContext::computeWidthAndMargin(const FloatingContext& floatingContext, const Box& layoutBox, const ConstraintsPair <HorizontalConstraints>& horizontalConstraintsPair, const ConstraintsPair<VerticalConstraints>& verticalConstraintsPair)348 { 349 auto& horizontalConstraints = horizontalConstraintsPair.containingBlock;327 void BlockFormattingContext::computeWidthAndMargin(const FloatingContext& floatingContext, const Box& layoutBox, const ConstraintsPair& constraintsPair) 328 { 329 auto& horizontalConstraints = constraintsPair.containingBlock.horizontal; 350 330 auto compute = [&](Optional<LayoutUnit> usedWidth) -> ContentWidthAndMargin { 351 331 if (layoutBox.isFloatingPositioned()) … … 355 335 auto availableWidth = horizontalConstraints.logicalWidth; 356 336 if (layoutBox.style().logicalWidth().isAuto()) 357 availableWidth = usedAvailableWidthForFloatAvoider(floatingContext, layoutBox, horizontalConstraintsPair, verticalConstraintsPair).valueOr(availableWidth);337 availableWidth = usedAvailableWidthForFloatAvoider(floatingContext, layoutBox, constraintsPair).valueOr(availableWidth); 358 338 return geometry().inFlowWidthAndMargin(layoutBox, { horizontalConstraints.logicalLeft, availableWidth }, { usedWidth, { } }); 359 339 } … … 386 366 } 387 367 388 void BlockFormattingContext::computeHeightAndMargin(const Box& layoutBox, const HorizontalConstraints& horizontalConstraints, const VerticalConstraints& verticalConstraints)368 void BlockFormattingContext::computeHeightAndMargin(const Box& layoutBox, const ConstraintsForInFlowContent& constraints) 389 369 { 390 370 auto compute = [&](Optional<LayoutUnit> usedHeight) -> ContentHeightAndMargin { 391 371 if (layoutBox.isInFlow()) 392 return geometry().inFlowHeightAndMargin(layoutBox, horizontalConstraints, { usedHeight });372 return geometry().inFlowHeightAndMargin(layoutBox, constraints.horizontal, { usedHeight }); 393 373 394 374 if (layoutBox.isFloatingPositioned()) 395 return geometry().floatingHeightAndMargin(layoutBox, horizontalConstraints, { usedHeight });375 return geometry().floatingHeightAndMargin(layoutBox, constraints.horizontal, { usedHeight }); 396 376 397 377 ASSERT_NOT_REACHED(); … … 450 430 #endif 451 431 auto& displayBox = formattingState().displayBox(layoutBox); 452 displayBox.setTop(verticalPositionWithMargin(layoutBox, verticalMargin, verticalConstraints));432 displayBox.setTop(verticalPositionWithMargin(layoutBox, verticalMargin, constraints.vertical)); 453 433 displayBox.setContentBoxHeight(contentHeightAndMargin.contentHeight); 454 434 displayBox.setVerticalMargin(verticalMargin); -
trunk/Source/WebCore/layout/blockformatting/BlockFormattingContext.h
r257718 r260824 49 49 BlockFormattingContext(const ContainerBox& formattingContextRoot, BlockFormattingState&); 50 50 51 void layoutInFlowContent(InvalidationState&, const HorizontalConstraints&, const VerticalConstraints&) override;51 void layoutInFlowContent(InvalidationState&, const ConstraintsForInFlowContent&) override; 52 52 53 53 private: 54 54 55 template<typename T>56 55 struct ConstraintsPair { 57 const T root;58 const TcontainingBlock;56 const ConstraintsForInFlowContent formattingContextRoot; 57 const ConstraintsForInFlowContent containingBlock; 59 58 }; 60 59 void placeInFlowPositionedChildren(const ContainerBox&, const HorizontalConstraints&); 61 60 62 void computeWidthAndMargin(const FloatingContext&, const Box&, const ConstraintsPair <HorizontalConstraints>&, const ConstraintsPair<VerticalConstraints>&);63 void computeHeightAndMargin(const Box&, const HorizontalConstraints&, const VerticalConstraints&);61 void computeWidthAndMargin(const FloatingContext&, const Box&, const ConstraintsPair&); 62 void computeHeightAndMargin(const Box&, const ConstraintsForInFlowContent&); 64 63 65 64 void computeStaticHorizontalPosition(const Box&, const HorizontalConstraints&); 66 65 void computeStaticVerticalPosition(const Box&, const VerticalConstraints&); 67 void computePositionToAvoidFloats(const FloatingContext&, const Box&, const ConstraintsPair <HorizontalConstraints>&, const ConstraintsPair<VerticalConstraints>&);66 void computePositionToAvoidFloats(const FloatingContext&, const Box&, const ConstraintsPair&); 68 67 void computeVerticalPositionForFloatClear(const FloatingContext&, const Box&); 69 68 70 void precomputeVerticalPositionForAncestors(const Box&, const ConstraintsPair <HorizontalConstraints>&, const ConstraintsPair<VerticalConstraints>&);71 void precomputeVerticalPositionForBoxAndAncestors(const Box&, const ConstraintsPair <HorizontalConstraints>&, const ConstraintsPair<VerticalConstraints>&);69 void precomputeVerticalPositionForAncestors(const Box&, const ConstraintsPair&); 70 void precomputeVerticalPositionForBoxAndAncestors(const Box&, const ConstraintsPair&); 72 71 73 72 IntrinsicWidthConstraints computedIntrinsicWidthConstraints() override; … … 168 167 BlockFormattingContext::Quirks quirks() const { return Quirks(*this); } 169 168 170 Optional<LayoutUnit> usedAvailableWidthForFloatAvoider(const FloatingContext&, const Box&, const ConstraintsPair <HorizontalConstraints>&, const ConstraintsPair<VerticalConstraints>&);169 Optional<LayoutUnit> usedAvailableWidthForFloatAvoider(const FloatingContext&, const Box&, const ConstraintsPair&); 171 170 172 171 const BlockFormattingState& formattingState() const { return downcast<BlockFormattingState>(FormattingContext::formattingState()); } -
trunk/Source/WebCore/layout/blockformatting/BlockFormattingContextQuirks.cpp
r259180 r260824 92 92 // However the non-in-flow document box's vertical margins are ignored. They don't affect the body box's content height. 93 93 if (documentBox.isInFlow()) { 94 auto precomputeDocumentBoxVerticalMargin = formattingContext.geometry().computedVerticalMargin(documentBox, Geometry:: horizontalConstraintsForInFlow(initialContainingBlockGeometry));94 auto precomputeDocumentBoxVerticalMargin = formattingContext.geometry().computedVerticalMargin(documentBox, Geometry::constraintsForInFlowContent(initialContainingBlockGeometry).horizontal); 95 95 bodyBoxContentHeight -= precomputeDocumentBoxVerticalMargin.before.valueOr(0) + precomputeDocumentBoxVerticalMargin.after.valueOr(0); 96 96 } -
trunk/Source/WebCore/layout/blockformatting/PrecomputedBlockMarginCollapse.cpp
r258819 r260824 45 45 return blockFormattingState.positiveAndNegativeVerticalMargin(layoutBox).before; 46 46 47 auto horizontalConstraints = Geometry:: horizontalConstraintsForInFlow(formattingContext().geometryForBox(layoutBox.containingBlock()));47 auto horizontalConstraints = Geometry::constraintsForInFlowContent(formattingContext().geometryForBox(layoutBox.containingBlock())).horizontal; 48 48 auto computedVerticalMargin = formattingContext().geometry().computedVerticalMargin(layoutBox, horizontalConstraints); 49 49 auto nonCollapsedMargin = UsedVerticalMargin::NonCollapsedValues { computedVerticalMargin.before.valueOr(0), computedVerticalMargin.after.valueOr(0) }; -
trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContext.cpp
r259241 r260824 77 77 } 78 78 79 void InlineFormattingContext::layoutInFlowContent(InvalidationState& invalidationState, const HorizontalConstraints& horizontalConstraints, const VerticalConstraints& verticalConstraints)79 void InlineFormattingContext::layoutInFlowContent(InvalidationState& invalidationState, const ConstraintsForInFlowContent& constraints) 80 80 { 81 81 LOG_WITH_STREAM(FormattingContextLayout, stream << "[Start] -> inline formatting context -> formatting root(" << &root() << ")"); … … 94 94 ASSERT(layoutBox->isInlineBlockBox() || layoutBox->isInlineTableBox() || layoutBox->isFloatingPositioned()); 95 95 auto& containerBox = downcast<ContainerBox>(*layoutBox); 96 computeBorderAndPadding(containerBox, horizontalConstraints);97 computeWidthAndMargin(containerBox, horizontalConstraints);98 99 auto& rootDisplayBox = geometryForBox(containerBox);96 computeBorderAndPadding(containerBox, constraints.horizontal); 97 computeWidthAndMargin(containerBox, constraints.horizontal); 98 99 auto& formattingRootDisplayBox = geometryForBox(containerBox); 100 100 if (containerBox.hasInFlowOrFloatingChild()) { 101 auto horizontalConstraintsForInFlowContent = Geometry::horizontalConstraintsForInFlow(rootDisplayBox);102 auto verticalConstraintsForInFlowContent = Geometry::verticalConstraintsForInFlow(rootDisplayBox);103 101 auto formattingContext = LayoutContext::createFormattingContext(containerBox, layoutState()); 104 formattingContext->layoutInFlowContent(invalidationState, horizontalConstraintsForInFlowContent, verticalConstraintsForInFlowContent);102 formattingContext->layoutInFlowContent(invalidationState, Geometry::constraintsForInFlowContent(formattingRootDisplayBox)); 105 103 } 106 computeHeightAndMargin(containerBox, horizontalConstraints);104 computeHeightAndMargin(containerBox, constraints.horizontal); 107 105 if (containerBox.hasChild()) { 108 auto horizontalConstraintsForOutOfFlow = Geometry::horizontalConstraintsForOutOfFlow( rootDisplayBox);109 auto verticalConstraintsForOutOfFlow = Geometry::verticalConstraintsForOutOfFlow( rootDisplayBox);106 auto horizontalConstraintsForOutOfFlow = Geometry::horizontalConstraintsForOutOfFlow(formattingRootDisplayBox); 107 auto verticalConstraintsForOutOfFlow = Geometry::verticalConstraintsForOutOfFlow(formattingRootDisplayBox); 110 108 auto formattingContext = LayoutContext::createFormattingContext(containerBox, layoutState()); 111 109 formattingContext->layoutOutOfFlowContent(invalidationState, horizontalConstraintsForOutOfFlow, verticalConstraintsForOutOfFlow); … … 113 111 } else { 114 112 // Replaced and other type of leaf atomic inline boxes. 115 computeBorderAndPadding(*layoutBox, horizontalConstraints);116 computeWidthAndMargin(*layoutBox, horizontalConstraints);117 computeHeightAndMargin(*layoutBox, horizontalConstraints);113 computeBorderAndPadding(*layoutBox, constraints.horizontal); 114 computeWidthAndMargin(*layoutBox, constraints.horizontal); 115 computeHeightAndMargin(*layoutBox, constraints.horizontal); 118 116 } 119 117 } else if (layoutBox->isInlineBox()) { … … 121 119 if (!layoutBox->isInlineTextBox() && !layoutBox->isLineBreakBox()) { 122 120 // Inline boxes (<span>) can't get sized/positioned yet. At this point we can only compute their margins, borders and paddings. 123 computeBorderAndPadding(*layoutBox, horizontalConstraints);124 computeHorizontalMargin(*layoutBox, horizontalConstraints);121 computeBorderAndPadding(*layoutBox, constraints.horizontal); 122 computeHorizontalMargin(*layoutBox, constraints.horizontal); 125 123 formattingState().displayBox(*layoutBox).setVerticalMargin({ { }, { } }); 126 124 } … … 134 132 135 133 auto& inlineItems = formattingState().inlineItems(); 136 lineLayout(inlineItems, { 0, inlineItems.size() }, horizontalConstraints, verticalConstraints);134 lineLayout(inlineItems, { 0, inlineItems.size() }, constraints); 137 135 LOG_WITH_STREAM(FormattingContextLayout, stream << "[End] -> inline formatting context -> formatting root(" << &root() << ")"); 138 136 } 139 137 140 void InlineFormattingContext::lineLayout(InlineItems& inlineItems, LineLayoutContext::InlineItemRange layoutRange, const HorizontalConstraints& horizontalConstraints, const VerticalConstraints& verticalConstraints)141 { 142 auto lineLogicalTop = verticalConstraints.logicalTop;138 void InlineFormattingContext::lineLayout(InlineItems& inlineItems, LineLayoutContext::InlineItemRange layoutRange, const ConstraintsForInFlowContent& constraints) 139 { 140 auto lineLogicalTop = constraints.vertical.logicalTop; 143 141 struct PreviousLineEnd { 144 142 unsigned runIndex; … … 150 148 151 149 while (!layoutRange.isEmpty()) { 152 lineBuilder.initialize(constraintsForLine( horizontalConstraints, lineLogicalTop));150 lineBuilder.initialize(constraintsForLine(constraints.horizontal, lineLogicalTop)); 153 151 auto lineContent = lineLayoutContext.layoutLine(lineBuilder, layoutRange, previousLineEnd ? previousLineEnd->overflowContentLength : WTF::nullopt); 154 setDisplayBoxesForLine(lineContent, horizontalConstraints);152 setDisplayBoxesForLine(lineContent, constraints.horizontal); 155 153 156 154 if (lineContent.trailingInlineItemIndex) { -
trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContext.h
r258138 r260824 44 44 public: 45 45 InlineFormattingContext(const ContainerBox& formattingContextRoot, InlineFormattingState&); 46 void layoutInFlowContent(InvalidationState&, const HorizontalConstraints&, const VerticalConstraints&) override;46 void layoutInFlowContent(InvalidationState&, const ConstraintsForInFlowContent&) override; 47 47 48 48 private: … … 78 78 InlineFormattingContext::Geometry geometry() const { return Geometry(*this); } 79 79 80 void lineLayout(InlineItems&, LineLayoutContext::InlineItemRange, const HorizontalConstraints&, const VerticalConstraints&);80 void lineLayout(InlineItems&, LineLayoutContext::InlineItemRange, const ConstraintsForInFlowContent&); 81 81 82 82 void computeIntrinsicWidthForFormattingRoot(const Box&); -
trunk/Source/WebCore/layout/integration/LayoutIntegrationLineLayout.cpp
r258508 r260824 111 111 auto verticalConstraints = Layout::VerticalConstraints { m_flow.borderAndPaddingBefore(), { } }; 112 112 113 inlineFormattingContext.layoutInFlowContent(invalidationState, horizontalConstraints, verticalConstraints);113 inlineFormattingContext.layoutInFlowContent(invalidationState, { horizontalConstraints, verticalConstraints }); 114 114 m_inlineFormattingState.shrinkDisplayInlineContent(); 115 115 } -
trunk/Source/WebCore/layout/tableformatting/TableFormattingContext.cpp
r260726 r260824 49 49 } 50 50 51 void TableFormattingContext::layoutInFlowContent(InvalidationState&, const HorizontalConstraints& horizontalConstraints, const VerticalConstraints& verticalConstraints) 52 { 51 void TableFormattingContext::layoutInFlowContent(InvalidationState&, const ConstraintsForInFlowContent& constraints) 52 { 53 auto availableHorizontalSpace = constraints.horizontal.logicalWidth; 54 auto availableVerticalSpace = constraints.vertical.logicalHeight; 53 55 // 1. Compute width and height for the grid. 54 computeAndDistributeExtraHorizontalSpace( horizontalConstraints.logicalWidth);55 computeAndDistributeExtraVerticalSpace( horizontalConstraints.logicalWidth, verticalConstraints.logicalHeight);56 computeAndDistributeExtraHorizontalSpace(availableHorizontalSpace); 57 computeAndDistributeExtraVerticalSpace(availableHorizontalSpace, availableVerticalSpace); 56 58 // 2. Finalize cells. 57 setUsedGeometryForCells( horizontalConstraints.logicalWidth);59 setUsedGeometryForCells(availableHorizontalSpace); 58 60 // 3. Finalize rows. 59 setUsedGeometryForRows( horizontalConstraints.logicalWidth);61 setUsedGeometryForRows(availableHorizontalSpace); 60 62 // 4. Finalize sections. 61 setUsedGeometryForSections( horizontalConstraints.logicalWidth);63 setUsedGeometryForSections(availableHorizontalSpace); 62 64 } 63 65 … … 175 177 176 178 if (cellBox.hasInFlowOrFloatingChild()) { 177 auto horizontalConstraintsForCellContent = Geometry::horizontalConstraintsForInFlow(cellDisplayBox);178 auto verticalConstraintsForCellContent = VerticalConstraints { cellDisplayBox.contentBoxTop(), usedCellHeight };179 179 auto invalidationState = InvalidationState { }; 180 LayoutContext::createFormattingContext(cellBox, layoutState())->layoutInFlowContent(invalidationState, horizontalConstraintsForCellContent, verticalConstraintsForCellContent); 180 auto constraintsForCellContent = Geometry::constraintsForInFlowContent(cellDisplayBox); 181 constraintsForCellContent.vertical.logicalHeight = usedCellHeight; 182 LayoutContext::createFormattingContext(cellBox, layoutState())->layoutInFlowContent(invalidationState, constraintsForCellContent); 181 183 } 182 184 cellDisplayBox.setContentBoxHeight(geometry().cellHeigh(cellBox)); -
trunk/Source/WebCore/layout/tableformatting/TableFormattingContext.h
r260703 r260824 43 43 public: 44 44 TableFormattingContext(const ContainerBox& formattingContextRoot, TableFormattingState&); 45 void layoutInFlowContent(InvalidationState&, const HorizontalConstraints&, const VerticalConstraints&) override;45 void layoutInFlowContent(InvalidationState&, const ConstraintsForInFlowContent&) override; 46 46 47 47 private:
Note: See TracChangeset
for help on using the changeset viewer.