Changeset 169110 in webkit

Timestamp:

May 20, 2014 7:34:56 AM (10 years ago)

Author:

stavila@adobe.com

Message:

[CSS Regions] Block incorrectly sized when containing an unsplittable box
​https://bugs.webkit.org/show_bug.cgi?id=132601

Reviewed by Antti Koivisto.

Source/WebCore:
When laying out elements in a region, when an inline element is encountered
the size of its parent must not be increased beyond the bottom of the current region,
unless if its the last region. This will ensure that the next sibling of the
inline element is correctly laid out at the top of the next region, instead
of leaving an empty space equal to the height of the overflow, as it did until now.

Tests: fast/regions/inline-block-inside-anonymous-overflow.html

fast/regions/inline-block-overflow.html

• rendering/RenderBlockFlow.cpp:

(WebCore::RenderBlockFlow::adjustLinePositionForPagination):
(WebCore::RenderBlockFlow::hasNextPage):

• rendering/RenderBlockFlow.h:
• rendering/RenderBlockLineLayout.cpp:

(WebCore::RenderBlockFlow::layoutRunsAndFloatsInRange):
(WebCore::RenderBlockFlow::linkToEndLineIfNeeded):
(WebCore::RenderBlockFlow::determineStartPosition):
(WebCore::RenderBlockFlow::checkPaginationAndFloatsAtEndLine):

LayoutTests:
Added tests for the layout of elements following inline-block elements
that overflow their region, with and without anonymous blocks.

• fast/regions/inline-block-inside-anonymous-overflow-expected.html: Added.
• fast/regions/inline-block-inside-anonymous-overflow.html: Added.
• fast/regions/inline-block-overflow-expected.html: Added.
• fast/regions/inline-block-overflow.html: Added.

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/fast/regions/inline-block-inside-anonymous-overflow-expected.html (added)
• LayoutTests/fast/regions/inline-block-inside-anonymous-overflow.html (added)
• LayoutTests/fast/regions/inline-block-overflow-expected.html (added)
• LayoutTests/fast/regions/inline-block-overflow.html (added)
• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/rendering/RenderBlockFlow.cpp (modified) (5 diffs)
• Source/WebCore/rendering/RenderBlockFlow.h (modified) (1 diff)
• Source/WebCore/rendering/RenderBlockLineLayout.cpp (modified) (5 diffs)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2014-05-20  Radu Stavila  <stavila@adobe.com>
+
+        [CSS Regions] Block incorrectly sized when containing an unsplittable box
+        https://bugs.webkit.org/show_bug.cgi?id=132601
+
+        Reviewed by Antti Koivisto.
+
+        Added tests for the layout of elements following inline-block elements 
+        that overflow their region, with and without anonymous blocks.
+
+        * fast/regions/inline-block-inside-anonymous-overflow-expected.html: Added.
+        * fast/regions/inline-block-inside-anonymous-overflow.html: Added.
+        * fast/regions/inline-block-overflow-expected.html: Added.
+        * fast/regions/inline-block-overflow.html: Added.
+
 2014-05-20  Zoltan Horvath  <zoltan@webkit.org>
 

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2014-05-20  Radu Stavila  <stavila@adobe.com>
+
+        [CSS Regions] Block incorrectly sized when containing an unsplittable box
+        https://bugs.webkit.org/show_bug.cgi?id=132601
+
+        Reviewed by Antti Koivisto.
+
+        When laying out elements in a region, when an inline element is encountered
+        the size of its parent must not be increased beyond the bottom of the current region,
+        unless if its the last region. This will ensure that the next sibling of the
+        inline element is correctly laid out at the top of the next region, instead
+        of leaving an empty space equal to the height of the overflow, as it did until now.
+
+        Tests: fast/regions/inline-block-inside-anonymous-overflow.html
+               fast/regions/inline-block-overflow.html
+
+        * rendering/RenderBlockFlow.cpp:
+        (WebCore::RenderBlockFlow::adjustLinePositionForPagination):
+        (WebCore::RenderBlockFlow::hasNextPage):
+        * rendering/RenderBlockFlow.h:
+        * rendering/RenderBlockLineLayout.cpp:
+        (WebCore::RenderBlockFlow::layoutRunsAndFloatsInRange):
+        (WebCore::RenderBlockFlow::linkToEndLineIfNeeded):
+        (WebCore::RenderBlockFlow::determineStartPosition):
+        (WebCore::RenderBlockFlow::checkPaginationAndFloatsAtEndLine):
+
 2014-05-20  Mihnea Ovidenie  <mihnea@adobe.com>
 

trunk/Source/WebCore/rendering/RenderBlockFlow.cpp

@@ -1621 +1621 @@
 }
 
