| Index: third_party/WebKit/Source/core/layout/LayoutBlockFlow.cpp
|
| diff --git a/third_party/WebKit/Source/core/layout/LayoutBlockFlow.cpp b/third_party/WebKit/Source/core/layout/LayoutBlockFlow.cpp
|
| index cfeedd4c6bbd355bf8b39c708de3956c23141360..1db10e88cfd54350d1c0147cebcb257289894492 100644
|
| --- a/third_party/WebKit/Source/core/layout/LayoutBlockFlow.cpp
|
| +++ b/third_party/WebKit/Source/core/layout/LayoutBlockFlow.cpp
|
| @@ -75,27 +75,33 @@ static_assert(sizeof(LayoutBlockFlow::MarginValues) == sizeof(LayoutUnit[4]),
|
|
|
| // Caches all our current margin collapsing state.
|
| class MarginInfo {
|
| - // Collapsing flags for whether we can collapse our margins with our children's margins.
|
| + // Collapsing flags for whether we can collapse our margins with our
|
| + // children's margins.
|
| bool m_canCollapseWithChildren : 1;
|
| bool m_canCollapseMarginBeforeWithChildren : 1;
|
| bool m_canCollapseMarginAfterWithChildren : 1;
|
| bool m_canCollapseMarginAfterWithLastChild : 1;
|
|
|
| - // Whether or not we are a quirky container, i.e., do we collapse away top and bottom
|
| - // margins in our container. Table cells and the body are the common examples. We
|
| - // also have a custom style property for Safari RSS to deal with TypePad blog articles.
|
| + // Whether or not we are a quirky container, i.e., do we collapse away top and
|
| + // bottom margins in our container. Table cells and the body are the common
|
| + // examples. We also have a custom style property for Safari RSS to deal with
|
| + // TypePad blog articles.
|
| bool m_quirkContainer : 1;
|
|
|
| - // This flag tracks whether we are still looking at child margins that can all collapse together at the beginning of a block.
|
| - // They may or may not collapse with the top margin of the block (|m_canCollapseTopWithChildren| tells us that), but they will
|
| - // always be collapsing with one another. This variable can remain set to true through multiple iterations
|
| - // as long as we keep encountering self-collapsing blocks.
|
| + // This flag tracks whether we are still looking at child margins that can all
|
| + // collapse together at the beginning of a block. They may or may not collapse
|
| + // with the top margin of the block (|m_canCollapseTopWithChildren| tells us
|
| + // that), but they will always be collapsing with one another. This variable
|
| + // can remain set to true through multiple iterations as long as we keep
|
| + // encountering self-collapsing blocks.
|
| bool m_atBeforeSideOfBlock : 1;
|
|
|
| - // This flag is set when we know we're examining bottom margins and we know we're at the bottom of the block.
|
| + // This flag is set when we know we're examining bottom margins and we know
|
| + // we're at the bottom of the block.
|
| bool m_atAfterSideOfBlock : 1;
|
|
|
| - // These variables are used to detect quirky margins that we need to collapse away (in table cells
|
| + // These variables are used to detect quirky margins that we need to collapse
|
| + // away (in table cells
|
| // and in the body element).
|
| bool m_hasMarginBeforeQuirk : 1;
|
| bool m_hasMarginAfterQuirk : 1;
|
| @@ -190,9 +196,10 @@ class MarginInfo {
|
| }
|
| };
|
|
|
| -// Some features, such as floats, margin collapsing and fragmentation, require some knowledge about
|
| -// things that happened when laying out previous block child siblings. Only looking at the object
|
| -// currently being laid out isn't always enough.
|
| +// Some features, such as floats, margin collapsing and fragmentation, require
|
| +// some knowledge about things that happened when laying out previous block
|
| +// child siblings. Only looking at the object currently being laid out isn't
|
| +// always enough.
|
| class BlockChildrenLayoutInfo {
|
| public:
|
| BlockChildrenLayoutInfo(LayoutBlockFlow* blockFlow,
|
| @@ -202,9 +209,10 @@ class BlockChildrenLayoutInfo {
|
| m_previousBreakAfterValue(BreakAuto),
|
| m_isAtFirstInFlowChild(true) {}
|
|
|
| - // Store multicol layout state before first layout of a block child. The child may contain a
|
| - // column spanner. If we need to re-lay out the block child because our initial logical top
|
| - // estimate was wrong, we need to roll back to how things were before laying out the child.
|
| + // Store multicol layout state before first layout of a block child. The child
|
| + // may contain a column spanner. If we need to re-lay out the block child
|
| + // because our initial logical top estimate was wrong, we need to roll back to
|
| + // how things were before laying out the child.
|
| void storeMultiColumnLayoutState(const LayoutFlowThread& flowThread) {
|
| m_multiColumnLayoutState = flowThread.multiColumnLayoutState();
|
| }
|
| @@ -274,15 +282,17 @@ void LayoutBlockFlow::checkForPaginationLogicalHeightChange(
|
| bool& pageLogicalHeightChanged,
|
| bool& hasSpecifiedPageLogicalHeight) {
|
| if (LayoutMultiColumnFlowThread* flowThread = multiColumnFlowThread()) {
|
| - // Calculate the non-auto content box height, or set it to 0 if it's auto. We need to know
|
| - // this before layout, so that we can figure out where to insert column breaks. We also
|
| - // treat LayoutView (which may be paginated, which uses the multicol implmentation) as
|
| - // having non-auto height, since its height is deduced from the viewport height. We use
|
| - // computeLogicalHeight() to calculate the content box height. That method will clamp
|
| - // against max-height and min-height. Since we're now at the beginning of layout, and we
|
| - // don't know the actual height of the content yet, only call that method when height is
|
| - // definite, or we might fool ourselves into believing that columns have a definite height
|
| - // when they in fact don't.
|
| + // Calculate the non-auto content box height, or set it to 0 if it's auto.
|
| + // We need to know this before layout, so that we can figure out where to
|
| + // insert column breaks. We also treat LayoutView (which may be paginated,
|
| + // which uses the multicol implmentation) as having non-auto height, since
|
| + // its height is deduced from the viewport height.
|
| + // We use computeLogicalHeight() to calculate the content box height. That
|
| + // method will clamp against max-height and min-height. Since we're now at
|
| + // the beginning of layout, and we don't know the actual height of the
|
| + // content yet, only call that method when height is definite, or we might
|
| + // fool ourselves into believing that columns have a definite height when
|
| + // they in fact don't.
|
| LayoutUnit columnHeight;
|
| if (hasDefiniteLogicalHeight() || isLayoutView()) {
|
| LogicalExtentComputedValues computedValues;
|
| @@ -296,15 +306,17 @@ void LayoutBlockFlow::checkForPaginationLogicalHeightChange(
|
| } else if (isLayoutFlowThread()) {
|
| LayoutFlowThread* flowThread = toLayoutFlowThread(this);
|
|
|
| - // FIXME: This is a hack to always make sure we have a page logical height, if said height
|
| - // is known. The page logical height thing in LayoutState is meaningless for flow
|
| - // thread-based pagination (page height isn't necessarily uniform throughout the flow
|
| - // thread), but as long as it is used universally as a means to determine whether page
|
| - // height is known or not, we need this. Page height is unknown when column balancing is
|
| - // enabled and flow thread height is still unknown (i.e. during the first layout pass). When
|
| - // it's unknown, we need to prevent the pagination code from assuming page breaks everywhere
|
| - // and thereby eating every top margin. It should be trivial to clean up and get rid of this
|
| - // hack once the old multicol implementation is gone.
|
| + // FIXME: This is a hack to always make sure we have a page logical height,
|
| + // if said height is known. The page logical height thing in LayoutState is
|
| + // meaningless for flow thread-based pagination (page height isn't
|
| + // necessarily uniform throughout the flow thread), but as long as it is
|
| + // used universally as a means to determine whether page height is known or
|
| + // not, we need this. Page height is unknown when column balancing is
|
| + // enabled and flow thread height is still unknown (i.e. during the first
|
| + // layout pass). When it's unknown, we need to prevent the pagination code
|
| + // from assuming page breaks everywhere and thereby eating every top margin.
|
| + // It should be trivial to clean up and get rid of this hack once the old
|
| + // multicol implementation is gone.
|
| pageLogicalHeight =
|
| flowThread->isPageLogicalHeightKnown() ? LayoutUnit(1) : LayoutUnit();
|
|
|
| @@ -322,8 +334,8 @@ void LayoutBlockFlow::setBreakAtLineToAvoidWidow(int lineToBreak) {
|
| void LayoutBlockFlow::setDidBreakAtLineToAvoidWidow() {
|
| ASSERT(!shouldBreakAtLineToAvoidWidow());
|
|
|
| - // This function should be called only after a break was applied to avoid widows
|
| - // so assert |m_rareData| exists.
|
| + // This function should be called only after a break was applied to avoid
|
| + // widows so assert |m_rareData| exists.
|
| ASSERT(m_rareData);
|
|
|
| m_rareData->m_didBreakAtLineToAvoidWidow = true;
|
| @@ -346,9 +358,10 @@ void LayoutBlockFlow::clearShouldBreakAtLineToAvoidWidow() const {
|
|
|
| bool LayoutBlockFlow::isSelfCollapsingBlock() const {
|
| if (needsLayout()) {
|
| - // Sometimes we don't lay out objects in DOM order (column spanners being one such relevant
|
| - // type of object right here). As long as the object in question establishes a new
|
| - // formatting context, that's nothing to worry about, though.
|
| + // Sometimes we don't lay out objects in DOM order (column spanners being
|
| + // one such relevant type of object right here). As long as the object in
|
| + // question establishes a new formatting context, that's nothing to worry
|
| + // about, though.
|
| ASSERT(createsNewFormattingContext());
|
| return false;
|
| }
|
| @@ -358,10 +371,12 @@ bool LayoutBlockFlow::isSelfCollapsingBlock() const {
|
|
|
| bool LayoutBlockFlow::checkIfIsSelfCollapsingBlock() const {
|
| // We are not self-collapsing if we
|
| - // (a) have a non-zero height according to layout (an optimization to avoid wasting time)
|
| + // (a) have a non-zero height according to layout (an optimization to avoid
|
| + // wasting time)
|
| // (b) have border/padding,
|
| // (c) have a min-height
|
| - // (d) have specified that one of our margins can't collapse using a CSS extension
|
| + // (d) have specified that one of our margins can't collapse using a CSS
|
| + // extension
|
| // (e) establish a new block formatting context.
|
|
|
| // The early exit must be done before we check for clean layout.
|
| @@ -371,9 +386,10 @@ bool LayoutBlockFlow::checkIfIsSelfCollapsingBlock() const {
|
| if (createsNewFormattingContext())
|
| return false;
|
|
|
| - // Placeholder elements are not laid out until the dimensions of their parent text control are known, so they
|
| - // don't get layout until their parent has had layout - this is unique in the layout tree and means
|
| - // when we call isSelfCollapsingBlock on them we find that they still need layout.
|
| + // Placeholder elements are not laid out until the dimensions of their parent
|
| + // text control are known, so they don't get layout until their parent has had
|
| + // layout - this is unique in the layout tree and means when we call
|
| + // isSelfCollapsingBlock on them we find that they still need layout.
|
| ASSERT(!needsLayout() ||
|
| (node() && node()->isElementNode() &&
|
| toElement(node())->shadowPseudoId() == "-webkit-input-placeholder"));
|
| @@ -395,18 +411,20 @@ bool LayoutBlockFlow::checkIfIsSelfCollapsingBlock() const {
|
| }
|
| }
|
|
|
| - // If the height is 0 or auto, then whether or not we are a self-collapsing block depends
|
| - // on whether we have content that is all self-collapsing or not.
|
| + // If the height is 0 or auto, then whether or not we are a self-collapsing
|
| + // block depends on whether we have content that is all self-collapsing.
|
| // TODO(alancutter): Make this work correctly for calc lengths.
|
| if (hasAutoHeight || ((logicalHeightLength.isFixed() ||
|
| logicalHeightLength.isPercentOrCalc()) &&
|
| logicalHeightLength.isZero())) {
|
| - // If the block has inline children, see if we generated any line boxes. If we have any
|
| - // line boxes, then we can't be self-collapsing, since we have content.
|
| + // If the block has inline children, see if we generated any line boxes.
|
| + // If we have any line boxes, then we can't be self-collapsing, since we
|
| + // have content.
|
| if (childrenInline())
|
| return !firstLineBox();
|
|
|
| - // Whether or not we collapse is dependent on whether all our normal flow children
|
| + // Whether or not we collapse is dependent on whether all our normal flow
|
| + // children
|
| // are also self-collapsing.
|
| for (LayoutBox* child = firstChildBox(); child;
|
| child = child->nextSiblingBox()) {
|
| @@ -474,16 +492,17 @@ inline bool LayoutBlockFlow::layoutBlockFlow(bool relayoutChildren,
|
| LayoutState state(*this, locationOffset(), pageLogicalHeight,
|
| pageLogicalHeightChanged, logicalWidthChanged);
|
|
|
| - // We use four values, maxTopPos, maxTopNeg, maxBottomPos, and maxBottomNeg, to track
|
| - // our current maximal positive and negative margins. These values are used when we
|
| - // are collapsed with adjacent blocks, so for example, if you have block A and B
|
| - // collapsing together, then you'd take the maximal positive margin from both A and B
|
| - // and subtract it from the maximal negative margin from both A and B to get the
|
| - // true collapsed margin. This algorithm is recursive, so when we finish layout()
|
| - // our block knows its current maximal positive/negative values.
|
| + // We use four values, maxTopPos, maxTopNeg, maxBottomPos, and maxBottomNeg,
|
| + // to track our current maximal positive and negative margins. These values
|
| + // are used when we are collapsed with adjacent blocks, so for example, if you
|
| + // have block A and B collapsing together, then you'd take the maximal
|
| + // positive margin from both A and B and subtract it from the maximal negative
|
| + // margin from both A and B to get the true collapsed margin. This algorithm
|
| + // is recursive, so when we finish layout() our block knows its current
|
| + // maximal positive/negative values.
|
| //
|
| - // Start out by setting our margin values to our current margins. Table cells have
|
| - // no margins, so we don't fill in the values for table cells.
|
| + // Start out by setting our margin values to our current margins. Table cells
|
| + // have no margins, so we don't fill in the values for table cells.
|
| if (!isTableCell()) {
|
| initMaxMarginValues();
|
| setHasMarginBeforeQuirk(style()->hasMarginBeforeQuirk());
|
| @@ -493,12 +512,13 @@ inline bool LayoutBlockFlow::layoutBlockFlow(bool relayoutChildren,
|
| if (state.isPaginated()) {
|
| setPaginationStrutPropagatedFromChild(LayoutUnit());
|
|
|
| - // Start with any applicable computed break-after and break-before values for this
|
| - // object. During child layout, breakBefore will be joined with the breakBefore value of
|
| - // the first in-flow child, and breakAfter will be joined with the breakAfter value of the
|
| - // last in-flow child. This is done in order to honor the requirement that a class A break
|
| - // point [1] may only exists *between* in-flow siblings (i.e. not before the first child
|
| - // and not after the last child).
|
| + // Start with any applicable computed break-after and break-before values
|
| + // for this object. During child layout, breakBefore will be joined with the
|
| + // breakBefore value of the first in-flow child, and breakAfter will be
|
| + // joined with the breakAfter value of the last in-flow child. This is done
|
| + // in order to honor the requirement that a class A break point [1] may only
|
| + // exists *between* in-flow siblings (i.e. not before the first child and
|
| + // not after the last child).
|
| //
|
| // [1] https://drafts.csswg.org/css-break/#possible-breaks
|
| setBreakBefore(LayoutBlock::breakBefore());
|
| @@ -529,9 +549,10 @@ inline bool LayoutBlockFlow::layoutBlockFlow(bool relayoutChildren,
|
| bool preferredLogicalWidthsBecameDirty =
|
| !preferredLogicalWidthsWereDirty && preferredLogicalWidthsDirty();
|
| if (preferredLogicalWidthsBecameDirty) {
|
| - // The only thing that should dirty preferred widths at this point is the addition of
|
| - // overflow:auto scrollbars in a descendant. To avoid a potential infinite loop,
|
| - // run layout again with auto scrollbars frozen in their current state.
|
| + // The only thing that should dirty preferred widths at this point is the
|
| + // addition of overflow:auto scrollbars in a descendant. To avoid a
|
| + // potential infinite loop, run layout again with auto scrollbars frozen in
|
| + // their current state.
|
| PaintLayerScrollableArea::FreezeScrollbarsScope freezeScrollbars;
|
| return layoutBlockFlow(relayoutChildren, pageLogicalHeight, layoutScope);
|
| }
|
| @@ -565,7 +586,8 @@ inline bool LayoutBlockFlow::layoutBlockFlow(bool relayoutChildren,
|
| // One of our children's floats may have become an overhanging float for us.
|
| for (LayoutObject* child = lastChild(); child;
|
| child = child->previousSibling()) {
|
| - // TODO(robhogan): We should exclude blocks that create formatting contexts, not just out of flow or floating blocks.
|
| + // TODO(robhogan): We should exclude blocks that create formatting
|
| + // contexts, not just out of flow or floating blocks.
|
| if (child->isLayoutBlockFlow() &&
|
| !child->isFloatingOrOutOfFlowPositioned()) {
|
| LayoutBlockFlow* block = toLayoutBlockFlow(child);
|
| @@ -580,8 +602,10 @@ inline bool LayoutBlockFlow::layoutBlockFlow(bool relayoutChildren,
|
| addedOverhangingFloats = true;
|
| }
|
| }
|
| - // If we have no overhanging floats we still pass a record of the lowest non-overhanging float up the tree so we can enclose it if
|
| - // we are a formatting context and allow siblings to avoid it if they have negative margin and find themselves in its vicinity.
|
| + // If we have no overhanging floats we still pass a record of the lowest
|
| + // non-overhanging float up the tree so we can enclose it if we are a
|
| + // formatting context and allow siblings to avoid it if they have negative
|
| + // margin and find themselves in its vicinity.
|
| if (!addedOverhangingFloats)
|
| addLowestFloatFromChildren(lowestBlock);
|
| }
|
| @@ -595,7 +619,8 @@ inline bool LayoutBlockFlow::layoutBlockFlow(bool relayoutChildren,
|
| ? ForcedLayoutAfterContainingBlockMoved
|
| : DefaultLayout);
|
|
|
| - // Add overflow from children (unless we're multi-column, since in that case all our child overflow is clipped anyway).
|
| + // Add overflow from children (unless we're multi-column, since in that case
|
| + // all our child overflow is clipped anyway).
|
| computeOverflow(oldClientAfterEdge);
|
|
|
| m_descendantsWithFloatsMarkedForLayout = false;
|
| @@ -641,10 +666,11 @@ void LayoutBlockFlow::determineLogicalLeftPositionForChild(LayoutBox& child) {
|
| startOffsetForLine(logicalTopForChild(child), DoNotIndentText,
|
| logicalHeightForChild(child));
|
|
|
| - // If the child has an offset from the content edge to avoid floats then use that, otherwise let any negative
|
| - // margin pull it back over the content edge or any positive margin push it out.
|
| - // If the child is being centred then the margin calculated to do that has factored in any offset required to
|
| - // avoid floats, so use it if necessary.
|
| + // If the child has an offset from the content edge to avoid floats then use
|
| + // that, otherwise let any negative margin pull it back over the content
|
| + // edge or any positive margin push it out.
|
| + // If the child is being centred then the margin calculated to do that has
|
| + // factored in any offset required to avoid floats, so use it if necessary.
|
| if (style()->textAlign() == WEBKIT_CENTER ||
|
| child.style()->marginStartUsing(style()).isAuto())
|
| newPosition =
|
| @@ -681,21 +707,21 @@ void LayoutBlockFlow::markDescendantsWithFloatsForLayoutIfNeeded(
|
| LayoutBlockFlow& child,
|
| LayoutUnit newLogicalTop,
|
| LayoutUnit previousFloatLogicalBottom) {
|
| - // TODO(mstensho): rework the code to return early when there is no need for marking, instead
|
| - // of this |markDescendantsWithFloats| flag.
|
| + // TODO(mstensho): rework the code to return early when there is no need for
|
| + // marking, instead of this |markDescendantsWithFloats| flag.
|
| bool markDescendantsWithFloats = false;
|
| if (newLogicalTop != child.logicalTop() && !child.avoidsFloats() &&
|
| child.containsFloats()) {
|
| markDescendantsWithFloats = true;
|
| } else if (UNLIKELY(newLogicalTop.mightBeSaturated())) {
|
| - // The logical top might be saturated for very large elements. Comparing with the old
|
| - // logical top might then yield a false negative, as adding and removing margins, borders
|
| - // etc. from a saturated number might yield incorrect results. If this is the case, always
|
| - // mark for layout.
|
| + // The logical top might be saturated for very large elements. Comparing
|
| + // with the old logical top might then yield a false negative, as adding and
|
| + // removing margins, borders etc. from a saturated number might yield
|
| + // incorrect results. If this is the case, always mark for layout.
|
| markDescendantsWithFloats = true;
|
| } else if (!child.avoidsFloats() || child.shrinkToAvoidFloats()) {
|
| - // If an element might be affected by the presence of floats, then always mark it for
|
| - // layout.
|
| + // If an element might be affected by the presence of floats, then always
|
| + // mark it for layout.
|
| if (std::max(previousFloatLogicalBottom, lowestFloatLogicalBottom()) >
|
| newLogicalTop)
|
| markDescendantsWithFloats = true;
|
| @@ -720,8 +746,9 @@ bool LayoutBlockFlow::positionAndLayoutOnceIfNeeded(
|
| markDescendantsWithFloatsForLayoutIfNeeded(childBlockFlow, newLogicalTop,
|
| previousFloatLogicalBottom);
|
|
|
| - // TODO(mstensho): A writing mode root is one thing, but we should be able to skip anything
|
| - // that establishes a new block formatting context here. Their floats don't affect us.
|
| + // TODO(mstensho): A writing mode root is one thing, but we should be able
|
| + // to skip anything that establishes a new block formatting context here.
|
| + // Their floats don't affect us.
|
| if (!childBlockFlow.isWritingModeRoot())
|
| previousFloatLogicalBottom =
|
| std::max(previousFloatLogicalBottom,
|
| @@ -735,8 +762,9 @@ bool LayoutBlockFlow::positionAndLayoutOnceIfNeeded(
|
| SubtreeLayoutScope layoutScope(child);
|
| if (!child.needsLayout()) {
|
| if (newLogicalTop != oldLogicalTop && child.shrinkToAvoidFloats()) {
|
| - // The child's width is affected by adjacent floats. When the child shifts to clear an
|
| - // item, its width can change (because it has more available width).
|
| + // The child's width is affected by adjacent floats. When the child shifts
|
| + // to clear an item, its width can change (because it has more available
|
| + // width).
|
| layoutScope.setChildNeedsLayout(&child);
|
| } else {
|
| markChildForPaginationRelayoutIfNeeded(child, layoutScope);
|
| @@ -753,15 +781,17 @@ void LayoutBlockFlow::insertForcedBreakBeforeChildIfNeeded(
|
| LayoutBox& child,
|
| BlockChildrenLayoutInfo& layoutInfo) {
|
| if (layoutInfo.isAtFirstInFlowChild()) {
|
| - // There's no class A break point before the first child (only *between* siblings), so
|
| - // steal its break value and join it with what we already have here.
|
| + // There's no class A break point before the first child (only *between*
|
| + // siblings), so steal its break value and join it with what we already have
|
| + // here.
|
| setBreakBefore(
|
| joinFragmentainerBreakValues(breakBefore(), child.breakBefore()));
|
| return;
|
| }
|
|
|
| - // Figure out if a forced break should be inserted in front of the child. If we insert a forced
|
| - // break, the margins on this child may not collapse with those preceding the break.
|
| + // Figure out if a forced break should be inserted in front of the child. If
|
| + // we insert a forced break, the margins on this child may not collapse with
|
| + // those preceding the break.
|
| EBreak classABreakPointValue =
|
| child.classABreakPointValue(layoutInfo.previousBreakAfterValue());
|
| if (isForcedFragmentainerBreakValue(classABreakPointValue)) {
|
| @@ -783,25 +813,28 @@ void LayoutBlockFlow::layoutBlockChild(LayoutBox& child,
|
| LayoutUnit oldPosMarginBefore = maxPositiveMarginBefore();
|
| LayoutUnit oldNegMarginBefore = maxNegativeMarginBefore();
|
|
|
| - // The child is a normal flow object. Compute the margins we will use for collapsing now.
|
| + // The child is a normal flow object. Compute the margins we will use for
|
| + // collapsing now.
|
| child.computeAndSetBlockDirectionMargins(this);
|
|
|
| - // Try to guess our correct logical top position. In most cases this guess will
|
| - // be correct. Only if we're wrong (when we compute the real logical top position)
|
| - // will we have to potentially relayout.
|
| + // Try to guess our correct logical top position. In most cases this guess
|
| + // will be correct. Only if we're wrong (when we compute the real logical top
|
| + // position) will we have to potentially relayout.
|
| LayoutUnit estimateWithoutPagination;
|
| LayoutUnit logicalTopEstimate =
|
| estimateLogicalTopPosition(child, layoutInfo, estimateWithoutPagination);
|
|
|
| - // Cache our old rect so that we can dirty the proper paint invalidation rects if the child moves.
|
| + // Cache our old rect so that we can dirty the proper paint invalidation rects
|
| + // if the child moves.
|
| LayoutRect oldRect = child.frameRect();
|
|
|
| if (LayoutFlowThread* flowThread = flowThreadContainingBlock())
|
| layoutInfo.storeMultiColumnLayoutState(*flowThread);
|
|
|
| - // Use the estimated block position and lay out the child if needed. After child layout, when
|
| - // we have enough information to perform proper margin collapsing, float clearing and
|
| - // pagination, we may have to reposition and lay out again if the estimate was wrong.
|
| + // Use the estimated block position and lay out the child if needed. After
|
| + // child layout, when we have enough information to perform proper margin
|
| + // collapsing, float clearing and pagination, we may have to reposition and
|
| + // lay out again if the estimate was wrong.
|
| bool childNeededLayout =
|
| positionAndLayoutOnceIfNeeded(child, logicalTopEstimate, layoutInfo);
|
|
|
| @@ -812,13 +845,14 @@ void LayoutBlockFlow::layoutBlockChild(LayoutBox& child,
|
| bool childDiscardMarginAfter = mustDiscardMarginAfterForChild(child);
|
| bool paginated = view()->layoutState()->isPaginated();
|
|
|
| - // If there should be a forced break before the child, we need to insert it before attempting
|
| - // to collapse margins or apply clearance.
|
| + // If there should be a forced break before the child, we need to insert it
|
| + // before attempting to collapse margins or apply clearance.
|
| if (paginated) {
|
| - // We will now insert the strut needed by any forced break. After this operation, we will
|
| - // have calculated the offset where we can apply margin collapsing and clearance. After
|
| - // having applied those things, we'll be at the position where we can honor requirements of
|
| - // unbreakable content, which may extend the strut further.
|
| + // We will now insert the strut needed by any forced break. After this
|
| + // operation, we will have calculated the offset where we can apply margin
|
| + // collapsing and clearance. After having applied those things, we'll be at
|
| + // the position where we can honor requirements of unbreakable content,
|
| + // which may extend the strut further.
|
| child.resetPaginationStrut();
|
| insertForcedBreakBeforeChildIfNeeded(child, layoutInfo);
|
| }
|
| @@ -835,44 +869,50 @@ void LayoutBlockFlow::layoutBlockChild(LayoutBox& child,
|
| child, marginInfo, oldPosMarginBefore, oldNegMarginBefore,
|
| logicalTopBeforeClear, childIsSelfCollapsing, childDiscardMargin);
|
|
|
| - // If there's a forced break in front of this child, its final position has already been
|
| - // determined. Otherwise, see if there are other reasons for breaking before it
|
| - // (break-inside:avoid, or not enough space for the first piece of child content to fit in the
|
| - // current fragmentainer), and adjust the position accordingly.
|
| + // If there's a forced break in front of this child, its final position has
|
| + // already been determined. Otherwise, see if there are other reasons for
|
| + // breaking before it (break-inside:avoid, or not enough space for the first
|
| + // piece of child content to fit in the current fragmentainer), and adjust the
|
| + // position accordingly.
|
| if (paginated) {
|
| if (estimateWithoutPagination != newLogicalTop) {
|
| - // We got a new position due to clearance or margin collapsing. Before we attempt to
|
| - // paginate (which may result in the position changing again), let's try again at the
|
| - // new position (since a new position may result in a new logical height).
|
| + // We got a new position due to clearance or margin collapsing. Before we
|
| + // attempt to paginate (which may result in the position changing again),
|
| + // let's try again at the new position (since a new position may result in
|
| + // a new logical height).
|
| positionAndLayoutOnceIfNeeded(child, newLogicalTop, layoutInfo);
|
| }
|
|
|
| - // We have now applied forced breaks, margin collapsing and clearance, and we're at the
|
| - // position where we can honor requirements of unbreakable content.
|
| + // We have now applied forced breaks, margin collapsing and clearance, and
|
| + // we're at the position where we can honor requirements of unbreakable
|
| + // content.
|
| newLogicalTop = adjustBlockChildForPagination(
|
| newLogicalTop, child, layoutInfo,
|
| atBeforeSideOfBlock && logicalTopBeforeClear == newLogicalTop);
|
| }
|
|
|
| - // Clearance, margin collapsing or pagination may have given us a new logical top, in which
|
| - // case we may have to reposition and possibly relayout as well. If we determined during child
|
| - // layout that we need to insert a break to honor widows, we also need to relayout.
|
| + // Clearance, margin collapsing or pagination may have given us a new logical
|
| + // top, in which case we may have to reposition and possibly relayout as well.
|
| + // If we determined during child layout that we need to insert a break to
|
| + // honor widows, we also need to relayout.
|
| if (newLogicalTop != logicalTopEstimate || child.needsLayout() ||
|
| (paginated && childLayoutBlockFlow &&
|
| childLayoutBlockFlow->shouldBreakAtLineToAvoidWidow())) {
|
| positionAndLayoutOnceIfNeeded(child, newLogicalTop, layoutInfo);
|
| }
|
|
|
| - // If we previously encountered a self-collapsing sibling of this child that had clearance then
|
| - // we set this bit to ensure we would not collapse the child's margins, and those of any subsequent
|
| - // self-collapsing siblings, with our parent. If this child is not self-collapsing then it can
|
| - // collapse its margins with the parent so reset the bit.
|
| + // If we previously encountered a self-collapsing sibling of this child that
|
| + // had clearance then we set this bit to ensure we would not collapse the
|
| + // child's margins, and those of any subsequent self-collapsing siblings, with
|
| + // our parent. If this child is not self-collapsing then it can collapse its
|
| + // margins with the parent so reset the bit.
|
| if (!marginInfo.canCollapseMarginAfterWithLastChild() &&
|
| !childIsSelfCollapsing)
|
| marginInfo.setCanCollapseMarginAfterWithLastChild(true);
|
|
|
| // We are no longer at the top of the block if we encounter a non-empty child.
|
| - // This has to be done after checking for clear, so that margins can be reset if a clear occurred.
|
| + // This has to be done after checking for clear, so that margins can be reset
|
| + // if a clear occurred.
|
| if (marginInfo.atBeforeSideOfBlock() && !childIsSelfCollapsing)
|
| marginInfo.setAtBeforeSideOfBlock(false);
|
|
|
| @@ -881,35 +921,40 @@ void LayoutBlockFlow::layoutBlockChild(LayoutBox& child,
|
|
|
| LayoutSize childOffset = child.location() - oldRect.location();
|
|
|
| - // Update our height now that the child has been placed in the correct position.
|
| + // Update our height now that the child has been placed in the correct
|
| + // position.
|
| setLogicalHeight(logicalHeight() + logicalHeightForChild(child));
|
| if (mustSeparateMarginAfterForChild(child)) {
|
| setLogicalHeight(logicalHeight() + marginAfterForChild(child));
|
| marginInfo.clearMargin();
|
| }
|
| - // If the child has overhanging floats that intrude into following siblings (or possibly out
|
| - // of this block), then the parent gets notified of the floats now.
|
| + // If the child has overhanging floats that intrude into following siblings
|
| + // (or possibly out of this block), then the parent gets notified of the
|
| + // floats now.
|
| if (childLayoutBlockFlow)
|
| addOverhangingFloats(childLayoutBlockFlow, !childNeededLayout);
|
|
|
| - // If the child moved, we have to invalidate its paint as well as any floating/positioned
|
| - // descendants. An exception is if we need a layout. In this case, we know we're going to
|
| - // invalidate our paint (and the child) anyway.
|
| + // If the child moved, we have to invalidate its paint as well as any
|
| + // floating/positioned descendants. An exception is if we need a layout.
|
| + // In this case, we know we're going to invalidate our paint (and the child)
|
| + // anyway.
|
| if (!selfNeedsLayout() && (childOffset.width() || childOffset.height()) &&
|
| child.isLayoutBlockFlow())
|
| BlockFlowPaintInvalidator(toLayoutBlockFlow(child))
|
| .invalidatePaintForOverhangingFloats();
|
|
|
| if (paginated) {
|
| - // Keep track of the break-after value of the child, so that it can be joined with the
|
| - // break-before value of the next in-flow object at the next class A break point.
|
| + // Keep track of the break-after value of the child, so that it can be
|
| + // joined with the break-before value of the next in-flow object at the next
|
| + // class A break point.
|
| layoutInfo.setPreviousBreakAfterValue(child.breakAfter());
|
|
|
| paginatedContentWasLaidOut(child.logicalBottom());
|
| }
|
|
|
| if (child.isLayoutMultiColumnSpannerPlaceholder()) {
|
| - // The actual column-span:all element is positioned by this placeholder child.
|
| + // The actual column-span:all element is positioned by this placeholder
|
| + // child.
|
| positionSpannerDescendant(toLayoutMultiColumnSpannerPlaceholder(child));
|
| }
|
| }
|
| @@ -922,49 +967,55 @@ LayoutUnit LayoutBlockFlow::adjustBlockChildForPagination(
|
| LayoutBlockFlow* childBlockFlow =
|
| child.isLayoutBlockFlow() ? toLayoutBlockFlow(&child) : 0;
|
|
|
| - // See if we need a soft (unforced) break in front of this child, and set the pagination strut
|
| - // in that case. An unforced break may come from two sources:
|
| - // 1. The first piece of content inside the child doesn't fit in the current page or column
|
| - // 2. The child itself has breaking restrictions (break-inside:avoid, replaced content, etc.)
|
| - // and doesn't fully fit in the current page or column.
|
| + // See if we need a soft (unforced) break in front of this child, and set the
|
| + // pagination strut in that case. An unforced break may come from two sources:
|
| + // 1. The first piece of content inside the child doesn't fit in the current
|
| + // page or column
|
| + // 2. The child itself has breaking restrictions (break-inside:avoid, replaced
|
| + // content, etc.) and doesn't fully fit in the current page or column.
|
| //
|
| - // No matter which source, if we need to insert a strut, it should always take us to the exact
|
| - // top of a page or column further ahead, or be zero.
|
| + // No matter which source, if we need to insert a strut, it should always take
|
| + // us to the exact top of a page or column further ahead, or be zero.
|
|
|
| - // The first piece of content inside the child may have set a strut during layout. Currently,
|
| - // only block flows support strut propagation, but this may (and should) change in the future.
|
| - // See crbug.com/539873
|
| + // The first piece of content inside the child may have set a strut during
|
| + // layout. Currently, only block flows support strut propagation, but this may
|
| + // (and should) change in the future. See crbug.com/539873
|
| LayoutUnit strutFromContent =
|
| childBlockFlow ? childBlockFlow->paginationStrutPropagatedFromChild()
|
| : LayoutUnit();
|
| LayoutUnit logicalTopWithContentStrut = logicalTop + strutFromContent;
|
|
|
| - // For replaced elements and scrolled elements, we want to shift them to the next page if they don't fit on the current one.
|
| + // For replaced elements and scrolled elements, we want to shift them to the
|
| + // next page if they don't fit on the current one.
|
| LayoutUnit logicalTopAfterUnsplittable =
|
| adjustForUnsplittableChild(child, logicalTop);
|
|
|
| - // Pick the largest offset. Tall unsplittable content may take us to a page or column further
|
| - // ahead than the next one.
|
| + // Pick the largest offset. Tall unsplittable content may take us to a page or
|
| + // column further ahead than the next one.
|
| LayoutUnit logicalTopAfterPagination =
|
| std::max(logicalTopWithContentStrut, logicalTopAfterUnsplittable);
|
| LayoutUnit newLogicalTop = logicalTop;
|
|
|
| - // Forced breaks may already have caused a strut, and this needs to be added together with
|
| - // any strut detected here in this method.
|
| + // Forced breaks may already have caused a strut, and this needs to be added
|
| + // together with any strut detected here in this method.
|
| LayoutUnit previousStrut = child.paginationStrut();
|
|
|
| if (LayoutUnit paginationStrut =
|
| logicalTopAfterPagination - logicalTop + previousStrut) {
|
| ASSERT(paginationStrut > 0);
|
| - // If we're not at the first in-flow child, there's a class A break point before the child. If we *are* at the
|
| - // first in-flow child, but the child isn't flush with the content edge of its container, due to e.g. clearance,
|
| - // there's a class C break point before the child. Otherwise we should propagate the strut to our parent block,
|
| - // and attempt to break there instead. See https://drafts.csswg.org/css-break/#possible-breaks
|
| + // If we're not at the first in-flow child, there's a class A break point
|
| + // before the child. If we *are* at the first in-flow child, but the child
|
| + // isn't flush with the content edge of its container, due to e.g.
|
| + // clearance, there's a class C break point before the child. Otherwise we
|
| + // should propagate the strut to our parent block, and attempt to break
|
| + // there instead. See https://drafts.csswg.org/css-break/#possible-breaks
|
| if (layoutInfo.isAtFirstInFlowChild() && atBeforeSideOfBlock &&
|
| allowsPaginationStrut()) {
|
| - // FIXME: Should really check if we're exceeding the page height before propagating the strut, but we don't
|
| - // have all the information to do so (the strut only has the remaining amount to push). Gecko gets this wrong too
|
| - // and pushes to the next page anyway, so not too concerned about it.
|
| + // FIXME: Should really check if we're exceeding the page height before
|
| + // propagating the strut, but we don't have all the information to do so
|
| + // (the strut only has the remaining amount to push). Gecko gets this
|
| + // wrong too and pushes to the next page anyway, so not too concerned
|
| + // about it.
|
| paginationStrut += logicalTop + marginBeforeIfFloating();
|
| setPaginationStrutPropagatedFromChild(paginationStrut);
|
| child.resetPaginationStrut();
|
| @@ -972,12 +1023,14 @@ LayoutUnit LayoutBlockFlow::adjustBlockChildForPagination(
|
| childBlockFlow->setPaginationStrutPropagatedFromChild(LayoutUnit());
|
| } else {
|
| child.setPaginationStrut(paginationStrut);
|
| - // |previousStrut| was already baked into the logical top, so don't add it again.
|
| + // |previousStrut| was already baked into the logical top, so don't add it
|
| + // again.
|
| newLogicalTop += paginationStrut - previousStrut;
|
| }
|
| }
|
|
|
| - // Similar to how we apply clearance. Go ahead and boost height() to be the place where we're going to position the child.
|
| + // Similar to how we apply clearance. Go ahead and boost height() to be the
|
| + // place where we're going to position the child.
|
| setLogicalHeight(logicalHeight() + (newLogicalTop - logicalTop));
|
|
|
| // Return the final adjusted logical top.
|
| @@ -990,13 +1043,14 @@ static bool shouldSetStrutOnBlock(const LayoutBlockFlow& block,
|
| int lineIndex,
|
| LayoutUnit pageLogicalHeight) {
|
| if (lineBox == block.firstRootBox()) {
|
| - // This is the first line in the block. We can take the whole block with us to the next page
|
| - // or column, rather than keeping a content-less portion of it in the previous one. Only do
|
| - // this if the line is flush with the content edge of the block, though. If it isn't, it
|
| - // means that the line was pushed downwards by preceding floats that didn't fit beside the
|
| - // line, and we don't want to move all that, since it has already been established that it
|
| - // fits nicely where it is. In this case we have a class "C" break point [1] in front of
|
| - // this line.
|
| + // This is the first line in the block. We can take the whole block with us
|
| + // to the next page or column, rather than keeping a content-less portion of
|
| + // it in the previous one. Only do this if the line is flush with the
|
| + // content edge of the block, though. If it isn't, it means that the line
|
| + // was pushed downwards by preceding floats that didn't fit beside the line,
|
| + // and we don't want to move all that, since it has already been established
|
| + // that it fits nicely where it is. In this case we have a class "C" break
|
| + // point [1] in front of this line.
|
| //
|
| // [1] https://drafts.csswg.org/css-break/#possible-breaks
|
| if (lineLogicalOffset > block.borderAndPaddingBefore())
|
| @@ -1006,7 +1060,8 @@ static bool shouldSetStrutOnBlock(const LayoutBlockFlow& block,
|
| lineBox.lineBottomWithLeading() - lineBox.lineTopWithLeading();
|
| LayoutUnit totalLogicalHeight =
|
| lineHeight + lineLogicalOffset.clampNegativeToZero();
|
| - // It's rather pointless to break before the block if the current line isn't going to
|
| + // It's rather pointless to break before the block if the current line isn't
|
| + // going to
|
| // fit in the same column or page, so check that as well.
|
| if (totalLogicalHeight > pageLogicalHeight)
|
| return false;
|
| @@ -1014,27 +1069,31 @@ static bool shouldSetStrutOnBlock(const LayoutBlockFlow& block,
|
| if (lineIndex > block.style()->orphans())
|
| return false;
|
|
|
| - // Not enough orphans here. Push the entire block to the next column / page as an attempt to
|
| - // better satisfy the orphans requirement.
|
| + // Not enough orphans here. Push the entire block to the next column / page
|
| + // as an attempt to better satisfy the orphans requirement.
|
| //
|
| - // Note that we should ideally check if the first line in the block is flush with the
|
| - // content edge of the block here, because if it isn't, we should break at the class "C"
|
| - // break point in front of the first line, rather than before the entire block.
|
| + // Note that we should ideally check if the first line in the block is flush
|
| + // with the content edge of the block here, because if it isn't, we should
|
| + // break at the class "C" break point in front of the first line, rather
|
| + // than before the entire block.
|
| }
|
| return block.allowsPaginationStrut();
|
| }
|
|
|
| void LayoutBlockFlow::adjustLinePositionForPagination(RootInlineBox& lineBox,
|
| LayoutUnit& delta) {
|
| - // TODO(mstensho): Pay attention to line overflow. It should be painted in the same column as
|
| - // the rest of the line, possibly overflowing the column. We currently only allow overflow above
|
| - // the first column. We clip at all other column boundaries, and that's how it has to be for
|
| - // now. The paint we have to do when a column has overflow has to be special. We need to exclude
|
| - // content that paints in a previous column (and content that paints in the following column).
|
| + // TODO(mstensho): Pay attention to line overflow. It should be painted in the
|
| + // same column as the rest of the line, possibly overflowing the column. We
|
| + // currently only allow overflow above the first column. We clip at all other
|
| + // column boundaries, and that's how it has to be for now. The paint we have
|
| + // to do when a column has overflow has to be special.
|
| + // We need to exclude content that paints in a previous column (and content
|
| + // that paints in the following column).
|
| //
|
| - // FIXME: Another problem with simply moving lines is that the available line width may change (because of floats).
|
| - // Technically if the location we move the line to has a different line width than our old position, then we need to dirty the
|
| - // line and all following lines.
|
| + // FIXME: Another problem with simply moving lines is that the available line
|
| + // width may change (because of floats). Technically if the location we move
|
| + // the line to has a different line width than our old position, then we need
|
| + // to dirty the line and all following lines.
|
| LayoutUnit logicalOffset = lineBox.lineTopWithLeading();
|
| LayoutUnit lineHeight = lineBox.lineBottomWithLeading() - logicalOffset;
|
| logicalOffset += delta;
|
| @@ -1052,20 +1111,23 @@ void LayoutBlockFlow::adjustLinePositionForPagination(RootInlineBox& lineBox,
|
| LayoutUnit paginationStrut = calculatePaginationStrutToFitContent(
|
| logicalOffset, remainingLogicalHeight, lineHeight);
|
| LayoutUnit newLogicalOffset = logicalOffset + paginationStrut;
|
| - // Moving to a different page or column may mean that its height is different.
|
| + // Moving to a different page or column may mean that its height is
|
| + // different.
|
| pageLogicalHeight = pageLogicalHeightForOffset(newLogicalOffset);
|
| if (lineHeight > pageLogicalHeight) {
|
| - // Too tall to fit in one page / column. Give up. Don't push to the next page / column.
|
| - // TODO(mstensho): Get rid of this. This is just utter weirdness, but the other browsers
|
| - // also do something slightly similar, although in much more specific cases than we do here,
|
| - // and printing Google Docs depends on it.
|
| + // Too tall to fit in one page / column. Give up. Don't push to the next
|
| + // page / column.
|
| + // TODO(mstensho): Get rid of this. This is just utter weirdness, but the
|
| + // other browsers also do something slightly similar, although in much
|
| + // more specific cases than we do here, and printing Google Docs depends
|
| + // on it.
|
| paginatedContentWasLaidOut(logicalOffset + lineHeight);
|
| return;
|
| }
|
|
|
| - // We need to insert a break now, either because there's no room for the line in the
|
| - // current column / page, or because we have determined that we need a break to satisfy
|
| - // widow requirements.
|
| + // We need to insert a break now, either because there's no room for the
|
| + // line in the current column / page, or because we have determined that we
|
| + // need a break to satisfy widow requirements.
|
| if (shouldBreakAtLineToAvoidWidow() &&
|
| lineBreakToAvoidWidow() == lineIndex) {
|
| clearShouldBreakAtLineToAvoidWidow();
|
| @@ -1073,11 +1135,12 @@ void LayoutBlockFlow::adjustLinePositionForPagination(RootInlineBox& lineBox,
|
| }
|
| if (shouldSetStrutOnBlock(*this, lineBox, logicalOffset, lineIndex,
|
| pageLogicalHeight)) {
|
| - // Note that when setting the strut on a block, it may be propagated to parent blocks
|
| - // later on, if a block's logical top is flush with that of its parent. We don't want
|
| - // content-less portions (struts) at the beginning of a block before a break, if it can
|
| - // be avoided. After all, that's the reason for setting struts on blocks and not lines
|
| - // in the first place.
|
| + // Note that when setting the strut on a block, it may be propagated to
|
| + // parent blocks later on, if a block's logical top is flush with that of
|
| + // its parent. We don't want content-less portions (struts) at the
|
| + // beginning of a block before a break, if it can be avoided. After all,
|
| + // that's the reason for setting struts on blocks and not lines in the
|
| + // first place.
|
| LayoutUnit strut =
|
| paginationStrut + logicalOffset + marginBeforeIfFloating();
|
| setPaginationStrutPropagatedFromChild(strut);
|
| @@ -1095,34 +1158,37 @@ void LayoutBlockFlow::adjustLinePositionForPagination(RootInlineBox& lineBox,
|
| // We're at the very top of a page or column.
|
| if (lineBox != firstRootBox())
|
| lineBox.setIsFirstAfterPageBreak(true);
|
| - // If this is the first line in the block, and the block has a top border, padding, or (in
|
| - // case it's a float) margin, we may want to set a strut on the block, so that everything
|
| - // ends up in the next column or page. Setting a strut on the block is also important when
|
| - // it comes to satisfying orphan requirements.
|
| + // If this is the first line in the block, and the block has a top border,
|
| + // padding, or (in case it's a float) margin, we may want to set a strut on
|
| + // the block, so that everything ends up in the next column or page. Setting
|
| + // a strut on the block is also important when it comes to satisfying orphan
|
| + // requirements.
|
| if (shouldSetStrutOnBlock(*this, lineBox, logicalOffset, lineIndex,
|
| pageLogicalHeight))
|
| strutToPropagate = logicalOffset + marginBeforeIfFloating();
|
| } else if (lineBox == firstRootBox() && allowsPaginationStrut()) {
|
| - // This is the first line in the block. The block may still start in the previous column or
|
| - // page, and if that's the case, attempt to pull it over to where this line is, so that we
|
| - // don't split the top border, padding, or (in case it's a float) margin.
|
| + // This is the first line in the block. The block may still start in the
|
| + // previous column or page, and if that's the case, attempt to pull it over
|
| + // to where this line is, so that we don't split the top border, padding, or
|
| + // (in case it's a float) margin.
|
| LayoutUnit totalLogicalOffset = logicalOffset + marginBeforeIfFloating();
|
| LayoutUnit strut =
|
| remainingLogicalHeight + totalLogicalOffset - pageLogicalHeight;
|
| if (strut > 0) {
|
| - // The block starts in a previous column or page. Set a strut on the block if there's
|
| - // room for the top border, padding and (if it's a float) margin and the line in one
|
| - // column or page.
|
| + // The block starts in a previous column or page. Set a strut on the block
|
| + // if there's room for the top border, padding and (if it's a float)
|
| + // margin and the line in one column or page.
|
| if (totalLogicalOffset + lineHeight <= pageLogicalHeight)
|
| strutToPropagate = strut;
|
| }
|
| }
|
|
|
| - // If we found that some preceding content (lines, border and padding) belongs together with
|
| - // this line, we should pull the entire block with us to the fragmentainer we're currently
|
| - // in. We need to avoid this when the block precedes the first fragmentainer, though. We
|
| - // shouldn't fragment content there, but rather let it appear in the overflow area before the
|
| - // first fragmentainer.
|
| + // If we found that some preceding content (lines, border and padding) belongs
|
| + // together with this line, we should pull the entire block with us to the
|
| + // fragmentainer we're currently in. We need to avoid this when the block
|
| + // precedes the first fragmentainer, though. We shouldn't fragment content
|
| + // there, but rather let it appear in the overflow area before the first
|
| + // fragmentainer.
|
| if (strutToPropagate && offsetFromLogicalTopOfFirstPage() > LayoutUnit())
|
| setPaginationStrutPropagatedFromChild(strutToPropagate);
|
|
|
| @@ -1150,8 +1216,8 @@ LayoutUnit LayoutBlockFlow::adjustForUnsplittableChild(
|
| logicalOffset, remainingLogicalHeight, childLogicalHeight);
|
| if (paginationStrut == remainingLogicalHeight &&
|
| remainingLogicalHeight == pageLogicalHeight) {
|
| - // Don't break if we were at the top of a page, and we failed to fit the content
|
| - // completely. No point in leaving a page completely blank.
|
| + // Don't break if we were at the top of a page, and we failed to fit the
|
| + // content completely. No point in leaving a page completely blank.
|
| return logicalOffset;
|
| }
|
| return logicalOffset + paginationStrut;
|
| @@ -1174,7 +1240,8 @@ void LayoutBlockFlow::rebuildFloatsFromIntruding() {
|
| }
|
| }
|
|
|
| - // Inline blocks are covered by the isAtomicInlineLevel() check in the avoidFloats method.
|
| + // Inline blocks are covered by the isAtomicInlineLevel() check in the
|
| + // avoidFloats method.
|
| if (avoidsFloats() || isDocumentElement() || isLayoutView() ||
|
| isFloatingOrOutOfFlowPositioned() || isTableCell()) {
|
| if (m_floatingObjects) {
|
| @@ -1194,15 +1261,18 @@ void LayoutBlockFlow::rebuildFloatsFromIntruding() {
|
| m_floatingObjects->clear();
|
| }
|
|
|
| - // We should not process floats if the parent node is not a LayoutBlockFlow. Otherwise, we will add
|
| - // floats in an invalid context. This will cause a crash arising from a bad cast on the parent.
|
| - // See <rdar://problem/8049753>, where float property is applied on a text node in a SVG.
|
| + // We should not process floats if the parent node is not a LayoutBlockFlow.
|
| + // Otherwise, we will add floats in an invalid context. This will cause a
|
| + // crash arising from a bad cast on the parent.
|
| + // See <rdar://problem/8049753>, where float property is applied on a text
|
| + // node in a SVG.
|
| if (!parent() || !parent()->isLayoutBlockFlow())
|
| return;
|
|
|
| - // Attempt to locate a previous sibling with overhanging floats. We skip any elements that
|
| - // may have shifted to avoid floats, and any objects whose floats cannot interact with objects
|
| - // outside it (i.e. objects that create a new block formatting context).
|
| + // Attempt to locate a previous sibling with overhanging floats. We skip any
|
| + // elements that may have shifted to avoid floats, and any objects whose
|
| + // floats cannot interact with objects outside it (i.e. objects that create a
|
| + // new block formatting context).
|
| LayoutBlockFlow* parentBlockFlow = toLayoutBlockFlow(parent());
|
| bool siblingFloatMayIntrude = false;
|
| LayoutObject* prev = previousSibling();
|
| @@ -1214,9 +1284,11 @@ void LayoutBlockFlow::rebuildFloatsFromIntruding() {
|
| prev = prev->previousSibling();
|
| }
|
|
|
| - // First add in floats from the parent. Self-collapsing blocks let their parent track any floats that intrude into
|
| - // them (as opposed to floats they contain themselves) so check for those here too. If margin collapsing has moved
|
| - // us up past the top a previous sibling then we need to check for floats from the parent too.
|
| + // First add in floats from the parent. Self-collapsing blocks let their
|
| + // parent track any floats that intrude into them (as opposed to floats they
|
| + // contain themselves) so check for those here too. If margin collapsing has
|
| + // moved us up past the top a previous sibling then we need to check for
|
| + // floats from the parent too.
|
| bool parentFloatsMayIntrude =
|
| !siblingFloatMayIntrude &&
|
| (!prev || toLayoutBlockFlow(prev)->isSelfCollapsingBlock() ||
|
| @@ -1227,7 +1299,8 @@ void LayoutBlockFlow::rebuildFloatsFromIntruding() {
|
| parentBlockFlow->logicalLeftOffsetForContent(),
|
| logicalTop());
|
|
|
| - // Add overhanging floats from the previous LayoutBlockFlow, but only if it has a float that intrudes into our space.
|
| + // Add overhanging floats from the previous LayoutBlockFlow, but only if it
|
| + // has a float that intrudes into our space.
|
| if (prev) {
|
| LayoutBlockFlow* previousBlockFlow = toLayoutBlockFlow(prev);
|
| if (logicalTop() < previousBlockFlow->logicalTop() +
|
| @@ -1304,8 +1377,9 @@ void LayoutBlockFlow::rebuildFloatsFromIntruding() {
|
|
|
| markLinesDirtyInBlockRange(changeLogicalTop, changeLogicalBottom);
|
| } else if (!oldIntrudingFloatSet.isEmpty()) {
|
| - // If there are previously intruding floats that no longer intrude, then children with floats
|
| - // should also get layout because they might need their floating object lists cleared.
|
| + // If there are previously intruding floats that no longer intrude, then
|
| + // children with floats should also get layout because they might need their
|
| + // floating object lists cleared.
|
| if (m_floatingObjects->set().size() < oldIntrudingFloatSet.size()) {
|
| markAllDescendantsWithFloatsForLayout();
|
| } else {
|
| @@ -1349,7 +1423,8 @@ void LayoutBlockFlow::layoutBlockChildren(bool relayoutChildren,
|
| child->setMayNeedPaintInvalidation();
|
|
|
| if (childToExclude == child)
|
| - continue; // Skip this child, since it will be positioned by the specialized subclass (ruby runs).
|
| + continue; // Skip this child, since it will be positioned by the
|
| + // specialized subclass (ruby runs).
|
|
|
| updateBlockChildDirtyBitsBeforeLayout(relayoutChildren, *child);
|
|
|
| @@ -1364,11 +1439,12 @@ void LayoutBlockFlow::layoutBlockChildren(bool relayoutChildren,
|
| continue;
|
| }
|
| if (child->isColumnSpanAll()) {
|
| - // This is not the containing block of the spanner. The spanner's placeholder will lay
|
| - // it out in due course. For now we just need to consult our flow thread, so that the
|
| - // columns (if any) preceding and following the spanner are laid out correctly. But
|
| - // first we apply the pending margin, so that it's taken into consideration and doesn't
|
| - // end up on the other side of the spanner.
|
| + // This is not the containing block of the spanner. The spanner's
|
| + // placeholder will lay it out in due course. For now we just need to
|
| + // consult our flow thread, so that the columns (if any) preceding and
|
| + // following the spanner are laid out correctly. But first we apply the
|
| + // pending margin, so that it's taken into consideration and doesn't end
|
| + // up on the other side of the spanner.
|
| setLogicalHeight(logicalHeight() + marginInfo.margin());
|
| marginInfo.clearMargin();
|
|
|
| @@ -1383,8 +1459,9 @@ void LayoutBlockFlow::layoutBlockChildren(bool relayoutChildren,
|
| lastNormalFlowChild = child;
|
| }
|
|
|
| - // Now do the handling of the bottom of the block, adding in our bottom border/padding and
|
| - // determining the correct collapsed bottom margin information.
|
| + // Now do the handling of the bottom of the block, adding in our bottom
|
| + // border/padding and determining the correct collapsed bottom margin
|
| + // information.
|
| handleAfterSideOfBlock(lastNormalFlowChild, beforeEdge, afterEdge,
|
| marginInfo);
|
| }
|
| @@ -1411,10 +1488,11 @@ MarginInfo::MarginInfo(LayoutBlockFlow* blockFlow,
|
| m_canCollapseWithChildren && !beforeBorderPadding &&
|
| blockStyle.marginBeforeCollapse() != MarginCollapseSeparate;
|
|
|
| - // If any height other than auto is specified in CSS, then we don't collapse our bottom
|
| - // margins with our children's margins. To do otherwise would be to risk odd visual
|
| - // effects when the children overflow out of the parent block and yet still collapse
|
| - // with it. We also don't collapse if we have any bottom border/padding.
|
| + // If any height other than auto is specified in CSS, then we don't collapse
|
| + // our bottom margins with our children's margins. To do otherwise would be to
|
| + // risk odd visual effects when the children overflow out of the parent block
|
| + // and yet still collapse with it. We also don't collapse if we have any
|
| + // bottom border/padding.
|
| m_canCollapseMarginAfterWithChildren =
|
| m_canCollapseWithChildren && !afterBorderPadding &&
|
| (blockStyle.logicalHeight().isAuto() &&
|
| @@ -1449,8 +1527,8 @@ LayoutBlockFlow::MarginValues LayoutBlockFlow::marginValuesForChild(
|
| LayoutBlockFlow* childLayoutBlockFlow =
|
| child.isLayoutBlockFlow() ? toLayoutBlockFlow(&child) : 0;
|
|
|
| - // If the child has the same directionality as we do, then we can just return its
|
| - // margins in the same direction.
|
| + // If the child has the same directionality as we do, then we can just return
|
| + // its margins in the same direction.
|
| if (!child.isWritingModeRoot()) {
|
| if (childLayoutBlockFlow) {
|
| childBeforePositive = childLayoutBlockFlow->maxPositiveMarginBefore();
|
| @@ -1462,8 +1540,9 @@ LayoutBlockFlow::MarginValues LayoutBlockFlow::marginValuesForChild(
|
| afterMargin = child.marginAfter();
|
| }
|
| } else if (child.isHorizontalWritingMode() == isHorizontalWritingMode()) {
|
| - // The child has a different directionality. If the child is parallel, then it's just
|
| - // flipped relative to us. We can use the margins for the opposite edges.
|
| + // The child has a different directionality. If the child is parallel, then
|
| + // it's just flipped relative to us. We can use the margins for the opposite
|
| + // edges.
|
| if (childLayoutBlockFlow) {
|
| childBeforePositive = childLayoutBlockFlow->maxPositiveMarginAfter();
|
| childBeforeNegative = childLayoutBlockFlow->maxNegativeMarginAfter();
|
| @@ -1474,8 +1553,9 @@ LayoutBlockFlow::MarginValues LayoutBlockFlow::marginValuesForChild(
|
| afterMargin = child.marginBefore();
|
| }
|
| } else {
|
| - // The child is perpendicular to us, which means its margins don't collapse but are on the
|
| - // "logical left/right" sides of the child box. We can just return the raw margin in this case.
|
| + // The child is perpendicular to us, which means its margins don't collapse
|
| + // but are on the "logical left/right" sides of the child box. We can just
|
| + // return the raw margin in this case.
|
| beforeMargin = marginBeforeForChild(child);
|
| afterMargin = marginAfterForChild(child);
|
| }
|
| @@ -1503,7 +1583,8 @@ LayoutUnit LayoutBlockFlow::collapseMargins(LayoutBox& child,
|
| bool childIsSelfCollapsing,
|
| bool childDiscardMarginBefore,
|
| bool childDiscardMarginAfter) {
|
| - // The child discards the before margin when the the after margin has discard in the case of a self collapsing block.
|
| + // The child discards the before margin when the the after margin has discard
|
| + // in the case of a self collapsing block.
|
| childDiscardMarginBefore = childDiscardMarginBefore ||
|
| (childDiscardMarginAfter && childIsSelfCollapsing);
|
|
|
| @@ -1556,12 +1637,14 @@ LayoutUnit LayoutBlockFlow::collapseMargins(LayoutBox& child,
|
| setHasMarginBeforeQuirk(true);
|
| }
|
| } else {
|
| - // The before margin of the container will also discard all the margins it is collapsing with.
|
| + // The before margin of the container will also discard all the margins it
|
| + // is collapsing with.
|
| setMustDiscardMarginBefore();
|
| }
|
| }
|
|
|
| - // Once we find a child with discardMarginBefore all the margins collapsing with us must also discard.
|
| + // Once we find a child with discardMarginBefore all the margins collapsing
|
| + // with us must also discard.
|
| if (childDiscardMarginBefore) {
|
| marginInfo.setDiscardMargin(true);
|
| marginInfo.clearMargin();
|
| @@ -1580,9 +1663,13 @@ LayoutUnit LayoutBlockFlow::collapseMargins(LayoutBox& child,
|
| !prev->isFloatingOrOutOfFlowPositioned()
|
| ? toLayoutBlockFlow(prev)
|
| : 0;
|
| - // If the child's previous sibling is a self-collapsing block that cleared a float then its top border edge has been set at the bottom border edge
|
| - // of the float. Since we want to collapse the child's top margin with the self-collapsing block's top and bottom margins we need to adjust our parent's height to match the
|
| - // margin top of the self-collapsing block. If the resulting collapsed margin leaves the child still intruding into the float then we will want to clear it.
|
| + // If the child's previous sibling is a self-collapsing block that cleared a
|
| + // float then its top border edge has been set at the bottom border edge of
|
| + // the float. Since we want to collapse the child's top margin with the self-
|
| + // collapsing block's top and bottom margins we need to adjust our parent's
|
| + // height to match the margin top of the self-collapsing block. If the
|
| + // resulting collapsed margin leaves the child still intruding into the float
|
| + // then we will want to clear it.
|
| if (!marginInfo.canCollapseWithMarginBefore() && previousBlockFlow &&
|
| marginInfo.lastChildIsSelfCollapsingBlockWithClearance())
|
| setLogicalHeight(
|
| @@ -1590,8 +1677,10 @@ LayoutUnit LayoutBlockFlow::collapseMargins(LayoutBox& child,
|
| marginValuesForChild(*previousBlockFlow).positiveMarginBefore());
|
|
|
| if (childIsSelfCollapsing) {
|
| - // For a self collapsing block both the before and after margins get discarded. The block doesn't contribute anything to the height of the block.
|
| - // Also, the child's top position equals the logical height of the container.
|
| + // For a self collapsing block both the before and after margins get
|
| + // discarded. The block doesn't contribute anything to the height of the
|
| + // block. Also, the child's top position equals the logical height of the
|
| + // container.
|
| if (!childDiscardMarginBefore && !marginInfo.discardMargin()) {
|
| // This child has no height. We need to compute our
|
| // position before we collapse the child's margins together,
|
| @@ -1619,9 +1708,9 @@ LayoutUnit LayoutBlockFlow::collapseMargins(LayoutBox& child,
|
| if (mustSeparateMarginBeforeForChild(child)) {
|
| ASSERT(!marginInfo.discardMargin() ||
|
| (marginInfo.discardMargin() && !marginInfo.margin()));
|
| - // If we are at the before side of the block and we collapse, ignore the computed margin
|
| - // and just add the child margin to the container height. This will correctly position
|
| - // the child inside the container.
|
| + // If we are at the before side of the block and we collapse, ignore the
|
| + // computed margin and just add the child margin to the container height.
|
| + // This will correctly position the child inside the container.
|
| LayoutUnit separateMargin = !marginInfo.canCollapseWithMarginBefore()
|
| ? marginInfo.margin()
|
| : LayoutUnit();
|
| @@ -1654,8 +1743,8 @@ LayoutUnit LayoutBlockFlow::collapseMargins(LayoutBox& child,
|
| marginInfo.setHasMarginAfterQuirk(hasMarginAfterQuirk(&child));
|
| }
|
|
|
| - // If margins would pull us past the top of the next page, then we need to pull back and pretend like the margins
|
| - // collapsed into the page edge.
|
| + // If margins would pull us past the top of the next page, then we need to
|
| + // pull back and pretend like the margins collapsed into the page edge.
|
| LayoutState* layoutState = view()->layoutState();
|
| if (layoutState->isPaginated() &&
|
| isPageLogicalHeightKnown(beforeCollapseLogicalTop) &&
|
| @@ -1667,8 +1756,9 @@ LayoutUnit LayoutBlockFlow::collapseMargins(LayoutBox& child,
|
| }
|
|
|
| if (previousBlockFlow) {
|
| - // If |child| is a self-collapsing block it may have collapsed into a previous sibling and although it hasn't reduced the height of the parent yet
|
| - // any floats from the parent will now overhang.
|
| + // If |child| is a self-collapsing block it may have collapsed into a
|
| + // previous sibling and although it hasn't reduced the height of the parent
|
| + // yet any floats from the parent will now overhang.
|
| LayoutUnit oldLogicalHeight = logicalHeight();
|
| setLogicalHeight(logicalTop);
|
| if (!previousBlockFlow->avoidsFloats() &&
|
| @@ -1677,9 +1767,11 @@ LayoutUnit LayoutBlockFlow::collapseMargins(LayoutBox& child,
|
| addOverhangingFloats(previousBlockFlow, false);
|
| setLogicalHeight(oldLogicalHeight);
|
|
|
| - // If |child|'s previous sibling is or contains a self-collapsing block that cleared a float and margin collapsing resulted in |child| moving up
|
| - // into the margin area of the self-collapsing block then the float it clears is now intruding into |child|. Layout again so that we can look for
|
| - // floats in the parent that overhang |child|'s new logical top.
|
| + // If |child|'s previous sibling is or contains a self-collapsing block that
|
| + // cleared a float and margin collapsing resulted in |child| moving up
|
| + // into the margin area of the self-collapsing block then the float it
|
| + // clears is now intruding into |child|. Layout again so that we can look
|
| + // for floats in the parent that overhang |child|'s new logical top.
|
| bool logicalTopIntrudesIntoFloat = logicalTop < beforeCollapseLogicalTop;
|
| if (logicalTopIntrudesIntoFloat && containsFloats() &&
|
| !child.avoidsFloats() && lowestFloatLogicalBottom() > logicalTop)
|
| @@ -1695,8 +1787,9 @@ void LayoutBlockFlow::adjustPositionedBlock(
|
| const BlockChildrenLayoutInfo& layoutInfo) {
|
| LayoutUnit logicalTop = logicalHeight();
|
|
|
| - // Forced breaks are only specified on in-flow objects, but auto-positioned out-of-flow objects
|
| - // may be affected by a break-after value of the previous in-flow object.
|
| + // Forced breaks are only specified on in-flow objects, but auto-positioned
|
| + // out-of-flow objects may be affected by a break-after value of the previous
|
| + // in-flow object.
|
| if (view()->layoutState()->isPaginated())
|
| logicalTop =
|
| applyForcedBreak(logicalTop, layoutInfo.previousBreakAfterValue());
|
| @@ -1706,7 +1799,8 @@ void LayoutBlockFlow::adjustPositionedBlock(
|
| const MarginInfo& marginInfo = layoutInfo.marginInfo();
|
| if (!marginInfo.canCollapseWithMarginBefore()) {
|
| // Positioned blocks don't collapse margins, so add the margin provided by
|
| - // the container now. The child's own margin is added later when calculating its logical top.
|
| + // the container now. The child's own margin is added later when calculating
|
| + // its logical top.
|
| LayoutUnit collapsedBeforePos = marginInfo.positiveMargin();
|
| LayoutUnit collapsedBeforeNeg = marginInfo.negativeMargin();
|
| logicalTop += collapsedBeforePos - collapsedBeforeNeg;
|
| @@ -1737,7 +1831,8 @@ LayoutUnit LayoutBlockFlow::clearFloatsIfNeeded(LayoutBox& child,
|
| // For self-collapsing blocks that clear, they can still collapse their
|
| // margins with following siblings. Reset the current margins to represent
|
| // the self-collapsing block's margins only.
|
| - // If DISCARD is specified for -webkit-margin-collapse, reset the margin values.
|
| + // If DISCARD is specified for -webkit-margin-collapse, reset the margin
|
| + // values.
|
| LayoutBlockFlow::MarginValues childMargins = marginValuesForChild(child);
|
| if (!childDiscardMargin) {
|
| marginInfo.setPositiveMargin(
|
| @@ -1751,18 +1846,28 @@ LayoutUnit LayoutBlockFlow::clearFloatsIfNeeded(LayoutBox& child,
|
| }
|
|
|
| // CSS2.1 states:
|
| - // "If the top and bottom margins of an element with clearance are adjoining, its margins collapse with
|
| - // the adjoining margins of following siblings but that resulting margin does not collapse with the bottom margin of the parent block."
|
| - // So the parent's bottom margin cannot collapse through this block or any subsequent self-collapsing blocks. Set a bit to ensure
|
| - // this happens; it will get reset if we encounter an in-flow sibling that is not self-collapsing.
|
| + // "If the top and bottom margins of an element with clearance are
|
| + // adjoining, its margins collapse with the adjoining margins of following
|
| + // siblings but that resulting margin does not collapse with the bottom
|
| + // margin of the parent block."
|
| + // So the parent's bottom margin cannot collapse through this block or any
|
| + // subsequent self-collapsing blocks. Set a bit to ensure this happens; it
|
| + // will get reset if we encounter an in-flow sibling that is not
|
| + // self-collapsing.
|
| marginInfo.setCanCollapseMarginAfterWithLastChild(false);
|
|
|
| - // For now set the border-top of |child| flush with the bottom border-edge of the float so it can layout any floating or positioned children of
|
| - // its own at the correct vertical position. If subsequent siblings attempt to collapse with |child|'s margins in |collapseMargins| we will
|
| - // adjust the height of the parent to |child|'s margin top (which if it is positive sits up 'inside' the float it's clearing) so that all three
|
| - // margins can collapse at the correct vertical position.
|
| - // Per CSS2.1 we need to ensure that any negative margin-top clears |child| beyond the bottom border-edge of the float so that the top border edge of the child
|
| - // (i.e. its clearance) is at a position that satisfies the equation: "the amount of clearance is set so that clearance + margin-top = [height of float],
|
| + // For now set the border-top of |child| flush with the bottom border-edge
|
| + // of the float so it can layout any floating or positioned children of its
|
| + // own at the correct vertical position. If subsequent siblings attempt to
|
| + // collapse with |child|'s margins in |collapseMargins| we will adjust the
|
| + // height of the parent to |child|'s margin top (which if it is positive
|
| + // sits up 'inside' the float it's clearing) so that all three margins can
|
| + // collapse at the correct vertical position.
|
| + // Per CSS2.1 we need to ensure that any negative margin-top clears |child|
|
| + // beyond the bottom border-edge of the float so that the top border edge of
|
| + // the child (i.e. its clearance) is at a position that satisfies the
|
| + // equation: "the amount of clearance is set so that:
|
| + // clearance + margin-top = [height of float],
|
| // i.e., clearance = [height of float] - margin-top".
|
| setLogicalHeight(child.logicalTop() + childMargins.negativeMarginBefore());
|
| } else {
|
| @@ -1776,7 +1881,8 @@ LayoutUnit LayoutBlockFlow::clearFloatsIfNeeded(LayoutBox& child,
|
| setMaxMarginBeforeValues(oldTopPosMargin, oldTopNegMargin);
|
| marginInfo.setAtBeforeSideOfBlock(false);
|
|
|
| - // In case the child discarded the before margin of the block we need to reset the mustDiscardMarginBefore flag to the initial value.
|
| + // In case the child discarded the before margin of the block we need to
|
| + // reset the mustDiscardMarginBefore flag to the initial value.
|
| setMustDiscardMarginBefore(style()->marginBeforeCollapse() ==
|
| MarginCollapseDiscard);
|
| }
|
| @@ -1787,15 +1893,16 @@ LayoutUnit LayoutBlockFlow::clearFloatsIfNeeded(LayoutBox& child,
|
| void LayoutBlockFlow::setCollapsedBottomMargin(const MarginInfo& marginInfo) {
|
| if (marginInfo.canCollapseWithMarginAfter() &&
|
| !marginInfo.canCollapseWithMarginBefore()) {
|
| - // Update the after side margin of the container to discard if the after margin of the last child also discards and we collapse with it.
|
| + // Update the after side margin of the container to discard if the after
|
| + // margin of the last child also discards and we collapse with it.
|
| // Don't update the max margin values because we won't need them anyway.
|
| if (marginInfo.discardMargin()) {
|
| setMustDiscardMarginAfter();
|
| return;
|
| }
|
|
|
| - // Update our max pos/neg bottom margins, since we collapsed our bottom margins
|
| - // with our children.
|
| + // Update our max pos/neg bottom margins, since we collapsed our bottom
|
| + // margins with our children.
|
| setMaxMarginAfterValues(
|
| std::max(maxPositiveMarginAfter(), marginInfo.positiveMargin()),
|
| std::max(maxNegativeMarginAfter(), marginInfo.negativeMargin()));
|
| @@ -1818,15 +1925,18 @@ void LayoutBlockFlow::marginBeforeEstimateForChild(
|
| LayoutUnit& positiveMarginBefore,
|
| LayoutUnit& negativeMarginBefore,
|
| bool& discardMarginBefore) const {
|
| - // Give up if in quirks mode and we're a body/table cell and the top margin of the child box is quirky.
|
| - // Give up if the child specified -webkit-margin-collapse: separate that prevents collapsing.
|
| + // Give up if in quirks mode and we're a body/table cell and the top margin of
|
| + // the child box is quirky.
|
| + // Give up if the child specified -webkit-margin-collapse: separate that
|
| + // prevents collapsing.
|
| // FIXME: Use writing mode independent accessor for marginBeforeCollapse.
|
| if ((document().inQuirksMode() && hasMarginBeforeQuirk(&child) &&
|
| (isTableCell() || isBody())) ||
|
| child.style()->marginBeforeCollapse() == MarginCollapseSeparate)
|
| return;
|
|
|
| - // The margins are discarded by a child that specified -webkit-margin-collapse: discard.
|
| + // The margins are discarded by a child that specified
|
| + // -webkit-margin-collapse: discard.
|
| // FIXME: Use writing mode independent accessor for marginBeforeCollapse.
|
| if (child.style()->marginBeforeCollapse() == MarginCollapseDiscard) {
|
| positiveMarginBefore = LayoutUnit();
|
| @@ -1863,7 +1973,8 @@ void LayoutBlockFlow::marginBeforeEstimateForChild(
|
| if (!grandchildBox)
|
| return;
|
|
|
| - // Make sure to update the block margins now for the grandchild box so that we're looking at current values.
|
| + // Make sure to update the block margins now for the grandchild box so that
|
| + // we're looking at current values.
|
| if (grandchildBox->needsLayout()) {
|
| grandchildBox->computeAndSetBlockDirectionMargins(this);
|
| if (grandchildBox->isLayoutBlock()) {
|
| @@ -1875,14 +1986,16 @@ void LayoutBlockFlow::marginBeforeEstimateForChild(
|
| }
|
| }
|
|
|
| - // If we have a 'clear' value but also have a margin we may not actually require clearance to move past any floats.
|
| - // If that's the case we want to be sure we estimate the correct position including margins after any floats rather
|
| - // than use 'clearance' later which could give us the wrong position.
|
| + // If we have a 'clear' value but also have a margin we may not actually
|
| + // require clearance to move past any floats. If that's the case we want to be
|
| + // sure we estimate the correct position including margins after any floats
|
| + // rather than use 'clearance' later which could give us the wrong position.
|
| if (grandchildBox->style()->clear() != ClearNone &&
|
| childBlockFlow->marginBeforeForChild(*grandchildBox) == 0)
|
| return;
|
|
|
| - // Collapse the margin of the grandchild box with our own to produce an estimate.
|
| + // Collapse the margin of the grandchild box with our own to produce an
|
| + // estimate.
|
| childBlockFlow->marginBeforeEstimateForChild(
|
| *grandchildBox, positiveMarginBefore, negativeMarginBefore,
|
| discardMarginBefore);
|
| @@ -1893,7 +2006,8 @@ LayoutUnit LayoutBlockFlow::estimateLogicalTopPosition(
|
| const BlockChildrenLayoutInfo& layoutInfo,
|
| LayoutUnit& estimateWithoutPagination) {
|
| const MarginInfo& marginInfo = layoutInfo.marginInfo();
|
| - // FIXME: We need to eliminate the estimation of vertical position, because when it's wrong we sometimes trigger a pathological
|
| + // FIXME: We need to eliminate the estimation of vertical position, because
|
| + // when it's wrong we sometimes trigger a pathological
|
| // relayout if there are intruding floats.
|
| LayoutUnit logicalTopEstimate = logicalHeight();
|
| LayoutUnit positiveMarginBefore;
|
| @@ -1905,8 +2019,8 @@ LayoutUnit LayoutBlockFlow::estimateLogicalTopPosition(
|
| marginBeforeEstimateForChild(child, positiveMarginBefore,
|
| negativeMarginBefore, discardMarginBefore);
|
| } else {
|
| - // Use the cached collapsed margin values from a previous layout. Most of the time they
|
| - // will be right.
|
| + // Use the cached collapsed margin values from a previous layout. Most of
|
| + // the time they will be right.
|
| LayoutBlockFlow::MarginValues marginValues = marginValuesForChild(child);
|
| positiveMarginBefore =
|
| std::max(positiveMarginBefore, marginValues.positiveMarginBefore());
|
| @@ -1922,8 +2036,8 @@ LayoutUnit LayoutBlockFlow::estimateLogicalTopPosition(
|
| std::max(marginInfo.negativeMargin(), negativeMarginBefore);
|
| }
|
|
|
| - // Adjust logicalTopEstimate down to the next page if the margins are so large that we don't fit on the current
|
| - // page.
|
| + // Adjust logicalTopEstimate down to the next page if the margins are so large
|
| + // that we don't fit on the current page.
|
| LayoutState* layoutState = view()->layoutState();
|
| if (layoutState->isPaginated() && isPageLogicalHeightKnown(logicalHeight()) &&
|
| logicalTopEstimate > logicalHeight())
|
| @@ -1936,17 +2050,18 @@ LayoutUnit LayoutBlockFlow::estimateLogicalTopPosition(
|
|
|
| if (layoutState->isPaginated()) {
|
| if (!layoutInfo.isAtFirstInFlowChild()) {
|
| - // Estimate the need for a forced break in front of this child. The final break policy
|
| - // at this class A break point isn't known until we have laid out the children of
|
| - // |child|. There may be forced break-before values set on first-children inside that
|
| - // get propagated up to the child. Just make an estimate with what we know so far.
|
| + // Estimate the need for a forced break in front of this child. The final
|
| + // break policy at this class A break point isn't known until we have laid
|
| + // out the children of |child|. There may be forced break-before values
|
| + // set on first-children inside that get propagated up to the child.
|
| + // Just make an estimate with what we know so far.
|
| EBreak breakValue =
|
| child.classABreakPointValue(layoutInfo.previousBreakAfterValue());
|
| if (isForcedFragmentainerBreakValue(breakValue)) {
|
| logicalTopEstimate = applyForcedBreak(logicalHeight(), breakValue);
|
| - // Disregard previous margins, since they will collapse with the fragmentainer
|
| - // boundary, due to the forced break. Only apply margins that have been specified
|
| - // on the child or its descendants.
|
| + // Disregard previous margins, since they will collapse with the
|
| + // fragmentainer boundary, due to the forced break. Only apply margins
|
| + // that have been specified on the child or its descendants.
|
| if (!discardMarginBefore)
|
| logicalTopEstimate += positiveMarginBefore - negativeMarginBefore;
|
|
|
| @@ -1956,7 +2071,8 @@ LayoutUnit LayoutBlockFlow::estimateLogicalTopPosition(
|
| }
|
| }
|
|
|
| - // For replaced elements and scrolled elements, we want to shift them to the next page if they don't fit on the current one.
|
| + // For replaced elements and scrolled elements, we want to shift them to the
|
| + // next page if they don't fit on the current one.
|
| logicalTopEstimate = adjustForUnsplittableChild(child, logicalTopEstimate);
|
| }
|
|
|
| @@ -1973,8 +2089,8 @@ void LayoutBlockFlow::adjustFloatingBlock(const MarginInfo& marginInfo) {
|
| //
|
| // Note also that the previous flow may collapse its margin into the top of
|
| // our block. If this is the case, then we do not add the margin in to our
|
| - // height when computing the position of the float. This condition can be tested
|
| - // for by simply calling canCollapseWithMarginBefore. See
|
| + // height when computing the position of the float. This condition can be
|
| + // tested for by simply calling canCollapseWithMarginBefore. See
|
| // http://www.hixie.ch/tests/adhoc/css/box/block/margin-collapse/046.html for
|
| // an example of this scenario.
|
| LayoutUnit marginOffset = marginInfo.canCollapseWithMarginBefore()
|
| @@ -1991,9 +2107,11 @@ void LayoutBlockFlow::handleAfterSideOfBlock(LayoutBox* lastChild,
|
| MarginInfo& marginInfo) {
|
| marginInfo.setAtAfterSideOfBlock(true);
|
|
|
| - // If our last child was a self-collapsing block with clearance then our logical height is flush with the
|
| - // bottom edge of the float that the child clears. The correct vertical position for the margin-collapsing we want
|
| - // to perform now is at the child's margin-top - so adjust our height to that position.
|
| + // If our last child was a self-collapsing block with clearance then our
|
| + // logical height is flush with the bottom edge of the float that the child
|
| + // clears. The correct vertical position for the margin-collapsing we want to
|
| + // perform now is at the child's margin-top - so adjust our height to that
|
| + // position.
|
| if (marginInfo.lastChildIsSelfCollapsingBlockWithClearance()) {
|
| ASSERT(lastChild);
|
| setLogicalHeight(logicalHeight() -
|
| @@ -2004,7 +2122,8 @@ void LayoutBlockFlow::handleAfterSideOfBlock(LayoutBox* lastChild,
|
| !marginInfo.canCollapseMarginAfterWithLastChild())
|
| marginInfo.setCanCollapseMarginAfterWithChildren(false);
|
|
|
| - // If we can't collapse with children then go ahead and add in the bottom margin.
|
| + // If we can't collapse with children then go ahead and add in the bottom
|
| + // margin.
|
| if (!marginInfo.discardMargin() &&
|
| (!marginInfo.canCollapseWithMarginAfter() &&
|
| !marginInfo.canCollapseWithMarginBefore() &&
|
| @@ -2015,17 +2134,18 @@ void LayoutBlockFlow::handleAfterSideOfBlock(LayoutBox* lastChild,
|
| // Now add in our bottom border/padding.
|
| setLogicalHeight(logicalHeight() + afterSide);
|
|
|
| - // Negative margins can cause our height to shrink below our minimal height (border/padding).
|
| - // If this happens, ensure that the computed height is increased to the minimal height.
|
| + // Negative margins can cause our height to shrink below our minimal height
|
| + // (border/padding). If this happens, ensure that the computed height is
|
| + // increased to the minimal height.
|
| setLogicalHeight(std::max(logicalHeight(), beforeSide + afterSide));
|
|
|
| // Update our bottom collapsed margin info.
|
| setCollapsedBottomMargin(marginInfo);
|
|
|
| - // There's no class A break point right after the last child, only *between* siblings. So
|
| - // propagate the break-after value, and keep looking for a class A break point (at the next
|
| - // in-flow block-level object), where we'll join this break-after value with the break-before
|
| - // value there.
|
| + // There's no class A break point right after the last child, only *between*
|
| + // siblings. So propagate the break-after value, and keep looking for a class
|
| + // A break point (at the next in-flow block-level object), where we'll join
|
| + // this break-after value with the break-before value there.
|
| if (view()->layoutState()->isPaginated() && lastChild)
|
| setBreakAfter(
|
| joinFragmentainerBreakValues(breakAfter(), lastChild->breakAfter()));
|
| @@ -2085,8 +2205,10 @@ bool LayoutBlockFlow::mustDiscardMarginBeforeForChild(
|
| : (child.style()->marginAfterCollapse() ==
|
| MarginCollapseDiscard);
|
|
|
| - // FIXME: We return false here because the implementation is not geometrically complete. We have values only for before/after, not start/end.
|
| - // In case the boxes are perpendicular we assume the property is not specified.
|
| + // FIXME: We return false here because the implementation is not geometrically
|
| + // complete. We have values only for before/after, not start/end.
|
| + // In case the boxes are perpendicular we assume the property is not
|
| + // specified.
|
| return false;
|
| }
|
|
|
| @@ -2160,17 +2282,20 @@ LayoutUnit LayoutBlockFlow::applyForcedBreak(LayoutUnit logicalOffset,
|
| EBreak breakValue) {
|
| if (!isForcedFragmentainerBreakValue(breakValue))
|
| return logicalOffset;
|
| - // TODO(mstensho): honor breakValue. There are different types of forced breaks. We currently
|
| - // just assume that we want to break to the top of the next fragmentainer of the fragmentation
|
| - // context we're in. However, we may want to find the next left or right page - even if we're
|
| - // inside a multicol container when printing.
|
| + // TODO(mstensho): honor breakValue. There are different types of forced
|
| + // breaks. We currently just assume that we want to break to the top of the
|
| + // next fragmentainer of the fragmentation context we're in. However, we may
|
| + // want to find the next left or right page - even if we're inside a multicol
|
| + // container when printing.
|
| LayoutUnit pageLogicalHeight = pageLogicalHeightForOffset(logicalOffset);
|
| if (!pageLogicalHeight)
|
| - return logicalOffset; // Page height is still unknown, so we cannot insert forced breaks.
|
| + return logicalOffset; // Page height is still unknown, so we cannot insert
|
| + // forced breaks.
|
| LayoutUnit remainingLogicalHeight = pageRemainingLogicalHeightForOffset(
|
| logicalOffset, AssociateWithLatterPage);
|
| if (remainingLogicalHeight == pageLogicalHeight)
|
| - return logicalOffset; // Don't break if we're already at the block start of a fragmentainer.
|
| + return logicalOffset; // Don't break if we're already at the block start of
|
| + // a fragmentainer.
|
| return logicalOffset + remainingLogicalHeight;
|
| }
|
|
|
| @@ -2238,7 +2363,8 @@ void LayoutBlockFlow::computeSelfHitTestRects(
|
| std::min<LayoutUnit>(curr->lineBottom(), curr->top() + curr->height());
|
| LayoutRect rect(layerOffset.x() + curr->x(), layerOffset.y() + top,
|
| curr->width(), bottom - top);
|
| - // It's common for this rect to be entirely contained in our box, so exclude that simple case.
|
| + // It's common for this rect to be entirely contained in our box, so exclude
|
| + // that simple case.
|
| if (!rect.isEmpty() && (rects.isEmpty() || !rects[0].contains(rect)))
|
| rects.append(rect);
|
| }
|
| @@ -2251,9 +2377,9 @@ void LayoutBlockFlow::absoluteRects(
|
| LayoutBlock::absoluteRects(rects, accumulatedOffset);
|
| return;
|
| }
|
| - // For blocks inside inlines, we go ahead and include margins so that we run right up to the
|
| - // inline boxes above and below us (thus getting merged with them to form a single irregular
|
| - // shape).
|
| + // For blocks inside inlines, we go ahead and include margins so that we run
|
| + // right up to the inline boxes above and below us (thus getting merged with
|
| + // them to form a single irregular shape).
|
| // FIXME: This is wrong for vertical writing-modes.
|
| // https://bugs.webkit.org/show_bug.cgi?id=46781
|
| LayoutRect rect(accumulatedOffset, size());
|
| @@ -2272,9 +2398,9 @@ void LayoutBlockFlow::absoluteQuads(Vector<FloatQuad>& quads) const {
|
| LayoutBlock::absoluteQuads(quads);
|
| return;
|
| }
|
| - // For blocks inside inlines, we go ahead and include margins so that we run right up to the
|
| - // inline boxes above and below us (thus getting merged with them to form a single irregular
|
| - // shape).
|
| + // For blocks inside inlines, we go ahead and include margins so that we run
|
| + // right up to the inline boxes above and below us (thus getting merged with
|
| + // them to form a single irregular shape).
|
| // FIXME: This is wrong for vertical writing-modes.
|
| // https://bugs.webkit.org/show_bug.cgi?id=46781
|
| LayoutRect localRect(LayoutPoint(), size());
|
| @@ -2347,7 +2473,8 @@ int LayoutBlockFlow::inlineBlockBaseline(
|
| if ((!style()->isOverflowVisible() &&
|
| !shouldIgnoreOverflowPropertyForInlineBlockBaseline()) ||
|
| style()->containsSize()) {
|
| - // We are not calling baselinePosition here because the caller should add the margin-top/margin-right, not us.
|
| + // We are not calling baselinePosition here because the caller should add
|
| + // the margin-top/margin-right, not us.
|
| return (lineDirection == HorizontalLine ? size().height() + marginBottom()
|
| : size().width() + marginLeft())
|
| .toInt();
|
| @@ -2380,14 +2507,17 @@ void LayoutBlockFlow::removeFloatingObjectsFromDescendants() {
|
| removeFloatingObjects();
|
| setChildNeedsLayout(MarkOnlyThis);
|
|
|
| - // If our children are inline, then the only boxes which could contain floats are atomic inlines (e.g. inline-block, float etc.)
|
| - // and these create formatting contexts, so can't pick up intruding floats from ancestors/siblings - making them safe to skip.
|
| + // If our children are inline, then the only boxes which could contain floats
|
| + // are atomic inlines (e.g. inline-block, float etc.) and these create
|
| + // formatting contexts, so can't pick up intruding floats from
|
| + // ancestors/siblings - making them safe to skip.
|
| if (childrenInline())
|
| return;
|
| for (LayoutObject* child = firstChild(); child;
|
| child = child->nextSibling()) {
|
| - // We don't skip blocks that create formatting contexts as they may have only recently
|
| - // changed style and their float lists may still contain floats from siblings and ancestors.
|
| + // We don't skip blocks that create formatting contexts as they may have
|
| + // only recently changed style and their float lists may still contain
|
| + // floats from siblings and ancestors.
|
| if (child->isLayoutBlockFlow())
|
| toLayoutBlockFlow(child)->removeFloatingObjectsFromDescendants();
|
| }
|
| @@ -2409,9 +2539,11 @@ void LayoutBlockFlow::markAllDescendantsWithFloatsForLayout(
|
| if (floatToRemove)
|
| removeFloatingObject(floatToRemove);
|
|
|
| - // Iterate over our children and mark them as needed. If our children are inline, then the
|
| - // only boxes which could contain floats are atomic inlines (e.g. inline-block, float etc.) and these create formatting
|
| - // contexts, so can't pick up intruding floats from ancestors/siblings - making them safe to skip.
|
| + // Iterate over our children and mark them as needed. If our children are
|
| + // inline, then the only boxes which could contain floats are atomic inlines
|
| + // (e.g. inline-block, float etc.) and these create formatting contexts, so
|
| + // can't pick up intruding floats from ancestors/siblings - making them safe
|
| + // to skip.
|
| if (!childrenInline()) {
|
| for (LayoutObject* child = firstChild(); child;
|
| child = child->nextSibling()) {
|
| @@ -2466,7 +2598,8 @@ LayoutUnit LayoutBlockFlow::getClearDelta(LayoutBox* child,
|
| if (!containsFloats())
|
| return LayoutUnit();
|
|
|
| - // At least one float is present. We need to perform the clearance computation.
|
| + // At least one float is present. We need to perform the clearance
|
| + // computation.
|
| bool clearSet = child->style()->clear() != ClearNone;
|
| LayoutUnit logicalBottom;
|
| switch (child->style()->clear()) {
|
| @@ -2483,7 +2616,8 @@ LayoutUnit LayoutBlockFlow::getClearDelta(LayoutBox* child,
|
| break;
|
| }
|
|
|
| - // We also clear floats if we are too big to sit on the same line as a float (and wish to avoid floats by default).
|
| + // We also clear floats if we are too big to sit on the same line as a float
|
| + // (and wish to avoid floats by default).
|
| LayoutUnit result = clearSet
|
| ? (logicalBottom - logicalTop).clampNegativeToZero()
|
| : LayoutUnit();
|
| @@ -2508,9 +2642,12 @@ LayoutUnit LayoutBlockFlow::getClearDelta(LayoutBox* child,
|
|
|
| if (childLogicalWidthAtNewLogicalTopOffset <=
|
| availableLogicalWidthAtNewLogicalTopOffset) {
|
| - // Even though we may not be moving, if the logical width did shrink because of the presence of new floats, then
|
| - // we need to force a relayout as though we shifted. This happens because of the dynamic addition of overhanging floats
|
| - // from previous siblings when negative margins exist on a child (see the addOverhangingFloats call at the end of collapseMargins).
|
| + // Even though we may not be moving, if the logical width did shrink
|
| + // because of the presence of new floats, then we need to force a
|
| + // relayout as though we shifted. This happens because of the dynamic
|
| + // addition of overhanging floats from previous siblings when negative
|
| + // margins exist on a child (see the addOverhangingFloats call at the
|
| + // end of collapseMargins).
|
| if (childLogicalWidthAtOldLogicalTopOffset !=
|
| childLogicalWidthAtNewLogicalTopOffset)
|
| child->setChildNeedsLayout(MarkOnlyThis);
|
| @@ -2536,13 +2673,16 @@ void LayoutBlockFlow::willBeDestroyed() {
|
| // Mark as being destroyed to avoid trouble with merges in removeChild().
|
| m_beingDestroyed = true;
|
|
|
| - // Make sure to destroy anonymous children first while they are still connected to the rest of the tree, so that they will
|
| - // properly dirty line boxes that they are removed from. Effects that do :before/:after only on hover could crash otherwise.
|
| + // Make sure to destroy anonymous children first while they are still
|
| + // connected to the rest of the tree, so that they will properly dirty line
|
| + // boxes that they are removed from. Effects that do :before/:after only on
|
| + // hover could crash otherwise.
|
| children()->destroyLeftoverChildren();
|
|
|
| // Destroy our continuation before anything other than anonymous children.
|
| // The reason we don't destroy it before anonymous children is that they may
|
| - // have continuations of their own that are anonymous children of our continuation.
|
| + // have continuations of their own that are anonymous children of our
|
| + // continuation.
|
| LayoutBoxModelObject* continuation = this->continuation();
|
| if (continuation) {
|
| continuation->destroy();
|
| @@ -2550,8 +2690,8 @@ void LayoutBlockFlow::willBeDestroyed() {
|
| }
|
|
|
| if (!documentBeingDestroyed()) {
|
| - // TODO(mstensho): figure out if we need this. We have no test coverage for it. It looks
|
| - // like all line boxes have been removed at this point.
|
| + // TODO(mstensho): figure out if we need this. We have no test coverage for
|
| + // it. It looks like all line boxes have been removed at this point.
|
| if (firstLineBox()) {
|
| // We can't wait for LayoutBox::destroy to clear the selection,
|
| // because by then we will have nuked the line boxes.
|
| @@ -2598,18 +2738,20 @@ void LayoutBlockFlow::styleDidChange(StyleDifference diff,
|
| bool hadSelfPaintingLayer = hasSelfPaintingLayer();
|
| LayoutBlock::styleDidChange(diff, oldStyle);
|
|
|
| - // After our style changed, if we lose our ability to propagate floats into next sibling
|
| - // blocks, then we need to find the top most parent containing that overhanging float and
|
| - // then mark its descendants with floats for layout and clear all floats from its next
|
| - // sibling blocks that exist in our floating objects list. See bug 56299 and 62875.
|
| + // After our style changed, if we lose our ability to propagate floats into
|
| + // next sibling blocks, then we need to find the top most parent containing
|
| + // that overhanging float and then mark its descendants with floats for layout
|
| + // and clear all floats from its next sibling blocks that exist in our
|
| + // floating objects list. See crbug.com/56299 and crbug.com/62875.
|
| bool canPropagateFloatIntoSibling =
|
| !isFloatingOrOutOfFlowPositioned() && !avoidsFloats();
|
| bool siblingFloatPropagationChanged =
|
| diff.needsFullLayout() && s_canPropagateFloatIntoSibling &&
|
| !canPropagateFloatIntoSibling && hasOverhangingFloats();
|
|
|
| - // When this object's self-painting layer status changed, we should update FloatingObjects::shouldPaint() flags for
|
| - // descendant overhanging floats in ancestors.
|
| + // When this object's self-painting layer status changed, we should update
|
| + // FloatingObjects::shouldPaint() flags for descendant overhanging floats in
|
| + // ancestors.
|
| bool needsUpdateAncestorFloatObjectShouldPaintFlags = false;
|
| if (hasSelfPaintingLayer() != hadSelfPaintingLayer &&
|
| hasOverhangingFloats()) {
|
| @@ -2654,8 +2796,8 @@ void LayoutBlockFlow::styleDidChange(StyleDifference diff,
|
| if (oldStyle) {
|
| if (LayoutMultiColumnFlowThread* flowThread = multiColumnFlowThread()) {
|
| if (!style()->columnRuleEquivalent(oldStyle)) {
|
| - // Column rules are painted by anonymous column set children of the multicol
|
| - // container. We need to notify them.
|
| + // Column rules are painted by anonymous column set children of the
|
| + // multicol container. We need to notify them.
|
| flowThread->columnRuleStyleDidChange();
|
| }
|
| }
|
| @@ -2711,15 +2853,16 @@ void LayoutBlockFlow::addChild(LayoutObject* newChild,
|
|
|
| bool madeBoxesNonInline = false;
|
|
|
| - // A block has to either have all of its children inline, or all of its children as blocks.
|
| - // So, if our children are currently inline and a block child has to be inserted, we move all our
|
| - // inline children into anonymous block boxes.
|
| + // A block has to either have all of its children inline, or all of its
|
| + // children as blocks.
|
| + // So, if our children are currently inline and a block child has to be
|
| + // inserted, we move all our inline children into anonymous block boxes.
|
| bool childIsBlockLevel =
|
| !newChild->isInline() && !newChild->isFloatingOrOutOfFlowPositioned();
|
| if (childrenInline()) {
|
| if (childIsBlockLevel) {
|
| - // Wrap the inline content in anonymous blocks, to allow for the new block child to be
|
| - // inserted.
|
| + // Wrap the inline content in anonymous blocks, to allow for the new block
|
| + // child to be inserted.
|
| makeChildrenNonInline(beforeChild);
|
| madeBoxesNonInline = true;
|
|
|
| @@ -2730,11 +2873,12 @@ void LayoutBlockFlow::addChild(LayoutObject* newChild,
|
| }
|
| }
|
| } else if (!childIsBlockLevel) {
|
| - // This block has block children. We may want to put the new child into an anomyous
|
| - // block. Floats and out-of-flow children may live among either block or inline children,
|
| - // so for such children, only put them inside an anonymous block if one already exists. If
|
| - // the child is inline, on the other hand, we *have to* put it inside an anonymous block,
|
| - // so create a new one if there is none for us there already.
|
| + // This block has block children. We may want to put the new child into an
|
| + // anomyous block. Floats and out-of-flow children may live among either
|
| + // block or inline children, so for such children, only put them inside an
|
| + // anonymous block if one already exists. If the child is inline, on the
|
| + // other hand, we *have to* put it inside an anonymous block, so create a
|
| + // new one if there is none for us there already.
|
| LayoutObject* afterChild =
|
| beforeChild ? beforeChild->previousSibling() : lastChild();
|
|
|
| @@ -2755,8 +2899,9 @@ void LayoutBlockFlow::addChild(LayoutObject* newChild,
|
| }
|
| }
|
|
|
| - // Skip the LayoutBlock override, since that one deals with anonymous child insertion in a way
|
| - // that isn't sufficient for us, and can only cause trouble at this point.
|
| + // Skip the LayoutBlock override, since that one deals with anonymous child
|
| + // insertion in a way that isn't sufficient for us, and can only cause trouble
|
| + // at this point.
|
| LayoutBox::addChild(newChild, beforeChild);
|
|
|
| if (madeBoxesNonInline && parent() && isAnonymousBlock() &&
|
| @@ -2846,7 +2991,8 @@ void LayoutBlockFlow::removeChild(LayoutObject* oldChild) {
|
| } else if (!beingDestroyed() &&
|
| !oldChild->isFloatingOrOutOfFlowPositioned() &&
|
| !oldChild->isAnonymousBlock()) {
|
| - // If the child we're removing means that we can now treat all children as inline without the need for anonymous blocks, then do that.
|
| + // If the child we're removing means that we can now treat all children as
|
| + // inline without the need for anonymous blocks, then do that.
|
| makeChildrenInlineIfPossible();
|
| }
|
| }
|
| @@ -2861,14 +3007,14 @@ void LayoutBlockFlow::moveAllChildrenIncludingFloatsTo(LayoutBlock* toBlock,
|
| // anonymous block later in the tree is merged into the one preceding it.
|
| // It can happen that the later block (this) contains floats that the
|
| // previous block (toBlockFlow) did not contain, and thus are not in the
|
| - // floating objects list for toBlockFlow. This can result in toBlockFlow containing
|
| - // floats that are not in it's floating objects list, but are in the
|
| - // floating objects lists of siblings and parents. This can cause problems
|
| - // when the float itself is deleted, since the deletion code assumes that
|
| - // if a float is not in it's containing block's floating objects list, it
|
| - // isn't in any floating objects list. In order to preserve this condition
|
| - // (removing it has serious performance implications), we need to copy the
|
| - // floating objects from the old block (this) to the new block (toBlockFlow).
|
| + // floating objects list for toBlockFlow. This can result in toBlockFlow
|
| + // containing floats that are not in it's floating objects list, but are in
|
| + // the floating objects lists of siblings and parents. This can cause problems
|
| + // when the float itself is deleted, since the deletion code assumes that if a
|
| + // float is not in it's containing block's floating objects list, it isn't in
|
| + // any floating objects list. In order to preserve this condition (removing it
|
| + // has serious performance implications), we need to copy the floating objects
|
| + // from the old block (this) to the new block (toBlockFlow).
|
| // The float's metrics will likely all be wrong, but since toBlockFlow is
|
| // already marked for layout, this will get fixed before anything gets
|
| // displayed.
|
| @@ -2901,8 +3047,8 @@ void LayoutBlockFlow::childBecameFloatingOrOutOfFlow(LayoutBox* child) {
|
| if (prev && prev->isAnonymousBlock() && prev->isLayoutBlockFlow()) {
|
| LayoutBlockFlow* newContainer = toLayoutBlockFlow(prev);
|
| moveChildTo(newContainer, child, nullptr, false);
|
| - // The anonymous block we've moved to may now be adjacent to former siblings of ours
|
| - // that it can contain also.
|
| + // The anonymous block we've moved to may now be adjacent to former siblings
|
| + // of ours that it can contain also.
|
| newContainer->reparentSubsequentFloatingOrOutOfFlowSiblings();
|
| return;
|
| }
|
| @@ -2921,7 +3067,8 @@ void LayoutBlockFlow::collapseAnonymousBlockChild(LayoutBlockFlow* child) {
|
| return;
|
| if (child->continuation())
|
| return;
|
| - // Ruby elements use anonymous wrappers for ruby runs and ruby bases by design, so we don't remove them.
|
| + // Ruby elements use anonymous wrappers for ruby runs and ruby bases by
|
| + // design, so we don't remove them.
|
| if (child->isRubyRun() || child->isRubyBase())
|
| return;
|
| setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(
|
| @@ -2936,8 +3083,9 @@ void LayoutBlockFlow::collapseAnonymousBlockChild(LayoutBlockFlow* child) {
|
|
|
| bool LayoutBlockFlow::mergeSiblingContiguousAnonymousBlock(
|
| LayoutBlockFlow* siblingThatMayBeDeleted) {
|
| - // Note: |this| and |siblingThatMayBeDeleted| may not be adjacent siblings at this point. There
|
| - // may be an object between them which is about to be removed.
|
| + // Note: |this| and |siblingThatMayBeDeleted| may not be adjacent siblings at
|
| + // this point. There may be an object between them which is about to be
|
| + // removed.
|
|
|
| if (!isMergeableAnonymousBlock(this) ||
|
| !isMergeableAnonymousBlock(siblingThatMayBeDeleted))
|
| @@ -2946,8 +3094,8 @@ bool LayoutBlockFlow::mergeSiblingContiguousAnonymousBlock(
|
| setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(
|
| LayoutInvalidationReason::AnonymousBlockChange);
|
|
|
| - // If the inlineness of children of the two block don't match, we'd need special code here
|
| - // (but there should be no need for it).
|
| + // If the inlineness of children of the two block don't match, we'd need
|
| + // special code here (but there should be no need for it).
|
| ASSERT(siblingThatMayBeDeleted->childrenInline() == childrenInline());
|
| // Take all the children out of the |next| block and put them in
|
| // the |prev| block.
|
| @@ -2993,7 +3141,8 @@ void LayoutBlockFlow::reparentPrecedingFloatingOrOutOfFlowSiblings() {
|
| }
|
|
|
| void LayoutBlockFlow::makeChildrenInlineIfPossible() {
|
| - // Collapsing away anonymous wrappers isn't relevant for the children of anonymous blocks, unless they are ruby bases.
|
| + // Collapsing away anonymous wrappers isn't relevant for the children of
|
| + // anonymous blocks, unless they are ruby bases.
|
| if (isAnonymousBlock() && !isRubyBase())
|
| return;
|
|
|
| @@ -3005,29 +3154,35 @@ void LayoutBlockFlow::makeChildrenInlineIfPossible() {
|
| if (child->isOutOfFlowPositioned())
|
| continue;
|
|
|
| - // There are still block children in the container, so any anonymous wrappers are still needed.
|
| + // There are still block children in the container, so any anonymous
|
| + // wrappers are still needed.
|
| if (!child->isAnonymousBlock() || !child->isLayoutBlockFlow())
|
| return;
|
| - // If one of the children is being destroyed then it is unsafe to clean up anonymous wrappers as the
|
| + // If one of the children is being destroyed then it is unsafe to clean up
|
| + // anonymous wrappers as the
|
| // entire branch may be being destroyed.
|
| if (toLayoutBlockFlow(child)->beingDestroyed())
|
| return;
|
| - // We can't remove anonymous wrappers if they contain continuations as this means there are block children present.
|
| + // We can't remove anonymous wrappers if they contain continuations as this
|
| + // means there are block children present.
|
| if (toLayoutBlockFlow(child)->continuation())
|
| return;
|
| - // We are only interested in removing anonymous wrappers if there are inline siblings underneath them.
|
| + // We are only interested in removing anonymous wrappers if there are inline
|
| + // siblings underneath them.
|
| if (!child->childrenInline())
|
| return;
|
| - // Ruby elements use anonymous wrappers for ruby runs and ruby bases by design, so we don't remove them.
|
| + // Ruby elements use anonymous wrappers for ruby runs and ruby bases by
|
| + // design, so we don't remove them.
|
| if (child->isRubyRun() || child->isRubyBase())
|
| return;
|
|
|
| blocksToRemove.append(toLayoutBlockFlow(child));
|
| }
|
|
|
| - // If we make an object's children inline we are going to frustrate any future attempts to remove
|
| - // floats from its children's float-lists before the next layout happens so clear down all the floatlists
|
| - // now - they will be rebuilt at layout.
|
| + // If we make an object's children inline we are going to frustrate any future
|
| + // attempts to remove floats from its children's float-lists before the next
|
| + // layout happens so clear down all the floatlists now - they will be rebuilt
|
| + // at layout.
|
| removeFloatingObjectsFromDescendants();
|
|
|
| for (size_t i = 0; i < blocksToRemove.size(); i++)
|
| @@ -3047,9 +3202,9 @@ static void getInlineRun(LayoutObject* start,
|
| // We skip any non-inlines we encounter as long as we haven't found any
|
| // inlines yet.
|
| //
|
| - // |boundary| indicates a non-inclusive boundary point. Regardless of whether |boundary|
|
| - // is inline or not, we will not include it in a run with inlines before it. It's as though we encountered
|
| - // a non-inline.
|
| + // |boundary| indicates a non-inclusive boundary point. Regardless of whether
|
| + // |boundary| is inline or not, we will not include it in a run with inlines
|
| + // before it. It's as though we encountered a non-inline.
|
|
|
| // Start by skipping as many non-inlines as we can.
|
| LayoutObject* curr = start;
|
| @@ -3080,12 +3235,12 @@ static void getInlineRun(LayoutObject* start,
|
|
|
| void LayoutBlockFlow::makeChildrenNonInline(LayoutObject* insertionPoint) {
|
| // makeChildrenNonInline takes a block whose children are *all* inline and it
|
| - // makes sure that inline children are coalesced under anonymous
|
| - // blocks. If |insertionPoint| is defined, then it represents the insertion point for
|
| - // the new block child that is causing us to have to wrap all the inlines. This
|
| - // means that we cannot coalesce inlines before |insertionPoint| with inlines following
|
| - // |insertionPoint|, because the new child is going to be inserted in between the inlines,
|
| - // splitting them.
|
| + // makes sure that inline children are coalesced under anonymous blocks.
|
| + // If |insertionPoint| is defined, then it represents the insertion point for
|
| + // the new block child that is causing us to have to wrap all the inlines.
|
| + // This means that we cannot coalesce inlines before |insertionPoint| with
|
| + // inlines following |insertionPoint|, because the new child is going to be
|
| + // inserted in between the inlines, splitting them.
|
| ASSERT(!isInline() || isAtomicInlineLevel());
|
| ASSERT(!insertionPoint || insertionPoint->parent() == this);
|
|
|
| @@ -3168,9 +3323,10 @@ LayoutPoint LayoutBlockFlow::flipFloatForWritingModeForChild(
|
| if (!style()->isFlippedBlocksWritingMode())
|
| return point;
|
|
|
| - // This is similar to LayoutBox::flipForWritingModeForChild. We have to subtract out our left offsets twice, since
|
| - // it's going to get added back in. We hide this complication here so that the calling code looks normal for the unflipped
|
| - // case.
|
| + // This is similar to LayoutBox::flipForWritingModeForChild. We have to
|
| + // subtract out our left offsets twice, since it's going to get added back in.
|
| + // We hide this complication here so that the calling code looks normal for
|
| + // the unflipped case.
|
| return LayoutPoint(point.x() + size().width() -
|
| child.layoutObject()->size().width() -
|
| 2 * xPositionForFloatIncludingMargin(child),
|
| @@ -3313,8 +3469,8 @@ FloatingObject* LayoutBlockFlow::insertFloatingObject(LayoutBox& floatBox) {
|
|
|
| std::unique_ptr<FloatingObject> newObj = FloatingObject::create(&floatBox);
|
|
|
| - // Our location is irrelevant if we're unsplittable or no pagination is in effect.
|
| - // Just go ahead and lay out the float.
|
| + // Our location is irrelevant if we're unsplittable or no pagination is in
|
| + // effect. Just go ahead and lay out the float.
|
| bool isChildLayoutBlock = floatBox.isLayoutBlock();
|
| if (isChildLayoutBlock && !floatBox.needsLayout() &&
|
| view()->layoutState()->pageLogicalHeightChanged())
|
| @@ -3345,9 +3501,9 @@ void LayoutBlockFlow::removeFloatingObject(LayoutBox* floatBox) {
|
| logicalTop == LayoutUnit::max()) {
|
| logicalBottom = LayoutUnit::max();
|
| } else {
|
| - // Special-case zero- and less-than-zero-height floats: those don't touch
|
| - // the line that they're on, but it still needs to be dirtied. This is
|
| - // accomplished by pretending they have a height of 1.
|
| + // Special-case zero- and less-than-zero-height floats: those don't
|
| + // touch the line that they're on, but it still needs to be dirtied.
|
| + // This is accomplished by pretending they have a height of 1.
|
| logicalBottom = std::max(logicalBottom, logicalTop + 1);
|
| }
|
| if (floatingObject.originatingLine()) {
|
| @@ -3396,9 +3552,9 @@ bool LayoutBlockFlow::positionNewFloats(LineWidth* width) {
|
| if (floatingObjectSet.last()->isPlaced())
|
| return false;
|
|
|
| - // Move backwards through our floating object list until we find a float that has
|
| - // already been positioned. Then we'll be able to move forward, positioning all of
|
| - // the new floats that need it.
|
| + // Move backwards through our floating object list until we find a float that
|
| + // has already been positioned. Then we'll be able to move forward,
|
| + // positioning all of the new floats that need it.
|
| FloatingObjectSetIterator it = floatingObjectSet.end();
|
| --it; // Go to last item.
|
| FloatingObjectSetIterator begin = floatingObjectSet.begin();
|
| @@ -3423,8 +3579,9 @@ bool LayoutBlockFlow::positionNewFloats(LineWidth* width) {
|
| // Now walk through the set of unpositioned floats and place them.
|
| for (; it != end; ++it) {
|
| FloatingObject& floatingObject = *it->get();
|
| - // The containing block is responsible for positioning floats, so if we have floats in our
|
| - // list that come from somewhere else, do not attempt to position them.
|
| + // The containing block is responsible for positioning floats, so if we have
|
| + // floats in our list that come from somewhere else, do not attempt to
|
| + // position them.
|
| if (floatingObject.layoutObject()->containingBlock() != this)
|
| continue;
|
|
|
| @@ -3445,8 +3602,8 @@ bool LayoutBlockFlow::positionNewFloats(LineWidth* width) {
|
|
|
| bool isPaginated = view()->layoutState()->isPaginated();
|
| if (isPaginated && !childrenInline()) {
|
| - // Forced breaks are inserted at class A break points. Floats may be affected by a
|
| - // break-after value on the previous in-flow sibling.
|
| + // Forced breaks are inserted at class A break points. Floats may be
|
| + // affected by a break-after value on the previous in-flow sibling.
|
| if (LayoutBox* previousInFlowBox = childBox->previousInFlowSiblingBox())
|
| logicalTop =
|
| applyForcedBreak(logicalTop, previousInFlowBox->breakAfter());
|
| @@ -3471,13 +3628,14 @@ bool LayoutBlockFlow::positionNewFloats(LineWidth* width) {
|
| if (isPaginated) {
|
| LayoutBlockFlow* childBlockFlow =
|
| childBox->isLayoutBlockFlow() ? toLayoutBlockFlow(childBox) : nullptr;
|
| - // The first piece of content inside the child may have set a strut during layout.
|
| + // The first piece of content inside the child may have set a strut during
|
| + // layout.
|
| LayoutUnit strut =
|
| childBlockFlow ? childBlockFlow->paginationStrutPropagatedFromChild()
|
| : LayoutUnit();
|
| if (!strut) {
|
| - // Otherwise, if we are unsplittable and don't fit, move to the next page or column
|
| - // if that helps the situation.
|
| + // Otherwise, if we are unsplittable and don't fit, move to the next
|
| + // page or column if that helps the situation.
|
| strut =
|
| adjustForUnsplittableChild(*childBox, floatLogicalLocation.y()) -
|
| floatLogicalLocation.y();
|
| @@ -3536,11 +3694,13 @@ void LayoutBlockFlow::addIntrudingFloats(LayoutBlockFlow* prev,
|
| LayoutUnit logicalTopOffset) {
|
| ASSERT(!avoidsFloats());
|
|
|
| - // If we create our own block formatting context then our contents don't interact with floats outside it, even those from our parent.
|
| + // If we create our own block formatting context then our contents don't
|
| + // interact with floats outside it, even those from our parent.
|
| if (createsNewFormattingContext())
|
| return;
|
|
|
| - // If the parent or previous sibling doesn't have any floats to add, don't bother.
|
| + // If the parent or previous sibling doesn't have any floats to add, don't
|
| + // bother.
|
| if (!prev->m_floatingObjects)
|
| return;
|
|
|
| @@ -3558,11 +3718,12 @@ void LayoutBlockFlow::addIntrudingFloats(LayoutBlockFlow* prev,
|
| if (!m_floatingObjects)
|
| createFloatingObjects();
|
|
|
| - // Applying the child's margin makes no sense in the case where the child was passed in.
|
| - // since this margin was added already through the modification of the |logicalLeftOffset| variable
|
| - // above. |logicalLeftOffset| will equal the margin in this case, so it's already been taken
|
| - // into account. Only apply this code if prev is the parent, since otherwise the left margin
|
| - // will get applied twice.
|
| + // Applying the child's margin makes no sense in the case where the
|
| + // child was passed in since this margin was added already through the
|
| + // modification of the |logicalLeftOffset| variable above.
|
| + // |logicalLeftOffset| will equal the margin in this case, so it's
|
| + // already been taken into account. Only apply this code if prev is the
|
| + // parent, since otherwise the left margin will get applied twice.
|
| LayoutSize offset =
|
| isHorizontalWritingMode()
|
| ? LayoutSize(
|
| @@ -3582,15 +3743,16 @@ void LayoutBlockFlow::addIntrudingFloats(LayoutBlockFlow* prev,
|
|
|
| void LayoutBlockFlow::addOverhangingFloats(LayoutBlockFlow* child,
|
| bool makeChildPaintOtherFloats) {
|
| - // Prevent floats from being added to the canvas by the root element, e.g., <html>.
|
| + // Prevent floats from being added to the canvas by the root element, e.g.,
|
| + // <html>.
|
| if (!child->containsFloats() || child->createsNewFormattingContext())
|
| return;
|
|
|
| LayoutUnit childLogicalTop = child->logicalTop();
|
| LayoutUnit childLogicalLeft = child->logicalLeft();
|
|
|
| - // Floats that will remain the child's responsibility to paint should factor into its
|
| - // overflow.
|
| + // Floats that will remain the child's responsibility to paint should factor
|
| + // into its overflow.
|
| FloatingObjectSetIterator childEnd = child->m_floatingObjects->set().end();
|
| for (FloatingObjectSetIterator childIt =
|
| child->m_floatingObjects->set().begin();
|
| @@ -3610,10 +3772,11 @@ void LayoutBlockFlow::addOverhangingFloats(LayoutBlockFlow* child,
|
| : LayoutSize(-childLogicalTop, -childLogicalLeft);
|
| bool shouldPaint = false;
|
|
|
| - // The nearest enclosing layer always paints the float (so that zindex and stacking
|
| - // behaves properly). We always want to propagate the desire to paint the float as
|
| - // far out as we can, to the outermost block that overlaps the float, stopping only
|
| - // if we hit a self-painting layer boundary.
|
| + // The nearest enclosing layer always paints the float (so that zindex
|
| + // and stacking behaves properly). We always want to propagate the
|
| + // desire to paint the float as far out as we can, to the outermost
|
| + // block that overlaps the float, stopping only if we hit a
|
| + // self-painting layer boundary.
|
| if (floatingObject.layoutObject()->enclosingFloatPaintingLayer() ==
|
| enclosingFloatPaintingLayer() &&
|
| !floatingObject.isLowestNonOverhangingFloatInChild()) {
|
| @@ -3634,16 +3797,17 @@ void LayoutBlockFlow::addOverhangingFloats(LayoutBlockFlow* child,
|
| floatingObject.layoutObject()->isDescendantOf(child) &&
|
| floatingObject.layoutObject()->enclosingFloatPaintingLayer() ==
|
| child->enclosingFloatPaintingLayer()) {
|
| - // The float is not overhanging from this block, so if it is a descendant of the child, the child should
|
| - // paint it (the other case is that it is intruding into the child), unless it has its own layer or enclosing
|
| - // layer.
|
| - // If makeChildPaintOtherFloats is false, it means that the child must already know about all the floats
|
| - // it should paint.
|
| + // The float is not overhanging from this block, so if it is a
|
| + // descendant of the child, the child should paint it (the other case is
|
| + // that it is intruding into the child), unless it has its own layer or
|
| + // enclosing layer.
|
| + // If makeChildPaintOtherFloats is false, it means that the child must
|
| + // already know about all the floats it should paint.
|
| floatingObject.setShouldPaint(true);
|
| }
|
|
|
| - // Since the float doesn't overhang, it didn't get put into our list. We need to go ahead and add its overflow in to the
|
| - // child now.
|
| + // Since the float doesn't overhang, it didn't get put into our list. We
|
| + // need to go ahead and add its overflow in to the child now.
|
| if (floatingObject.isDescendant())
|
| child->addOverflowFromChild(
|
| floatingObject.layoutObject(),
|
| @@ -3806,10 +3970,12 @@ void LayoutBlockFlow::setAncestorShouldPaintFloatingObject(
|
|
|
| FloatingObject& floatingObject = **it;
|
| if (!floatBoxIsSelfPaintingLayer) {
|
| - // This repeats the logic in addOverhangingFloats() about shouldPaint flag:
|
| - // - The nearest enclosing block in which the float doesn't overhang paints the float;
|
| - // - Or even if the float overhangs, if the ancestor block has self-painting layer, it
|
| - // paints the float.
|
| + // This repeats the logic in addOverhangingFloats() about shouldPaint
|
| + // flag:
|
| + // - The nearest enclosing block in which the float doesn't overhang
|
| + // paints the float;
|
| + // - Or even if the float overhangs, if the ancestor block has
|
| + // self-painting layer, it paints the float.
|
| if (ancestorBlock->hasSelfPaintingLayer() ||
|
| !ancestorBlock->isOverhangingFloat(floatingObject)) {
|
| floatingObject.setShouldPaint(true);
|
| @@ -3822,21 +3988,23 @@ void LayoutBlockFlow::setAncestorShouldPaintFloatingObject(
|
| }
|
|
|
| bool LayoutBlockFlow::allowsPaginationStrut() const {
|
| - // The block needs to be contained by a LayoutBlockFlow (and not by e.g. a flexbox, grid, or a
|
| - // table (the latter being the case for table cell or table caption)). The reason for this
|
| - // limitation is simply that LayoutBlockFlow child layout code is the only place where we pick
|
| - // up the struts and handle them. We handle floats and regular in-flow children, and that's
|
| - // all. We could handle this in other layout modes as well (and even for out-of-flow children),
|
| - // but currently we don't.
|
| + // The block needs to be contained by a LayoutBlockFlow (and not by e.g. a
|
| + // flexbox, grid, or a table (the latter being the case for table cell or
|
| + // table caption)). The reason for this limitation is simply that
|
| + // LayoutBlockFlow child layout code is the only place where we pick up the
|
| + // struts and handle them. We handle floats and regular in-flow children, and
|
| + // that's all. We could handle this in other layout modes as well (and even
|
| + // for out-of-flow children), but currently we don't.
|
| // TODO(mstensho): But we *should*.
|
| if (isOutOfFlowPositioned())
|
| return false;
|
| if (isLayoutFlowThread()) {
|
| // Don't let the strut escape the fragmentation context and get lost.
|
| - // TODO(mstensho): If we're in a nested fragmentation context, we should ideally convert
|
| - // and propagate the strut to the outer fragmentation context, so that the inner one is
|
| - // fully pushed to the next outer fragmentainer, instead of taking up unusable space in the
|
| - // previous one. But currently we have no mechanism in place to handle this.
|
| + // TODO(mstensho): If we're in a nested fragmentation context, we should
|
| + // ideally convert and propagate the strut to the outer fragmentation
|
| + // context, so that the inner one is fully pushed to the next outer
|
| + // fragmentainer, instead of taking up unusable space in the previous one.
|
| + // But currently we have no mechanism in place to handle this.
|
| return false;
|
| }
|
| LayoutBlock* containingBlock = this->containingBlock();
|
| @@ -3856,15 +4024,17 @@ void LayoutBlockFlow::setPaginationStrutPropagatedFromChild(LayoutUnit strut) {
|
| void LayoutBlockFlow::positionSpannerDescendant(
|
| LayoutMultiColumnSpannerPlaceholder& child) {
|
| LayoutBox& spanner = *child.layoutObjectInFlowThread();
|
| - // FIXME: |spanner| is a descendant, but never a direct child, so the names here are bad, if
|
| - // nothing else.
|
| + // FIXME: |spanner| is a descendant, but never a direct child, so the names
|
| + // here are bad, if nothing else.
|
| setLogicalTopForChild(spanner, child.logicalTop());
|
| determineLogicalLeftPositionForChild(spanner);
|
| }
|
|
|
| bool LayoutBlockFlow::avoidsFloats() const {
|
| - // Floats can't intrude into our box if we have a non-auto column count or width.
|
| - // Note: we need to use LayoutBox::avoidsFloats here since LayoutBlock::avoidsFloats is always true.
|
| + // Floats can't intrude into our box if we have a non-auto column count or
|
| + // width.
|
| + // Note: we need to use LayoutBox::avoidsFloats here since
|
| + // LayoutBlock::avoidsFloats is always true.
|
| return LayoutBox::avoidsFloats() || !style()->hasAutoColumnCount() ||
|
| !style()->hasAutoColumnWidth();
|
| }
|
| @@ -3946,18 +4116,20 @@ LayoutMultiColumnFlowThread* LayoutBlockFlow::createMultiColumnFlowThread(
|
|
|
| void LayoutBlockFlow::createOrDestroyMultiColumnFlowThreadIfNeeded(
|
| const ComputedStyle* oldStyle) {
|
| - // Paged overflow trumps multicol in this implementation. Ideally, it should be possible to have
|
| - // both paged overflow and multicol on the same element, but then we need two flow
|
| - // threads. Anyway, this is nothing to worry about until we can actually nest multicol properly
|
| - // inside other fragmentation contexts.
|
| + // Paged overflow trumps multicol in this implementation. Ideally, it should
|
| + // be possible to have both paged overflow and multicol on the same element,
|
| + // but then we need two flow threads. Anyway, this is nothing to worry about
|
| + // until we can actually nest multicol properly inside other fragmentation
|
| + // contexts.
|
| FlowThreadType type = getFlowThreadType(styleRef());
|
|
|
| if (multiColumnFlowThread()) {
|
| ASSERT(oldStyle);
|
| if (type != getFlowThreadType(*oldStyle)) {
|
| - // If we're no longer to be multicol/paged, destroy the flow thread. Also destroy it
|
| - // when switching between multicol and paged, since that affects the column set
|
| - // structure (multicol containers may have spanners, paged containers may not).
|
| + // If we're no longer to be multicol/paged, destroy the flow thread. Also
|
| + // destroy it when switching between multicol and paged, since that
|
| + // affects the column set structure (multicol containers may have
|
| + // spanners, paged containers may not).
|
| multiColumnFlowThread()->evacuateAndDestroy();
|
| ASSERT(!multiColumnFlowThread());
|
| }
|
| @@ -3966,19 +4138,22 @@ void LayoutBlockFlow::createOrDestroyMultiColumnFlowThreadIfNeeded(
|
| if (type == NoFlowThread || multiColumnFlowThread())
|
| return;
|
|
|
| - // Ruby elements manage child insertion in a special way, and would mess up insertion of the
|
| - // flow thread. The flow thread needs to be a direct child of the multicol block (|this|).
|
| + // Ruby elements manage child insertion in a special way, and would mess up
|
| + // insertion of the flow thread. The flow thread needs to be a direct child of
|
| + // the multicol block (|this|).
|
| if (isRuby())
|
| return;
|
|
|
| - // Form controls are replaced content, and are therefore not supposed to support multicol.
|
| + // Form controls are replaced content, and are therefore not supposed to
|
| + // support multicol.
|
| if (isFileUploadControl() || isTextControl() || isListBox())
|
| return;
|
|
|
| LayoutMultiColumnFlowThread* flowThread = createMultiColumnFlowThread(type);
|
| addChild(flowThread);
|
|
|
| - // Check that addChild() put the flow thread as a direct child, and didn't do fancy things.
|
| + // Check that addChild() put the flow thread as a direct child, and didn't do
|
| + // fancy things.
|
| ASSERT(flowThread->parent() == this);
|
|
|
| flowThread->populate();
|
| @@ -4046,7 +4221,8 @@ void LayoutBlockFlow::simplifiedNormalFlowInlineLayout() {
|
| }
|
| }
|
|
|
| - // FIXME: Glyph overflow will get lost in this case, but not really a big deal.
|
| + // FIXME: Glyph overflow will get lost in this case, but not really a big
|
| + // deal.
|
| GlyphOverflowAndFallbackFontsMap textBoxDataMap;
|
| for (ListHashSet<RootInlineBox*>::const_iterator it = lineBoxes.begin();
|
| it != lineBoxes.end(); ++it) {
|
| @@ -4070,7 +4246,8 @@ bool LayoutBlockFlow::recalcInlineChildrenOverflowAfterStyleChange() {
|
| }
|
| }
|
|
|
| - // FIXME: Glyph overflow will get lost in this case, but not really a big deal.
|
| + // FIXME: Glyph overflow will get lost in this case, but not really a big
|
| + // deal.
|
| GlyphOverflowAndFallbackFontsMap textBoxDataMap;
|
| for (ListHashSet<RootInlineBox*>::const_iterator it = lineBoxes.begin();
|
| it != lineBoxes.end(); ++it) {
|
| @@ -4104,7 +4281,8 @@ PositionWithAffinity LayoutBlockFlow::positionForPoint(
|
| bool linesAreFlipped = style()->isFlippedLinesWritingMode();
|
| bool blocksAreFlipped = style()->isFlippedBlocksWritingMode();
|
|
|
| - // look for the closest line box in the root box which is at the passed-in y coordinate
|
| + // look for the closest line box in the root box which is at the passed-in y
|
| + // coordinate
|
| InlineBox* closestBox = nullptr;
|
| RootInlineBox* firstRootBoxWithChildren = nullptr;
|
| RootInlineBox* lastRootBoxWithChildren = nullptr;
|
| @@ -4175,7 +4353,8 @@ PositionWithAffinity LayoutBlockFlow::positionForPoint(
|
| if (InlineBox* newBox = box->nextLeafChildIgnoringLineBreak())
|
| box = newBox;
|
| }
|
| - // y coordinate is above first root line box, so return the start of the first
|
| + // y coordinate is above first root line box, so return the start of the
|
| + // first
|
| return PositionWithAffinity(positionForBox(box, true));
|
| }
|
| }
|
| @@ -4192,7 +4371,8 @@ PositionWithAffinity LayoutBlockFlow::positionForPoint(
|
| }
|
|
|
| if (lastRootBoxWithChildren) {
|
| - // We hit this case for Mac behavior when the Y coordinate is below the last box.
|
| + // We hit this case for Mac behavior when the Y coordinate is below the last
|
| + // box.
|
| ASSERT(moveCaretToBoundary);
|
| InlineBox* logicallyLastBox;
|
| if (lastRootBoxWithChildren->getLogicalEndBoxWithNode(logicallyLastBox))
|
| @@ -4225,15 +4405,16 @@ void LayoutBlockFlow::addOutlineRects(
|
| Vector<LayoutRect>& rects,
|
| const LayoutPoint& additionalOffset,
|
| IncludeBlockVisualOverflowOrNot includeBlockOverflows) const {
|
| - // For blocks inside inlines, we go ahead and include margins so that we run right up to the
|
| - // inline boxes above and below us (thus getting merged with them to form a single irregular
|
| - // shape).
|
| + // For blocks inside inlines, we go ahead and include margins so that we run
|
| + // right up to the inline boxes above and below us (thus getting merged with
|
| + // them to form a single irregular shape).
|
| const LayoutInline* inlineElementContinuation =
|
| this->inlineElementContinuation();
|
| if (inlineElementContinuation) {
|
| // FIXME: This check really isn't accurate.
|
| bool nextInlineHasLineBox = inlineElementContinuation->firstLineBox();
|
| - // FIXME: This is wrong. The principal layoutObject may not be the continuation preceding this block.
|
| + // FIXME: This is wrong. The principal layoutObject may not be the
|
| + // continuation preceding this block.
|
| // FIXME: This is wrong for vertical writing-modes.
|
| // https://bugs.webkit.org/show_bug.cgi?id=46781
|
| bool prevInlineHasLineBox =
|
|
|
Chromium Code Reviews
Issue 2391893004:
Reformat comments in core/layout up until LayoutBox (Closed)