-void RenderBlockFlow::adjustLinePositionForPagination(RootInlineBox* lineBox, LayoutUnit& delta, RenderFlowThread* flowThread)
+void RenderBlockFlow::adjustLinePositionForPagination(RootInlineBox* lineBox, LayoutUnit& delta, bool& overflowsRegion, RenderFlowThread* flowThread)
 {
     // FIXME: For now we paginate using line overflow. This ensures that lines don't overlap at all when we
@@ -1642 +1642 @@
     // 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.
+    overflowsRegion = false;
     LayoutRect logicalVisualOverflow = lineBox->logicalVisualOverflowRect(lineBox->lineTop(), lineBox->lineBottom());
     LayoutUnit logicalOffset = std::min(lineBox->lineTopWithLeading(), logicalVisualOverflow.y());
@@ -1660 +1661 @@
         return;
     LayoutUnit remainingLogicalHeight = pageRemainingLogicalHeightForOffset(logicalOffset, ExcludePageBoundary);
+    overflowsRegion = (lineHeight > remainingLogicalHeight);
 
     int lineIndex = lineCount(lineBox);
@@ -1674 +1676 @@
             remainingLogicalHeight -= std::min(lineHeight - pageLogicalHeight, std::max<LayoutUnit>(0, logicalVisualOverflow.y() - lineBox->lineTopWithLeading()));
         }
+        LayoutUnit remainingLogicalHeightAtNewOffset = pageRemainingLogicalHeightForOffset(logicalOffset + remainingLogicalHeight, ExcludePageBoundary);
+        overflowsRegion = (lineHeight > remainingLogicalHeightAtNewOffset);
         LayoutUnit totalLogicalHeight = lineHeight + std::max<LayoutUnit>(0, logicalOffset);
         LayoutUnit pageLogicalHeightAtNewOffset = hasUniformPageLogicalHeight ? pageLogicalHeight : pageLogicalHeightForOffset(logicalOffset + remainingLogicalHeight);
@@ -1759 +1763 @@
     RenderRegion* endRegion = nullptr;
     flowThread->getRegionRangeForBox(this, startRegion, endRegion);
-    return region != endRegion;
+    return (endRegion && region != endRegion);
 }
 

trunk/Source/WebCore/rendering/RenderBlockFlow.h

@@ -591 +591 @@
 public:
     // FIXME-BLOCKFLOW: These can be made protected again once all callers have been moved here.
-    void adjustLinePositionForPagination(RootInlineBox*, LayoutUnit& deltaOffset, RenderFlowThread*); // Computes a deltaOffset value that put a line at the top of the next page if it doesn't fit on the current page.
+    void adjustLinePositionForPagination(RootInlineBox*, LayoutUnit& deltaOffset, bool& overflowsRegion, RenderFlowThread*); // Computes a deltaOffset value that put a line at the top of the next page if it doesn't fit on the current page.
     void updateRegionForLine(RootInlineBox*) const;
     void createRenderNamedFlowFragmentIfNeeded();

trunk/Source/WebCore/rendering/RenderBlockLineLayout.cpp

@@ -1135 +1135 @@
                 if (paginated) {
                     LayoutUnit adjustment = 0;
-                    adjustLinePositionForPagination(lineBox, adjustment, layoutState.flowThread());
+                    bool overflowsRegion;
+                    adjustLinePositionForPagination(lineBox, adjustment, overflowsRegion, layoutState.flowThread());
                     if (adjustment) {
                         LayoutUnit oldLineWidth = availableLogicalWidthForLine(oldLogicalHeight, layoutState.lineInfo().isFirstLine());
@@ -1150 +1151 @@
 
                         setLogicalHeight(lineBox->lineBottomWithLeading());
+                    }
+                    
+                    if (RenderFlowThread* flowThread = flowThreadContainingBlock()) {
+                        if (flowThread->isRenderNamedFlowThread() && overflowsRegion && hasNextPage(lineBox->lineTop())) {
+                            // Limit the height of this block to the end of the current region because
+                            // it is also fragmented into the next region.
+                            LayoutUnit remainingLogicalHeight = pageRemainingLogicalHeightForOffset(logicalTop(), ExcludePageBoundary);
+                            if (logicalHeight() > remainingLogicalHeight)
+                                setLogicalHeight(remainingLogicalHeight);
+                        }
                     }
 
@@ -1266 +1277 @@
                 if (paginated) {
                     delta -= line->paginationStrut();
-                    adjustLinePositionForPagination(line, delta, layoutState.flowThread());
+                    bool overflowsRegion;
+                    adjustLinePositionForPagination(line, delta, overflowsRegion, layoutState.flowThread());
                 }
                 if (delta) {
@@ -1506 +1518 @@
                 }
                 paginationDelta -= curr->paginationStrut();
-                adjustLinePositionForPagination(curr, paginationDelta, layoutState.flowThread());
+                bool overflowsRegion;
+                adjustLinePositionForPagination(curr, paginationDelta, overflowsRegion, layoutState.flowThread());
                 if (paginationDelta) {
                     if (containsFloats() || !layoutState.floats().isEmpty()) {
@@ -1654 +1667 @@
                 // strut yet.
                 LayoutUnit oldPaginationStrut = lineBox->paginationStrut();
+                bool overflowsRegion;
                 lineDelta -= oldPaginationStrut;
-                adjustLinePositionForPagination(lineBox, lineDelta, layoutState.flowThread());
+                adjustLinePositionForPagination(lineBox, lineDelta, overflowsRegion, layoutState.flowThread());
                 lineBox->setPaginationStrut(oldPaginationStrut);
             }