<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[168380] trunk</title>
</head>
<body>
<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; }
#msg dl a { font-weight: bold}
#msg dl a:link { color:#fc3; }
#msg dl a:active { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/168380">168380</a></dd>
<dt>Author</dt> <dd>hyatt@apple.com</dd>
<dt>Date</dt> <dd>2014-05-06 14:35:52 -0700 (Tue, 06 May 2014)</dd>
</dl>
<h3>Log Message</h3>
<pre>Begin Removal of Old Multi-Column Code.
https://bugs.webkit.org/show_bug.cgi?id=132480
Reviewed by Andreas Kling.
Source/WebCore:
* dom/Document.cpp:
(WebCore::Document::regionBasedColumnsEnabled): Deleted.
* dom/Document.h:
* page/FrameView.cpp:
(WebCore::updateLayerPositionFlags):
* page/Settings.in:
* rendering/LayoutState.cpp:
(WebCore::LayoutState::LayoutState):
(WebCore::LayoutState::clearPaginationInformation):
(WebCore::LayoutState::addForcedColumnBreak): Deleted.
* rendering/LayoutState.h:
(WebCore::LayoutState::LayoutState):
(WebCore::LayoutState::isPaginatingColumns): Deleted.
* rendering/RenderBlock.cpp:
(WebCore::RenderBlock::~RenderBlock):
(WebCore::RenderBlock::addChildToContinuation):
(WebCore::RenderBlock::addChild):
(WebCore::RenderBlock::addChildIgnoringContinuation):
(WebCore::RenderBlock::removeLeftoverAnonymousBlock):
(WebCore::canMergeContiguousAnonymousBlocks):
(WebCore::RenderBlock::removeChild):
(WebCore::RenderBlock::recomputeLogicalWidth):
(WebCore::RenderBlock::addOverflowFromChildren):
(WebCore::RenderBlock::expandsToEncloseOverhangingFloats):
(WebCore::RenderBlock::simplifiedLayout):
(WebCore::RenderBlock::layoutPositionedObjects):
(WebCore::RenderBlock::paintObject):
(WebCore::RenderBlock::selectionGaps):
(WebCore::RenderBlock::nodeAtPoint):
(WebCore::RenderBlock::offsetForContents):
(WebCore::RenderBlock::computeIntrinsicLogicalWidths):
(WebCore::RenderBlock::createAnonymousBoxWithSameTypeAs):
(WebCore::RenderBlock::childBoxIsUnsplittableForFragmentation):
(WebCore::RenderBlock::renderName):
(WebCore::RenderBlock::addChildToAnonymousColumnBlocks): Deleted.
(WebCore::RenderBlock::containingColumnsBlock): Deleted.
(WebCore::RenderBlock::splitFlow): Deleted.
(WebCore::RenderBlock::makeChildrenAnonymousColumnBlocks): Deleted.
(WebCore::RenderBlock::columnsBlockForSpanningElement): Deleted.
(WebCore::RenderBlock::addChildIgnoringAnonymousColumnBlocks): Deleted.
(WebCore::RenderBlock::updateLogicalWidthAndColumnWidth): Deleted.
(WebCore::RenderBlock::isTopLayoutOverflowAllowed): Deleted.
(WebCore::RenderBlock::isLeftLayoutOverflowAllowed): Deleted.
(WebCore::RenderBlock::paintColumnRules): Deleted.
(WebCore::RenderBlock::initialBlockOffsetForPainting): Deleted.
(WebCore::RenderBlock::blockDeltaForPaintingNextColumn): Deleted.
(WebCore::RenderBlock::paintColumnContents): Deleted.
(WebCore::ColumnRectIterator::ColumnRectIterator): Deleted.
(WebCore::ColumnRectIterator::advance): Deleted.
(WebCore::ColumnRectIterator::columnRect): Deleted.
(WebCore::ColumnRectIterator::hasMore): Deleted.
(WebCore::ColumnRectIterator::adjust): Deleted.
(WebCore::ColumnRectIterator::update): Deleted.
(WebCore::RenderBlock::hitTestColumns): Deleted.
(WebCore::RenderBlock::adjustForColumnRect): Deleted.
(WebCore::RenderBlock::availableLogicalWidth): Deleted.
(WebCore::RenderBlock::columnGap): Deleted.
(WebCore::RenderBlock::computeColumnCountAndWidth): Deleted.
(WebCore::RenderBlock::requiresColumns): Deleted.
(WebCore::RenderBlock::setComputedColumnCountAndWidth): Deleted.
(WebCore::RenderBlock::updateColumnProgressionFromStyle): Deleted.
(WebCore::RenderBlock::computedColumnWidth): Deleted.
(WebCore::RenderBlock::computedColumnCount): Deleted.
(WebCore::RenderBlock::columnInfo): Deleted.
(WebCore::RenderBlock::columnCount): Deleted.
(WebCore::RenderBlock::columnRectAt): Deleted.
(WebCore::RenderBlock::adjustPointToColumnContents): Deleted.
(WebCore::RenderBlock::adjustRectForColumns): Deleted.
(WebCore::RenderBlock::flipForWritingModeIncludingColumns): Deleted.
(WebCore::RenderBlock::adjustStartEdgeForWritingModeIncludingColumns): Deleted.
(WebCore::RenderBlock::adjustForColumns): Deleted.
(WebCore::RenderBlock::adjustIntrinsicLogicalWidthsForColumns): Deleted.
(WebCore::RenderBlock::paginationUnit): Deleted.
(WebCore::RenderBlock::createAnonymousColumnsWithParentRenderer): Deleted.
(WebCore::RenderBlock::createAnonymousColumnSpanWithParentRenderer): Deleted.
(WebCore::RenderBlock::computeLineGridPaginationOrigin): Deleted.
* rendering/RenderBlock.h:
(WebCore::RenderBlock::pixelSnappedLogicalRightOffsetForLine):
(WebCore::RenderBlock::createAnonymousBlock):
(WebCore::RenderBlock::paintColumnRules):
(WebCore::RenderBlock::createAnonymousColumnsBlock): Deleted.
(WebCore::RenderBlock::createAnonymousColumnSpanBlock): Deleted.
* rendering/RenderBlockFlow.cpp:
(WebCore::RenderBlockFlow::adjustIntrinsicLogicalWidthsForColumns):
(WebCore::RenderBlockFlow::computeIntrinsicLogicalWidths):
(WebCore::RenderBlockFlow::recomputeLogicalWidthAndColumnWidth):
(WebCore::RenderBlockFlow::columnGap):
(WebCore::RenderBlockFlow::computeColumnCountAndWidth):
(WebCore::RenderBlockFlow::layoutBlock):
(WebCore::inNormalFlow):
(WebCore::RenderBlockFlow::applyBeforeBreak):
(WebCore::RenderBlockFlow::applyAfterBreak):
(WebCore::RenderBlockFlow::updateMinimumPageHeight):
(WebCore::RenderBlockFlow::computeOverflow):
(WebCore::RenderBlockFlow::addOverhangingFloats):
(WebCore::RenderBlockFlow::hasOverhangingFloat):
(WebCore::RenderBlockFlow::relayoutForPagination):
(WebCore::RenderBlockFlow::checkForPaginationLogicalHeightChange):
(WebCore::RenderBlockFlow::requiresColumns):
(WebCore::RenderBlockFlow::setComputedColumnCountAndWidth):
(WebCore::RenderBlockFlow::updateColumnProgressionFromStyle):
(WebCore::RenderBlockFlow::computedColumnWidth):
(WebCore::RenderBlockFlow::computedColumnCount):
* rendering/RenderBlockFlow.h:
(WebCore::RenderBlockFlow::hasOverhangingFloats):
* rendering/RenderBox.cpp:
(WebCore::RenderBox::styleDidChange):
(WebCore::RenderBox::offsetFromContainer):
(WebCore::RenderBox::computeRectForRepaint):
(WebCore::RenderBox::layoutOverflowRectForPropagation):
* rendering/RenderBox.h:
* rendering/RenderBoxModelObject.cpp:
(WebCore::RenderBoxModelObject::adjustedPositionRelativeToOffsetParent):
(WebCore::RenderBoxModelObject::mapAbsoluteToLocalPoint):
* rendering/RenderBoxModelObject.h:
(WebCore::RenderBoxModelObject::canHaveBoxInfoInRegion):
* rendering/RenderFlexibleBox.cpp:
(WebCore::RenderFlexibleBox::layoutBlock):
* rendering/RenderFlowThread.h:
* rendering/RenderGeometryMap.cpp:
(WebCore::canMapBetweenRenderers):
* rendering/RenderInline.cpp:
(WebCore::RenderInline::clippedOverflowRectForRepaint):
(WebCore::RenderInline::computeRectForRepaint):
(WebCore::RenderInline::offsetFromContainer):
(WebCore::RenderInline::mapLocalToContainer):
* rendering/RenderLayer.cpp:
(WebCore::RenderLayer::RenderLayer):
(WebCore::RenderLayer::updateLayerPositions):
(WebCore::RenderLayer::updatePagination):
(WebCore::accumulateOffsetTowardsAncestor):
(WebCore::RenderLayer::paintList):
(WebCore::RenderLayer::hitTestList):
(WebCore::checkContainingBlockChainForPagination): Deleted.
(WebCore::RenderLayer::useRegionBasedColumns): Deleted.
(WebCore::RenderLayer::paintPaginatedChildLayer): Deleted.
(WebCore::RenderLayer::paintChildLayerIntoColumns): Deleted.
(WebCore::RenderLayer::hitTestPaginatedChildLayer): Deleted.
(WebCore::RenderLayer::hitTestChildLayerColumns): Deleted.
* rendering/RenderLayer.h:
* rendering/RenderMultiColumnFlowThread.cpp:
(WebCore::RenderMultiColumnFlowThread::shouldCheckColumnBreaks):
* rendering/RenderMultiColumnFlowThread.h:
* rendering/RenderObject.cpp:
(WebCore::RenderObject::computeRectForRepaint):
(WebCore::RenderObject::mapLocalToContainer):
(WebCore::RenderObject::pushMappingToContainer):
(WebCore::RenderObject::offsetFromContainer):
* rendering/RenderObject.h:
(WebCore::RenderObject::isAnonymousBlock):
(WebCore::RenderObject::RenderObjectBitfields::RenderObjectBitfields):
(WebCore::RenderObject::hasColumns): Deleted.
(WebCore::RenderObject::setHasColumns): Deleted.
(WebCore::RenderObject::isAnonymousColumnsBlock): Deleted.
(WebCore::RenderObject::isAnonymousColumnSpanBlock): Deleted.
(WebCore::RenderObject::adjustForColumns): Deleted.
(WebCore::RenderObject::offsetForColumns): Deleted.
* rendering/RenderText.cpp:
(WebCore::RenderText::selectionRectForRepaint):
* rendering/RenderView.cpp:
(WebCore::RenderView::availableLogicalHeight):
(WebCore::RenderView::pageOrViewLogicalHeight):
(WebCore::RenderView::unextendedBackgroundRect):
(WebCore::RenderView::backgroundRect):
(WebCore::RenderView::shouldDisableLayoutStateForSubtree):
(WebCore::RenderView::pageNumberForBlockProgressionOffset):
(WebCore::RenderView::pageCount):
(WebCore::RenderView::paginationUnit): Deleted.
* rendering/RenderView.h:
(WebCore::LayoutStateMaintainer::LayoutStateMaintainer):
(WebCore::LayoutStateMaintainer::push):
* rendering/SimpleLineLayout.cpp:
(WebCore::SimpleLineLayout::canUseFor):
* rendering/svg/RenderSVGText.cpp:
(WebCore::RenderSVGText::layout):
* style/StyleResolveForDocument.cpp:
(WebCore::Style::resolveForDocument):
LayoutTests:
* platform/mac/fast/multicol/client-rects-expected.png:
* platform/mac/fast/multicol/client-rects-expected.txt:
* platform/mac/fast/multicol/client-rects-spanners-complex-expected.png:
* platform/mac/fast/multicol/client-rects-spanners-complex-expected.txt:
* platform/mac/fast/multicol/client-rects-spanners-expected.png:
* platform/mac/fast/multicol/client-rects-spanners-expected.txt:
* platform/mac/fast/multicol/newmulticol/client-rects-expected.png:
* platform/mac/fast/multicol/newmulticol/client-rects-expected.txt:</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkLayoutTestsChangeLog">trunk/LayoutTests/ChangeLog</a></li>
<li><a href="#trunkLayoutTestsplatformmacfastmulticolclientrectsexpectedpng">trunk/LayoutTests/platform/mac/fast/multicol/client-rects-expected.png</a></li>
<li><a href="#trunkLayoutTestsplatformmacfastmulticolclientrectsexpectedtxt">trunk/LayoutTests/platform/mac/fast/multicol/client-rects-expected.txt</a></li>
<li><a href="#trunkLayoutTestsplatformmacfastmulticolclientrectsspannerscomplexexpectedpng">trunk/LayoutTests/platform/mac/fast/multicol/client-rects-spanners-complex-expected.png</a></li>
<li><a href="#trunkLayoutTestsplatformmacfastmulticolclientrectsspannerscomplexexpectedtxt">trunk/LayoutTests/platform/mac/fast/multicol/client-rects-spanners-complex-expected.txt</a></li>
<li><a href="#trunkLayoutTestsplatformmacfastmulticolclientrectsspannersexpectedpng">trunk/LayoutTests/platform/mac/fast/multicol/client-rects-spanners-expected.png</a></li>
<li><a href="#trunkLayoutTestsplatformmacfastmulticolclientrectsspannersexpectedtxt">trunk/LayoutTests/platform/mac/fast/multicol/client-rects-spanners-expected.txt</a></li>
<li><a href="#trunkLayoutTestsplatformmacfastmulticolnewmulticolclientrectsexpectedpng">trunk/LayoutTests/platform/mac/fast/multicol/newmulticol/client-rects-expected.png</a></li>
<li><a href="#trunkLayoutTestsplatformmacfastmulticolnewmulticolclientrectsexpectedtxt">trunk/LayoutTests/platform/mac/fast/multicol/newmulticol/client-rects-expected.txt</a></li>
<li><a href="#trunkSourceWebCoreChangeLog">trunk/Source/WebCore/ChangeLog</a></li>
<li><a href="#trunkSourceWebCoredomDocumentcpp">trunk/Source/WebCore/dom/Document.cpp</a></li>
<li><a href="#trunkSourceWebCoredomDocumenth">trunk/Source/WebCore/dom/Document.h</a></li>
<li><a href="#trunkSourceWebCorepageFrameViewcpp">trunk/Source/WebCore/page/FrameView.cpp</a></li>
<li><a href="#trunkSourceWebCorepageSettingsin">trunk/Source/WebCore/page/Settings.in</a></li>
<li><a href="#trunkSourceWebCorerenderingLayoutStatecpp">trunk/Source/WebCore/rendering/LayoutState.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingLayoutStateh">trunk/Source/WebCore/rendering/LayoutState.h</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderBlockcpp">trunk/Source/WebCore/rendering/RenderBlock.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderBlockh">trunk/Source/WebCore/rendering/RenderBlock.h</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderBlockFlowcpp">trunk/Source/WebCore/rendering/RenderBlockFlow.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderBlockFlowh">trunk/Source/WebCore/rendering/RenderBlockFlow.h</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderBoxcpp">trunk/Source/WebCore/rendering/RenderBox.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderBoxh">trunk/Source/WebCore/rendering/RenderBox.h</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderBoxModelObjectcpp">trunk/Source/WebCore/rendering/RenderBoxModelObject.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderBoxModelObjecth">trunk/Source/WebCore/rendering/RenderBoxModelObject.h</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderFlexibleBoxcpp">trunk/Source/WebCore/rendering/RenderFlexibleBox.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderFlowThreadh">trunk/Source/WebCore/rendering/RenderFlowThread.h</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderGeometryMapcpp">trunk/Source/WebCore/rendering/RenderGeometryMap.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderInlinecpp">trunk/Source/WebCore/rendering/RenderInline.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderLayercpp">trunk/Source/WebCore/rendering/RenderLayer.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderLayerh">trunk/Source/WebCore/rendering/RenderLayer.h</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderMultiColumnFlowThreadcpp">trunk/Source/WebCore/rendering/RenderMultiColumnFlowThread.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderMultiColumnFlowThreadh">trunk/Source/WebCore/rendering/RenderMultiColumnFlowThread.h</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderObjectcpp">trunk/Source/WebCore/rendering/RenderObject.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderObjecth">trunk/Source/WebCore/rendering/RenderObject.h</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderTextcpp">trunk/Source/WebCore/rendering/RenderText.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderViewcpp">trunk/Source/WebCore/rendering/RenderView.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderViewh">trunk/Source/WebCore/rendering/RenderView.h</a></li>
<li><a href="#trunkSourceWebCorerenderingSimpleLineLayoutcpp">trunk/Source/WebCore/rendering/SimpleLineLayout.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingsvgRenderSVGTextcpp">trunk/Source/WebCore/rendering/svg/RenderSVGText.cpp</a></li>
<li><a href="#trunkSourceWebCorestyleStyleResolveForDocumentcpp">trunk/Source/WebCore/style/StyleResolveForDocument.cpp</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkLayoutTestsChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/ChangeLog (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/ChangeLog 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/LayoutTests/ChangeLog 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -1,3 +1,19 @@
</span><ins>+2014-05-06 David Hyatt <hyatt@apple.com>
+
+ Begin Removal of Old Multi-Column Code.
+ https://bugs.webkit.org/show_bug.cgi?id=132480
+
+ Reviewed by Andreas Kling.
+
+ * platform/mac/fast/multicol/client-rects-expected.png:
+ * platform/mac/fast/multicol/client-rects-expected.txt:
+ * platform/mac/fast/multicol/client-rects-spanners-complex-expected.png:
+ * platform/mac/fast/multicol/client-rects-spanners-complex-expected.txt:
+ * platform/mac/fast/multicol/client-rects-spanners-expected.png:
+ * platform/mac/fast/multicol/client-rects-spanners-expected.txt:
+ * platform/mac/fast/multicol/newmulticol/client-rects-expected.png:
+ * platform/mac/fast/multicol/newmulticol/client-rects-expected.txt:
+
</ins><span class="cx"> 2014-05-06 Eric Carlson <eric.carlson@apple.com>
</span><span class="cx">
</span><span class="cx"> [Mac] make metadata cue attributes consistent
</span></span></pre></div>
<a id="trunkLayoutTestsplatformmacfastmulticolclientrectsexpectedpng"></a>
<div class="binary"><h4>Modified: trunk/LayoutTests/platform/mac/fast/multicol/client-rects-expected.png</h4>
<pre class="diff"><span>
<span class="cx">(Binary files differ)
</span></span></pre></div>
<a id="trunkLayoutTestsplatformmacfastmulticolclientrectsexpectedtxt"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/platform/mac/fast/multicol/client-rects-expected.txt (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/platform/mac/fast/multicol/client-rects-expected.txt 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/LayoutTests/platform/mac/fast/multicol/client-rects-expected.txt 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -345,12 +345,12 @@
</span><span class="cx"> RenderBlock (positioned) {DIV} at (51,323) size 25x26 [border: (3px solid #0000FF7F)]
</span><span class="cx"> layer at (26,323) size 25x26
</span><span class="cx"> RenderBlock (positioned) {DIV} at (26,323) size 25x26 [border: (3px solid #0000FF7F)]
</span><del>-layer at (115,271) size 25x25
- RenderBlock (positioned) {DIV} at (115,271) size 25x25 [border: (3px solid #0000FF7F)]
-layer at (140,323) size 25x26
- RenderBlock (positioned) {DIV} at (140,323) size 25x26 [border: (3px solid #0000FF7F)]
-layer at (115,323) size 25x26
- RenderBlock (positioned) {DIV} at (115,323) size 25x26 [border: (3px solid #0000FF7F)]
</del><ins>+layer at (116,271) size 25x25
+ RenderBlock (positioned) {DIV} at (116,271) size 25x25 [border: (3px solid #0000FF7F)]
+layer at (141,323) size 25x26
+ RenderBlock (positioned) {DIV} at (141,323) size 25x26 [border: (3px solid #0000FF7F)]
+layer at (116,323) size 25x26
+ RenderBlock (positioned) {DIV} at (116,323) size 25x26 [border: (3px solid #0000FF7F)]
</ins><span class="cx"> layer at (206,271) size 25x25
</span><span class="cx"> RenderBlock (positioned) {DIV} at (206,271) size 25x25 [border: (3px solid #0000FF7F)]
</span><span class="cx"> layer at (231,323) size 25x26
</span></span></pre></div>
<a id="trunkLayoutTestsplatformmacfastmulticolclientrectsspannerscomplexexpectedpng"></a>
<div class="binary"><h4>Modified: trunk/LayoutTests/platform/mac/fast/multicol/client-rects-spanners-complex-expected.png</h4>
<pre class="diff"><span>
<span class="cx">(Binary files differ)
</span></span></pre></div>
<a id="trunkLayoutTestsplatformmacfastmulticolclientrectsspannerscomplexexpectedtxt"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/platform/mac/fast/multicol/client-rects-spanners-complex-expected.txt (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/platform/mac/fast/multicol/client-rects-spanners-complex-expected.txt 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/LayoutTests/platform/mac/fast/multicol/client-rects-spanners-complex-expected.txt 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -434,12 +434,12 @@
</span><span class="cx"> RenderBlock (positioned) {DIV} at (316,387) size 25x26 [border: (3px solid #0000FF7F)]
</span><span class="cx"> layer at (291,387) size 25x26
</span><span class="cx"> RenderBlock (positioned) {DIV} at (291,387) size 25x26 [border: (3px solid #0000FF7F)]
</span><del>-layer at (420,335) size 25x25
- RenderBlock (positioned) {DIV} at (420,335) size 25x25 [border: (3px solid #0000FF7F)]
-layer at (445,387) size 25x26
- RenderBlock (positioned) {DIV} at (445,387) size 25x26 [border: (3px solid #0000FF7F)]
-layer at (420,387) size 25x26
- RenderBlock (positioned) {DIV} at (420,387) size 25x26 [border: (3px solid #0000FF7F)]
</del><ins>+layer at (421,335) size 25x25
+ RenderBlock (positioned) {DIV} at (421,335) size 25x25 [border: (3px solid #0000FF7F)]
+layer at (446,387) size 25x26
+ RenderBlock (positioned) {DIV} at (446,387) size 25x26 [border: (3px solid #0000FF7F)]
+layer at (421,387) size 25x26
+ RenderBlock (positioned) {DIV} at (421,387) size 25x26 [border: (3px solid #0000FF7F)]
</ins><span class="cx"> layer at (551,335) size 25x25
</span><span class="cx"> RenderBlock (positioned) {DIV} at (551,335) size 25x25 [border: (3px solid #0000FF7F)]
</span><span class="cx"> layer at (576,387) size 25x26
</span></span></pre></div>
<a id="trunkLayoutTestsplatformmacfastmulticolclientrectsspannersexpectedpng"></a>
<div class="binary"><h4>Modified: trunk/LayoutTests/platform/mac/fast/multicol/client-rects-spanners-expected.png</h4>
<pre class="diff"><span>
<span class="cx">(Binary files differ)
</span></span></pre></div>
<a id="trunkLayoutTestsplatformmacfastmulticolclientrectsspannersexpectedtxt"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/platform/mac/fast/multicol/client-rects-spanners-expected.txt (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/platform/mac/fast/multicol/client-rects-spanners-expected.txt 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/LayoutTests/platform/mac/fast/multicol/client-rects-spanners-expected.txt 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -394,12 +394,12 @@
</span><span class="cx"> RenderBlock (positioned) {DIV} at (151,333) size 25x26 [border: (3px solid #0000FF7F)]
</span><span class="cx"> layer at (126,333) size 25x26
</span><span class="cx"> RenderBlock (positioned) {DIV} at (126,333) size 25x26 [border: (3px solid #0000FF7F)]
</span><del>-layer at (225,281) size 25x25
- RenderBlock (positioned) {DIV} at (225,281) size 25x25 [border: (3px solid #0000FF7F)]
-layer at (250,333) size 25x26
- RenderBlock (positioned) {DIV} at (250,333) size 25x26 [border: (3px solid #0000FF7F)]
-layer at (225,333) size 25x26
- RenderBlock (positioned) {DIV} at (225,333) size 25x26 [border: (3px solid #0000FF7F)]
</del><ins>+layer at (226,281) size 25x25
+ RenderBlock (positioned) {DIV} at (226,281) size 25x25 [border: (3px solid #0000FF7F)]
+layer at (251,333) size 25x26
+ RenderBlock (positioned) {DIV} at (251,333) size 25x26 [border: (3px solid #0000FF7F)]
+layer at (226,333) size 25x26
+ RenderBlock (positioned) {DIV} at (226,333) size 25x26 [border: (3px solid #0000FF7F)]
</ins><span class="cx"> layer at (326,281) size 25x25
</span><span class="cx"> RenderBlock (positioned) {DIV} at (326,281) size 25x25 [border: (3px solid #0000FF7F)]
</span><span class="cx"> layer at (351,333) size 25x26
</span></span></pre></div>
<a id="trunkLayoutTestsplatformmacfastmulticolnewmulticolclientrectsexpectedpng"></a>
<div class="binary"><h4>Modified: trunk/LayoutTests/platform/mac/fast/multicol/newmulticol/client-rects-expected.png</h4>
<pre class="diff"><span>
<span class="cx">(Binary files differ)
</span></span></pre></div>
<a id="trunkLayoutTestsplatformmacfastmulticolnewmulticolclientrectsexpectedtxt"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/platform/mac/fast/multicol/newmulticol/client-rects-expected.txt (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/platform/mac/fast/multicol/newmulticol/client-rects-expected.txt 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/LayoutTests/platform/mac/fast/multicol/newmulticol/client-rects-expected.txt 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -345,12 +345,12 @@
</span><span class="cx"> RenderBlock (positioned) {DIV} at (51,323) size 25x26 [border: (3px solid #0000FF7F)]
</span><span class="cx"> layer at (26,323) size 25x26
</span><span class="cx"> RenderBlock (positioned) {DIV} at (26,323) size 25x26 [border: (3px solid #0000FF7F)]
</span><del>-layer at (115,271) size 25x25
- RenderBlock (positioned) {DIV} at (115,271) size 25x25 [border: (3px solid #0000FF7F)]
-layer at (140,323) size 25x26
- RenderBlock (positioned) {DIV} at (140,323) size 25x26 [border: (3px solid #0000FF7F)]
-layer at (115,323) size 25x26
- RenderBlock (positioned) {DIV} at (115,323) size 25x26 [border: (3px solid #0000FF7F)]
</del><ins>+layer at (116,271) size 25x25
+ RenderBlock (positioned) {DIV} at (116,271) size 25x25 [border: (3px solid #0000FF7F)]
+layer at (141,323) size 25x26
+ RenderBlock (positioned) {DIV} at (141,323) size 25x26 [border: (3px solid #0000FF7F)]
+layer at (116,323) size 25x26
+ RenderBlock (positioned) {DIV} at (116,323) size 25x26 [border: (3px solid #0000FF7F)]
</ins><span class="cx"> layer at (206,271) size 25x25
</span><span class="cx"> RenderBlock (positioned) {DIV} at (206,271) size 25x25 [border: (3px solid #0000FF7F)]
</span><span class="cx"> layer at (231,323) size 25x26
</span></span></pre></div>
<a id="trunkSourceWebCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/ChangeLog (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/ChangeLog 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/Source/WebCore/ChangeLog 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -1,3 +1,188 @@
</span><ins>+2014-05-06 David Hyatt <hyatt@apple.com>
+
+ Begin Removal of Old Multi-Column Code.
+ https://bugs.webkit.org/show_bug.cgi?id=132480
+
+ Reviewed by Andreas Kling.
+
+ * dom/Document.cpp:
+ (WebCore::Document::regionBasedColumnsEnabled): Deleted.
+ * dom/Document.h:
+ * page/FrameView.cpp:
+ (WebCore::updateLayerPositionFlags):
+ * page/Settings.in:
+ * rendering/LayoutState.cpp:
+ (WebCore::LayoutState::LayoutState):
+ (WebCore::LayoutState::clearPaginationInformation):
+ (WebCore::LayoutState::addForcedColumnBreak): Deleted.
+ * rendering/LayoutState.h:
+ (WebCore::LayoutState::LayoutState):
+ (WebCore::LayoutState::isPaginatingColumns): Deleted.
+ * rendering/RenderBlock.cpp:
+ (WebCore::RenderBlock::~RenderBlock):
+ (WebCore::RenderBlock::addChildToContinuation):
+ (WebCore::RenderBlock::addChild):
+ (WebCore::RenderBlock::addChildIgnoringContinuation):
+ (WebCore::RenderBlock::removeLeftoverAnonymousBlock):
+ (WebCore::canMergeContiguousAnonymousBlocks):
+ (WebCore::RenderBlock::removeChild):
+ (WebCore::RenderBlock::recomputeLogicalWidth):
+ (WebCore::RenderBlock::addOverflowFromChildren):
+ (WebCore::RenderBlock::expandsToEncloseOverhangingFloats):
+ (WebCore::RenderBlock::simplifiedLayout):
+ (WebCore::RenderBlock::layoutPositionedObjects):
+ (WebCore::RenderBlock::paintObject):
+ (WebCore::RenderBlock::selectionGaps):
+ (WebCore::RenderBlock::nodeAtPoint):
+ (WebCore::RenderBlock::offsetForContents):
+ (WebCore::RenderBlock::computeIntrinsicLogicalWidths):
+ (WebCore::RenderBlock::createAnonymousBoxWithSameTypeAs):
+ (WebCore::RenderBlock::childBoxIsUnsplittableForFragmentation):
+ (WebCore::RenderBlock::renderName):
+ (WebCore::RenderBlock::addChildToAnonymousColumnBlocks): Deleted.
+ (WebCore::RenderBlock::containingColumnsBlock): Deleted.
+ (WebCore::RenderBlock::splitFlow): Deleted.
+ (WebCore::RenderBlock::makeChildrenAnonymousColumnBlocks): Deleted.
+ (WebCore::RenderBlock::columnsBlockForSpanningElement): Deleted.
+ (WebCore::RenderBlock::addChildIgnoringAnonymousColumnBlocks): Deleted.
+ (WebCore::RenderBlock::updateLogicalWidthAndColumnWidth): Deleted.
+ (WebCore::RenderBlock::isTopLayoutOverflowAllowed): Deleted.
+ (WebCore::RenderBlock::isLeftLayoutOverflowAllowed): Deleted.
+ (WebCore::RenderBlock::paintColumnRules): Deleted.
+ (WebCore::RenderBlock::initialBlockOffsetForPainting): Deleted.
+ (WebCore::RenderBlock::blockDeltaForPaintingNextColumn): Deleted.
+ (WebCore::RenderBlock::paintColumnContents): Deleted.
+ (WebCore::ColumnRectIterator::ColumnRectIterator): Deleted.
+ (WebCore::ColumnRectIterator::advance): Deleted.
+ (WebCore::ColumnRectIterator::columnRect): Deleted.
+ (WebCore::ColumnRectIterator::hasMore): Deleted.
+ (WebCore::ColumnRectIterator::adjust): Deleted.
+ (WebCore::ColumnRectIterator::update): Deleted.
+ (WebCore::RenderBlock::hitTestColumns): Deleted.
+ (WebCore::RenderBlock::adjustForColumnRect): Deleted.
+ (WebCore::RenderBlock::availableLogicalWidth): Deleted.
+ (WebCore::RenderBlock::columnGap): Deleted.
+ (WebCore::RenderBlock::computeColumnCountAndWidth): Deleted.
+ (WebCore::RenderBlock::requiresColumns): Deleted.
+ (WebCore::RenderBlock::setComputedColumnCountAndWidth): Deleted.
+ (WebCore::RenderBlock::updateColumnProgressionFromStyle): Deleted.
+ (WebCore::RenderBlock::computedColumnWidth): Deleted.
+ (WebCore::RenderBlock::computedColumnCount): Deleted.
+ (WebCore::RenderBlock::columnInfo): Deleted.
+ (WebCore::RenderBlock::columnCount): Deleted.
+ (WebCore::RenderBlock::columnRectAt): Deleted.
+ (WebCore::RenderBlock::adjustPointToColumnContents): Deleted.
+ (WebCore::RenderBlock::adjustRectForColumns): Deleted.
+ (WebCore::RenderBlock::flipForWritingModeIncludingColumns): Deleted.
+ (WebCore::RenderBlock::adjustStartEdgeForWritingModeIncludingColumns): Deleted.
+ (WebCore::RenderBlock::adjustForColumns): Deleted.
+ (WebCore::RenderBlock::adjustIntrinsicLogicalWidthsForColumns): Deleted.
+ (WebCore::RenderBlock::paginationUnit): Deleted.
+ (WebCore::RenderBlock::createAnonymousColumnsWithParentRenderer): Deleted.
+ (WebCore::RenderBlock::createAnonymousColumnSpanWithParentRenderer): Deleted.
+ (WebCore::RenderBlock::computeLineGridPaginationOrigin): Deleted.
+ * rendering/RenderBlock.h:
+ (WebCore::RenderBlock::pixelSnappedLogicalRightOffsetForLine):
+ (WebCore::RenderBlock::createAnonymousBlock):
+ (WebCore::RenderBlock::paintColumnRules):
+ (WebCore::RenderBlock::createAnonymousColumnsBlock): Deleted.
+ (WebCore::RenderBlock::createAnonymousColumnSpanBlock): Deleted.
+ * rendering/RenderBlockFlow.cpp:
+ (WebCore::RenderBlockFlow::adjustIntrinsicLogicalWidthsForColumns):
+ (WebCore::RenderBlockFlow::computeIntrinsicLogicalWidths):
+ (WebCore::RenderBlockFlow::recomputeLogicalWidthAndColumnWidth):
+ (WebCore::RenderBlockFlow::columnGap):
+ (WebCore::RenderBlockFlow::computeColumnCountAndWidth):
+ (WebCore::RenderBlockFlow::layoutBlock):
+ (WebCore::inNormalFlow):
+ (WebCore::RenderBlockFlow::applyBeforeBreak):
+ (WebCore::RenderBlockFlow::applyAfterBreak):
+ (WebCore::RenderBlockFlow::updateMinimumPageHeight):
+ (WebCore::RenderBlockFlow::computeOverflow):
+ (WebCore::RenderBlockFlow::addOverhangingFloats):
+ (WebCore::RenderBlockFlow::hasOverhangingFloat):
+ (WebCore::RenderBlockFlow::relayoutForPagination):
+ (WebCore::RenderBlockFlow::checkForPaginationLogicalHeightChange):
+ (WebCore::RenderBlockFlow::requiresColumns):
+ (WebCore::RenderBlockFlow::setComputedColumnCountAndWidth):
+ (WebCore::RenderBlockFlow::updateColumnProgressionFromStyle):
+ (WebCore::RenderBlockFlow::computedColumnWidth):
+ (WebCore::RenderBlockFlow::computedColumnCount):
+ * rendering/RenderBlockFlow.h:
+ (WebCore::RenderBlockFlow::hasOverhangingFloats):
+ * rendering/RenderBox.cpp:
+ (WebCore::RenderBox::styleDidChange):
+ (WebCore::RenderBox::offsetFromContainer):
+ (WebCore::RenderBox::computeRectForRepaint):
+ (WebCore::RenderBox::layoutOverflowRectForPropagation):
+ * rendering/RenderBox.h:
+ * rendering/RenderBoxModelObject.cpp:
+ (WebCore::RenderBoxModelObject::adjustedPositionRelativeToOffsetParent):
+ (WebCore::RenderBoxModelObject::mapAbsoluteToLocalPoint):
+ * rendering/RenderBoxModelObject.h:
+ (WebCore::RenderBoxModelObject::canHaveBoxInfoInRegion):
+ * rendering/RenderFlexibleBox.cpp:
+ (WebCore::RenderFlexibleBox::layoutBlock):
+ * rendering/RenderFlowThread.h:
+ * rendering/RenderGeometryMap.cpp:
+ (WebCore::canMapBetweenRenderers):
+ * rendering/RenderInline.cpp:
+ (WebCore::RenderInline::clippedOverflowRectForRepaint):
+ (WebCore::RenderInline::computeRectForRepaint):
+ (WebCore::RenderInline::offsetFromContainer):
+ (WebCore::RenderInline::mapLocalToContainer):
+ * rendering/RenderLayer.cpp:
+ (WebCore::RenderLayer::RenderLayer):
+ (WebCore::RenderLayer::updateLayerPositions):
+ (WebCore::RenderLayer::updatePagination):
+ (WebCore::accumulateOffsetTowardsAncestor):
+ (WebCore::RenderLayer::paintList):
+ (WebCore::RenderLayer::hitTestList):
+ (WebCore::checkContainingBlockChainForPagination): Deleted.
+ (WebCore::RenderLayer::useRegionBasedColumns): Deleted.
+ (WebCore::RenderLayer::paintPaginatedChildLayer): Deleted.
+ (WebCore::RenderLayer::paintChildLayerIntoColumns): Deleted.
+ (WebCore::RenderLayer::hitTestPaginatedChildLayer): Deleted.
+ (WebCore::RenderLayer::hitTestChildLayerColumns): Deleted.
+ * rendering/RenderLayer.h:
+ * rendering/RenderMultiColumnFlowThread.cpp:
+ (WebCore::RenderMultiColumnFlowThread::shouldCheckColumnBreaks):
+ * rendering/RenderMultiColumnFlowThread.h:
+ * rendering/RenderObject.cpp:
+ (WebCore::RenderObject::computeRectForRepaint):
+ (WebCore::RenderObject::mapLocalToContainer):
+ (WebCore::RenderObject::pushMappingToContainer):
+ (WebCore::RenderObject::offsetFromContainer):
+ * rendering/RenderObject.h:
+ (WebCore::RenderObject::isAnonymousBlock):
+ (WebCore::RenderObject::RenderObjectBitfields::RenderObjectBitfields):
+ (WebCore::RenderObject::hasColumns): Deleted.
+ (WebCore::RenderObject::setHasColumns): Deleted.
+ (WebCore::RenderObject::isAnonymousColumnsBlock): Deleted.
+ (WebCore::RenderObject::isAnonymousColumnSpanBlock): Deleted.
+ (WebCore::RenderObject::adjustForColumns): Deleted.
+ (WebCore::RenderObject::offsetForColumns): Deleted.
+ * rendering/RenderText.cpp:
+ (WebCore::RenderText::selectionRectForRepaint):
+ * rendering/RenderView.cpp:
+ (WebCore::RenderView::availableLogicalHeight):
+ (WebCore::RenderView::pageOrViewLogicalHeight):
+ (WebCore::RenderView::unextendedBackgroundRect):
+ (WebCore::RenderView::backgroundRect):
+ (WebCore::RenderView::shouldDisableLayoutStateForSubtree):
+ (WebCore::RenderView::pageNumberForBlockProgressionOffset):
+ (WebCore::RenderView::pageCount):
+ (WebCore::RenderView::paginationUnit): Deleted.
+ * rendering/RenderView.h:
+ (WebCore::LayoutStateMaintainer::LayoutStateMaintainer):
+ (WebCore::LayoutStateMaintainer::push):
+ * rendering/SimpleLineLayout.cpp:
+ (WebCore::SimpleLineLayout::canUseFor):
+ * rendering/svg/RenderSVGText.cpp:
+ (WebCore::RenderSVGText::layout):
+ * style/StyleResolveForDocument.cpp:
+ (WebCore::Style::resolveForDocument):
+
</ins><span class="cx"> 2014-05-06 Brady Eidson <beidson@apple.com>
</span><span class="cx">
</span><span class="cx"> Don't select an image that is about to have its menu shown.
</span></span></pre></div>
<a id="trunkSourceWebCoredomDocumentcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/dom/Document.cpp (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/dom/Document.cpp 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/Source/WebCore/dom/Document.cpp 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -1099,11 +1099,6 @@
</span><span class="cx"> return element.release();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool Document::regionBasedColumnsEnabled() const
-{
- return settings() && settings()->regionBasedColumnsEnabled();
-}
-
</del><span class="cx"> bool Document::cssRegionsEnabled() const
</span><span class="cx"> {
</span><span class="cx"> return RuntimeEnabledFeatures::sharedFeatures().cssRegionsEnabled();
</span></span></pre></div>
<a id="trunkSourceWebCoredomDocumenth"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/dom/Document.h (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/dom/Document.h 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/Source/WebCore/dom/Document.h 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -436,8 +436,6 @@
</span><span class="cx">
</span><span class="cx"> NamedFlowCollection* namedFlows();
</span><span class="cx">
</span><del>- bool regionBasedColumnsEnabled() const;
-
</del><span class="cx"> #if ENABLE(CSS_GRID_LAYOUT)
</span><span class="cx"> bool cssGridLayoutEnabled() const;
</span><span class="cx"> #endif
</span></span></pre></div>
<a id="trunkSourceWebCorepageFrameViewcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/page/FrameView.cpp (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/page/FrameView.cpp 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/Source/WebCore/page/FrameView.cpp 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -120,7 +120,7 @@
</span><span class="cx"> flags &= ~RenderLayer::CheckForRepaint;
</span><span class="cx"> flags |= RenderLayer::NeedsFullRepaintInBacking;
</span><span class="cx"> }
</span><del>- if (isRelayoutingSubtree && (layer->isPaginated() || layer->enclosingPaginationLayer()))
</del><ins>+ if (isRelayoutingSubtree && layer->enclosingPaginationLayer())
</ins><span class="cx"> flags |= RenderLayer::UpdatePagination;
</span><span class="cx"> return flags;
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCorepageSettingsin"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/page/Settings.in (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/page/Settings.in 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/Source/WebCore/page/Settings.in 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -84,7 +84,7 @@
</span><span class="cx"> canvasUsesAcceleratedDrawing initial=false
</span><span class="cx"> acceleratedDrawingEnabled initial=false
</span><span class="cx"> acceleratedFiltersEnabled initial=false
</span><del>-regionBasedColumnsEnabled initial=false
</del><ins>+regionBasedColumnsEnabled initial=true
</ins><span class="cx"> cssGridLayoutEnabled initial=true
</span><span class="cx"> useLegacyTextAlignPositionedElementBehavior initial=false
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingLayoutStatecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/LayoutState.cpp (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/LayoutState.cpp 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/Source/WebCore/rendering/LayoutState.cpp 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -26,17 +26,16 @@
</span><span class="cx"> #include "config.h"
</span><span class="cx"> #include "LayoutState.h"
</span><span class="cx">
</span><del>-#include "ColumnInfo.h"
</del><span class="cx"> #include "RenderFlowThread.h"
</span><span class="cx"> #include "RenderInline.h"
</span><span class="cx"> #include "RenderLayer.h"
</span><ins>+#include "RenderMultiColumnFlowThread.h"
</ins><span class="cx"> #include "RenderView.h"
</span><span class="cx">
</span><span class="cx"> namespace WebCore {
</span><span class="cx">
</span><del>-LayoutState::LayoutState(std::unique_ptr<LayoutState> next, RenderBox* renderer, const LayoutSize& offset, LayoutUnit pageLogicalHeight, bool pageLogicalHeightChanged, ColumnInfo* columnInfo)
- : m_columnInfo(columnInfo)
- , m_lineGrid(0)
</del><ins>+LayoutState::LayoutState(std::unique_ptr<LayoutState> next, RenderBox* renderer, const LayoutSize& offset, LayoutUnit pageLogicalHeight, bool pageLogicalHeightChanged)
+ : m_lineGrid(0)
</ins><span class="cx"> , m_next(std::move(next))
</span><span class="cx"> #ifndef NDEBUG
</span><span class="cx"> , m_renderer(renderer)
</span><span class="lines">@@ -82,7 +81,7 @@
</span><span class="cx">
</span><span class="cx"> // If we establish a new page height, then cache the offset to the top of the first page.
</span><span class="cx"> // We can compare this later on to figure out what part of the page we're actually on,
</span><del>- if (pageLogicalHeight || m_columnInfo || renderer->isRenderFlowThread()) {
</del><ins>+ if (pageLogicalHeight || renderer->isRenderFlowThread()) {
</ins><span class="cx"> m_pageLogicalHeight = pageLogicalHeight;
</span><span class="cx"> bool isFlipped = renderer->style().isFlippedBlocksWritingMode();
</span><span class="cx"> m_pageOffset = LayoutSize(m_layoutOffset.width() + (!isFlipped ? renderer->borderLeft() + renderer->paddingLeft() : renderer->borderRight() + renderer->paddingRight()),
</span><span class="lines">@@ -101,23 +100,20 @@
</span><span class="cx"> m_pageLogicalHeight = 0;
</span><span class="cx"> m_isPaginated = false;
</span><span class="cx"> } else
</span><del>- m_isPaginated = m_pageLogicalHeight || m_next->m_columnInfo || renderer->flowThreadContainingBlock();
</del><ins>+ m_isPaginated = m_pageLogicalHeight || renderer->flowThreadContainingBlock();
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // Propagate line grid information.
</span><span class="cx"> propagateLineGridInfo(renderer);
</span><span class="cx">
</span><del>- if (!m_columnInfo)
- m_columnInfo = m_next->m_columnInfo;
-
</del><span class="cx"> m_layoutDelta = m_next->m_layoutDelta;
</span><span class="cx"> #if !ASSERT_DISABLED && ENABLE(SATURATED_LAYOUT_ARITHMETIC)
</span><span class="cx"> m_layoutDeltaXSaturated = m_next->m_layoutDeltaXSaturated;
</span><span class="cx"> m_layoutDeltaYSaturated = m_next->m_layoutDeltaYSaturated;
</span><span class="cx"> #endif
</span><span class="cx">
</span><del>- if (lineGrid() && (lineGrid()->style().writingMode() == renderer->style().writingMode()) && renderer->isRenderBlock())
- toRenderBlock(renderer)->computeLineGridPaginationOrigin(*this);
</del><ins>+ if (lineGrid() && (lineGrid()->style().writingMode() == renderer->style().writingMode()) && renderer->isRenderMultiColumnFlowThread())
+ toRenderMultiColumnFlowThread(renderer)->computeLineGridPaginationOrigin(*this);
</ins><span class="cx">
</span><span class="cx"> // If we have a new grid to track, then add it to our set.
</span><span class="cx"> if (renderer->style().lineGrid() != RenderStyle::initialLineGrid() && renderer->isRenderBlockFlow())
</span><span class="lines">@@ -134,7 +130,6 @@
</span><span class="cx"> , m_layoutDeltaXSaturated(false)
</span><span class="cx"> , m_layoutDeltaYSaturated(false)
</span><span class="cx"> #endif
</span><del>- , m_columnInfo(0)
</del><span class="cx"> , m_lineGrid(0)
</span><span class="cx"> , m_pageLogicalHeight(0)
</span><span class="cx"> #ifndef NDEBUG
</span><span class="lines">@@ -156,7 +151,6 @@
</span><span class="cx"> {
</span><span class="cx"> m_pageLogicalHeight = m_next->m_pageLogicalHeight;
</span><span class="cx"> m_pageOffset = m_next->m_pageOffset;
</span><del>- m_columnInfo = m_next->m_columnInfo;
</del><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> LayoutUnit LayoutState::pageLogicalOffset(RenderBox* child, LayoutUnit childLogicalOffset) const
</span><span class="lines">@@ -166,13 +160,6 @@
</span><span class="cx"> return m_layoutOffset.width() + childLogicalOffset - m_pageOffset.width();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void LayoutState::addForcedColumnBreak(RenderBox* child, LayoutUnit childLogicalOffset)
-{
- if (!m_columnInfo || m_columnInfo->columnHeight())
- return;
- m_columnInfo->addForcedBreak(pageLogicalOffset(child, childLogicalOffset));
-}
-
</del><span class="cx"> void LayoutState::propagateLineGridInfo(RenderBox* renderer)
</span><span class="cx"> {
</span><span class="cx"> // Disable line grids for objects we don't support. For now this includes overflow:scroll/auto, inline blocks and
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingLayoutStateh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/LayoutState.h (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/LayoutState.h 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/Source/WebCore/rendering/LayoutState.h 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -26,7 +26,6 @@
</span><span class="cx"> #ifndef LayoutState_h
</span><span class="cx"> #define LayoutState_h
</span><span class="cx">
</span><del>-#include "ColumnInfo.h"
</del><span class="cx"> #include "LayoutRect.h"
</span><span class="cx"> #include <wtf/HashMap.h>
</span><span class="cx"> #include <wtf/Noncopyable.h>
</span><span class="lines">@@ -53,7 +52,6 @@
</span><span class="cx"> , m_layoutDeltaXSaturated(false)
</span><span class="cx"> , m_layoutDeltaYSaturated(false)
</span><span class="cx"> #endif
</span><del>- , m_columnInfo(nullptr)
</del><span class="cx"> , m_lineGrid(nullptr)
</span><span class="cx"> , m_pageLogicalHeight(0)
</span><span class="cx"> #ifndef NDEBUG
</span><span class="lines">@@ -62,18 +60,15 @@
</span><span class="cx"> {
</span><span class="cx"> }
</span><span class="cx">
</span><del>- LayoutState(std::unique_ptr<LayoutState> state, RenderBox*, const LayoutSize& offset, LayoutUnit pageHeight, bool pageHeightChanged, ColumnInfo*);
</del><ins>+ LayoutState(std::unique_ptr<LayoutState>, RenderBox*, const LayoutSize& offset, LayoutUnit pageHeight, bool pageHeightChanged);
</ins><span class="cx"> explicit LayoutState(RenderObject&);
</span><span class="cx">
</span><span class="cx"> void clearPaginationInformation();
</span><del>- bool isPaginatingColumns() const { return m_columnInfo && m_columnInfo->paginationUnit() == ColumnInfo::Column; }
</del><span class="cx"> bool isPaginated() const { return m_isPaginated; }
</span><span class="cx">
</span><span class="cx"> // The page logical offset is the object's offset from the top of the page in the page progression
</span><span class="cx"> // direction (so an x-offset in vertical text and a y-offset for horizontal text).
</span><span class="cx"> LayoutUnit pageLogicalOffset(RenderBox*, LayoutUnit childLogicalOffset) const;
</span><del>-
- void addForcedColumnBreak(RenderBox*, LayoutUnit childLogicalOffset);
</del><span class="cx">
</span><span class="cx"> LayoutUnit pageLogicalHeight() const { return m_pageLogicalHeight; }
</span><span class="cx"> bool pageLogicalHeightChanged() const { return m_pageLogicalHeightChanged; }
</span><span class="lines">@@ -93,7 +88,7 @@
</span><span class="cx"> void establishLineGrid(RenderBlockFlow*);
</span><span class="cx">
</span><span class="cx"> public:
</span><del>- // Do not add anything apart from bitfields until after m_columnInfo. See https://bugs.webkit.org/show_bug.cgi?id=100173
</del><ins>+ // Do not add anything apart from bitfields. See https://bugs.webkit.org/show_bug.cgi?id=100173
</ins><span class="cx"> bool m_clipped : 1;
</span><span class="cx"> bool m_isPaginated : 1;
</span><span class="cx"> // If our page height has changed, this will force all blocks to relayout.
</span><span class="lines">@@ -103,8 +98,6 @@
</span><span class="cx"> bool m_layoutDeltaYSaturated : 1;
</span><span class="cx"> #endif
</span><span class="cx">
</span><del>- // If the enclosing pagination model is a column model, then this will store column information for easy retrieval/manipulation.
- ColumnInfo* m_columnInfo;
</del><span class="cx"> // The current line grid that we're snapping to and the offset of the start of the grid.
</span><span class="cx"> RenderBlockFlow* m_lineGrid;
</span><span class="cx"> std::unique_ptr<LayoutState> m_next;
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderBlockcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderBlock.cpp (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderBlock.cpp 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/Source/WebCore/rendering/RenderBlock.cpp 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -25,7 +25,6 @@
</span><span class="cx"> #include "RenderBlock.h"
</span><span class="cx">
</span><span class="cx"> #include "AXObjectCache.h"
</span><del>-#include "ColumnInfo.h"
</del><span class="cx"> #include "Document.h"
</span><span class="cx"> #include "Editor.h"
</span><span class="cx"> #include "Element.h"
</span><span class="lines">@@ -54,7 +53,6 @@
</span><span class="cx"> #include "RenderInline.h"
</span><span class="cx"> #include "RenderIterator.h"
</span><span class="cx"> #include "RenderLayer.h"
</span><del>-#include "RenderMarquee.h"
</del><span class="cx"> #include "RenderNamedFlowFragment.h"
</span><span class="cx"> #include "RenderNamedFlowThread.h"
</span><span class="cx"> #include "RenderRegion.h"
</span><span class="lines">@@ -86,9 +84,6 @@
</span><span class="cx">
</span><span class="cx"> COMPILE_ASSERT(sizeof(RenderBlock) == sizeof(SameSizeAsRenderBlock), RenderBlock_should_stay_small);
</span><span class="cx">
</span><del>-typedef WTF::HashMap<const RenderBox*, std::unique_ptr<ColumnInfo>> ColumnInfoMap;
-static ColumnInfoMap* gColumnInfoMap = 0;
-
</del><span class="cx"> static TrackedDescendantsMap* gPositionedDescendantsMap = 0;
</span><span class="cx"> static TrackedDescendantsMap* gPercentHeightDescendantsMap = 0;
</span><span class="cx">
</span><span class="lines">@@ -101,8 +96,6 @@
</span><span class="cx"> static int gDelayUpdateScrollInfo = 0;
</span><span class="cx"> static DelayedUpdateScrollInfoSet* gDelayedUpdateScrollInfoSet = 0;
</span><span class="cx">
</span><del>-static bool gColumnFlowSplitEnabled = true;
-
</del><span class="cx"> // Allocated only when some of these fields have non-default values
</span><span class="cx">
</span><span class="cx"> struct RenderBlockRareData {
</span><span class="lines">@@ -207,8 +200,6 @@
</span><span class="cx">
</span><span class="cx"> RenderBlock::~RenderBlock()
</span><span class="cx"> {
</span><del>- if (hasColumns())
- gColumnInfoMap->take(this);
</del><span class="cx"> if (gRareDataMap)
</span><span class="cx"> gRareDataMap->remove(this);
</span><span class="cx"> if (gPercentHeightDescendantsMap)
</span><span class="lines">@@ -347,7 +338,7 @@
</span><span class="cx"> void RenderBlock::addChildToContinuation(RenderObject* newChild, RenderObject* beforeChild)
</span><span class="cx"> {
</span><span class="cx"> RenderBlock* flow = continuationBefore(beforeChild);
</span><del>- ASSERT(!beforeChild || beforeChild->parent()->isAnonymousColumnSpanBlock() || beforeChild->parent()->isRenderBlock());
</del><ins>+ ASSERT(!beforeChild || beforeChild->parent()->isRenderBlock());
</ins><span class="cx"> RenderBoxModelObject* beforeChildParent = 0;
</span><span class="cx"> if (beforeChild)
</span><span class="cx"> beforeChildParent = toRenderBoxModelObject(beforeChild->parent());
</span><span class="lines">@@ -364,8 +355,6 @@
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- // A continuation always consists of two potential candidates: a block or an anonymous
- // column span box holding column span children.
</del><span class="cx"> bool childIsNormal = newChild->isInline() || !newChild->style().columnSpan();
</span><span class="cx"> bool bcpIsNormal = beforeChildParent->isInline() || !beforeChildParent->style().columnSpan();
</span><span class="cx"> bool flowIsNormal = flow->isInline() || !flow->style().columnSpan();
</span><span class="lines">@@ -388,96 +377,6 @@
</span><span class="cx"> beforeChildParent->addChildIgnoringContinuation(newChild, beforeChild);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-
-void RenderBlock::addChildToAnonymousColumnBlocks(RenderObject* newChild, RenderObject* beforeChild)
-{
- ASSERT(!continuation()); // We don't yet support column spans that aren't immediate children of the multi-column block.
-
- // The goal is to locate a suitable box in which to place our child.
- RenderBlock* beforeChildParent = 0;
- if (beforeChild) {
- RenderObject* curr = beforeChild;
- while (curr && curr->parent() != this)
- curr = curr->parent();
- beforeChildParent = toRenderBlock(curr);
- ASSERT(beforeChildParent);
- ASSERT(beforeChildParent->isAnonymousColumnsBlock() || beforeChildParent->isAnonymousColumnSpanBlock());
- } else
- beforeChildParent = toRenderBlock(lastChild());
-
- // If the new child is floating or positioned it can just go in that block.
- if (newChild->isFloatingOrOutOfFlowPositioned()) {
- beforeChildParent->addChildIgnoringAnonymousColumnBlocks(newChild, beforeChild);
- return;
- }
-
- // See if the child can be placed in the box.
- bool newChildHasColumnSpan = !newChild->isInline() && newChild->style().columnSpan();
- bool beforeChildParentHoldsColumnSpans = beforeChildParent->isAnonymousColumnSpanBlock();
-
- if (newChildHasColumnSpan == beforeChildParentHoldsColumnSpans) {
- beforeChildParent->addChildIgnoringAnonymousColumnBlocks(newChild, beforeChild);
- return;
- }
-
- if (!beforeChild) {
- // Create a new block of the correct type.
- RenderBlock* newBox = newChildHasColumnSpan ? createAnonymousColumnSpanBlock() : createAnonymousColumnsBlock();
- insertChildInternal(newBox, nullptr, NotifyChildren);
- newBox->addChildIgnoringAnonymousColumnBlocks(newChild, 0);
- return;
- }
-
- RenderObject* immediateChild = beforeChild;
- bool isPreviousBlockViable = true;
- while (immediateChild->parent() != this) {
- if (isPreviousBlockViable)
- isPreviousBlockViable = !immediateChild->previousSibling();
- immediateChild = immediateChild->parent();
- }
- if (isPreviousBlockViable && immediateChild->previousSibling()) {
- toRenderBlock(immediateChild->previousSibling())->addChildIgnoringAnonymousColumnBlocks(newChild, 0); // Treat like an append.
- return;
- }
-
- // Split our anonymous blocks.
- RenderObject* newBeforeChild = splitAnonymousBoxesAroundChild(beforeChild);
-
-
- // Create a new anonymous box of the appropriate type.
- RenderBlock* newBox = newChildHasColumnSpan ? createAnonymousColumnSpanBlock() : createAnonymousColumnsBlock();
- insertChildInternal(newBox, newBeforeChild, NotifyChildren);
- newBox->addChildIgnoringAnonymousColumnBlocks(newChild, 0);
- return;
-}
-
-RenderBlock* RenderBlock::containingColumnsBlock(bool allowAnonymousColumnBlock)
-{
- RenderBlock* firstChildIgnoringAnonymousWrappers = 0;
- for (RenderElement* curr = this; curr; curr = curr->parent()) {
- if (!curr->isRenderBlock() || curr->isFloatingOrOutOfFlowPositioned() || curr->isTableCell() || curr->isRoot() || curr->isRenderView() || curr->hasOverflowClip()
- || curr->isInlineBlockOrInlineTable())
- return 0;
-
- // FIXME: Tables, RenderButtons, and RenderListItems all do special management
- // of their children that breaks when the flow is split through them. Disabling
- // multi-column for them to avoid this problem.
- if (curr->isTable() || curr->isRenderButton() || curr->isListItem())
- return 0;
-
- RenderBlock* currBlock = toRenderBlock(curr);
- if (!currBlock->createsAnonymousWrapper())
- firstChildIgnoringAnonymousWrappers = currBlock;
-
- if (currBlock->style().specifiesColumns() && (allowAnonymousColumnBlock || !currBlock->isAnonymousColumnsBlock()))
- return firstChildIgnoringAnonymousWrappers;
-
- if (currBlock->isAnonymousColumnSpanBlock())
- return 0;
- }
- return 0;
-}
-
</del><span class="cx"> RenderPtr<RenderBlock> RenderBlock::clone() const
</span><span class="cx"> {
</span><span class="cx"> RenderPtr<RenderBlock> cloneBlock;
</span><span class="lines">@@ -568,148 +467,16 @@
</span><span class="cx"> fromBlock->moveChildrenTo(toBlock, currChildNextSibling, 0, true);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void RenderBlock::splitFlow(RenderObject* beforeChild, RenderBlock* newBlockBox,
- RenderObject* newChild, RenderBoxModelObject* oldCont)
</del><ins>+void RenderBlock::addChild(RenderObject* newChild, RenderObject* beforeChild)
</ins><span class="cx"> {
</span><del>- RenderBlock* pre = 0;
- RenderBlock* block = containingColumnsBlock();
-
- // Delete our line boxes before we do the inline split into continuations.
- block->deleteLines();
-
- bool madeNewBeforeBlock = false;
- if (block->isAnonymousColumnsBlock()) {
- // We can reuse this block and make it the preBlock of the next continuation.
- pre = block;
- pre->removePositionedObjects(0);
- // FIXME-BLOCKFLOW remove this when splitFlow is moved to RenderBlockFlow.
- if (pre->isRenderBlockFlow())
- toRenderBlockFlow(pre)->removeFloatingObjects();
- block = toRenderBlock(block->parent());
- } else {
- // No anonymous block available for use. Make one.
- pre = block->createAnonymousColumnsBlock();
- pre->setChildrenInline(false);
- madeNewBeforeBlock = true;
- }
-
- RenderBlock* post = block->createAnonymousColumnsBlock();
- post->setChildrenInline(false);
-
- RenderObject* boxFirst = madeNewBeforeBlock ? block->firstChild() : pre->nextSibling();
- if (madeNewBeforeBlock)
- block->insertChildInternal(pre, boxFirst, NotifyChildren);
- block->insertChildInternal(newBlockBox, boxFirst, NotifyChildren);
- block->insertChildInternal(post, boxFirst, NotifyChildren);
- block->setChildrenInline(false);
-
- if (madeNewBeforeBlock)
- block->moveChildrenTo(pre, boxFirst, 0, true);
-
- splitBlocks(pre, post, newBlockBox, beforeChild, oldCont);
-
- // We already know the newBlockBox isn't going to contain inline kids, so avoid wasting
- // time in makeChildrenNonInline by just setting this explicitly up front.
- newBlockBox->setChildrenInline(false);
-
- // We delayed adding the newChild until now so that the |newBlockBox| would be fully
- // connected, thus allowing newChild access to a renderArena should it need
- // to wrap itself in additional boxes (e.g., table construction).
- newBlockBox->addChild(newChild);
-
- // Always just do a full layout in order to ensure that line boxes (especially wrappers for images)
- // get deleted properly. Because objects moves from the pre block into the post block, we want to
- // make new line boxes instead of leaving the old line boxes around.
- pre->setNeedsLayoutAndPrefWidthsRecalc();
- block->setNeedsLayoutAndPrefWidthsRecalc();
- post->setNeedsLayoutAndPrefWidthsRecalc();
</del><ins>+ if (continuation() && !isAnonymousBlock())
+ addChildToContinuation(newChild, beforeChild);
+ else
+ addChildIgnoringContinuation(newChild, beforeChild);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void RenderBlock::makeChildrenAnonymousColumnBlocks(RenderObject* beforeChild, RenderBlock* newBlockBox, RenderObject* newChild)
</del><ins>+void RenderBlock::addChildIgnoringContinuation(RenderObject* newChild, RenderObject* beforeChild)
</ins><span class="cx"> {
</span><del>- RenderBlock* pre = 0;
- RenderBlock* post = 0;
- RenderBlock* block = this; // Eventually block will not just be |this|, but will also be a block nested inside |this|. Assign to a variable
- // so that we don't have to patch all of the rest of the code later on.
-
- // Delete the block's line boxes before we do the split.
- block->deleteLines();
-
- if (beforeChild && beforeChild->parent() != this)
- beforeChild = splitAnonymousBoxesAroundChild(beforeChild);
-
- if (beforeChild != firstChild()) {
- pre = block->createAnonymousColumnsBlock();
- pre->setChildrenInline(block->childrenInline());
- }
-
- if (beforeChild) {
- post = block->createAnonymousColumnsBlock();
- post->setChildrenInline(block->childrenInline());
- }
-
- RenderObject* boxFirst = block->firstChild();
- if (pre)
- block->insertChildInternal(pre, boxFirst, NotifyChildren);
- block->insertChildInternal(newBlockBox, boxFirst, NotifyChildren);
- if (post)
- block->insertChildInternal(post, boxFirst, NotifyChildren);
- block->setChildrenInline(false);
-
- // The pre/post blocks always have layers, so we know to always do a full insert/remove (so we pass true as the last argument).
- block->moveChildrenTo(pre, boxFirst, beforeChild, true);
- block->moveChildrenTo(post, beforeChild, 0, true);
-
- // We already know the newBlockBox isn't going to contain inline kids, so avoid wasting
- // time in makeChildrenNonInline by just setting this explicitly up front.
- newBlockBox->setChildrenInline(false);
-
- // We delayed adding the newChild until now so that the |newBlockBox| would be fully
- // connected, thus allowing newChild access to a renderArena should it need
- // to wrap itself in additional boxes (e.g., table construction).
- newBlockBox->addChild(newChild);
-
- // Always just do a full layout in order to ensure that line boxes (especially wrappers for images)
- // get deleted properly. Because objects moved from the pre block into the post block, we want to
- // make new line boxes instead of leaving the old line boxes around.
- if (pre)
- pre->setNeedsLayoutAndPrefWidthsRecalc();
- block->setNeedsLayoutAndPrefWidthsRecalc();
- if (post)
- post->setNeedsLayoutAndPrefWidthsRecalc();
-}
-
-RenderBlock* RenderBlock::columnsBlockForSpanningElement(RenderObject* newChild)
-{
- // FIXME: This function is the gateway for the addition of column-span support. It will
- // be added to in three stages:
- // (1) Immediate children of a multi-column block can span.
- // (2) Nested block-level children with only block-level ancestors between them and the multi-column block can span.
- // (3) Nested children with block or inline ancestors between them and the multi-column block can span (this is when we
- // cross the streams and have to cope with both types of continuations mixed together).
- // This function currently supports (1) and (2).
- RenderBlock* columnsBlockAncestor = 0;
- if (!newChild->isText() && newChild->style().columnSpan() && !newChild->isBeforeOrAfterContent()
- && !newChild->isFloatingOrOutOfFlowPositioned() && !newChild->isInline() && !isAnonymousColumnSpanBlock()) {
- columnsBlockAncestor = containingColumnsBlock(false);
- if (columnsBlockAncestor) {
- // Make sure that none of the parent ancestors have a continuation.
- // If yes, we do not want split the block into continuations.
- RenderElement* curr = this;
- while (curr && curr != columnsBlockAncestor) {
- if (curr->isRenderBlock() && toRenderBlock(curr)->continuation()) {
- columnsBlockAncestor = 0;
- break;
- }
- curr = curr->parent();
- }
- }
- }
- return columnsBlockAncestor;
-}
-
-void RenderBlock::addChildIgnoringAnonymousColumnBlocks(RenderObject* newChild, RenderObject* beforeChild)
-{
</del><span class="cx"> if (beforeChild && beforeChild->parent() != this) {
</span><span class="cx"> RenderElement* beforeChildContainer = beforeChild->parent();
</span><span class="cx"> while (beforeChildContainer->parent() != this)
</span><span class="lines">@@ -753,36 +520,6 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>- // Check for a spanning element in columns.
- if (gColumnFlowSplitEnabled && !document().regionBasedColumnsEnabled()) {
- RenderBlock* columnsBlockAncestor = columnsBlockForSpanningElement(newChild);
- if (columnsBlockAncestor) {
- TemporaryChange<bool> columnFlowSplitEnabled(gColumnFlowSplitEnabled, false);
- // We are placing a column-span element inside a block.
- RenderBlock* newBox = createAnonymousColumnSpanBlock();
-
- if (columnsBlockAncestor != this && !isRenderFlowThread()) {
- // We are nested inside a multi-column element and are being split by the span. We have to break up
- // our block into continuations.
- RenderBoxModelObject* oldContinuation = continuation();
-
- // When we split an anonymous block, there's no need to do any continuation hookup,
- // since we haven't actually split a real element.
- if (!isAnonymousBlock())
- setContinuation(newBox);
-
- splitFlow(beforeChild, newBox, newChild, oldContinuation);
- return;
- }
-
- // We have to perform a split of this block's children. This involves creating an anonymous block box to hold
- // the column-spanning |newChild|. We take all of the children from before |newChild| and put them into
- // one anonymous columns block, and all of the children after |newChild| go into another anonymous block.
- makeChildrenAnonymousColumnBlocks(beforeChild, newBox, newChild);
- return;
- }
- }
-
</del><span class="cx"> bool madeBoxesNonInline = false;
</span><span class="cx">
</span><span class="cx"> // A block has to either have all of its children inline, or all of its children as blocks.
</span><span class="lines">@@ -827,22 +564,6 @@
</span><span class="cx"> // this object may be dead here
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void RenderBlock::addChild(RenderObject* newChild, RenderObject* beforeChild)
-{
- if (continuation() && !isAnonymousBlock())
- addChildToContinuation(newChild, beforeChild);
- else
- addChildIgnoringContinuation(newChild, beforeChild);
-}
-
-void RenderBlock::addChildIgnoringContinuation(RenderObject* newChild, RenderObject* beforeChild)
-{
- if (!isAnonymousBlock() && firstChild() && (firstChild()->isAnonymousColumnsBlock() || firstChild()->isAnonymousColumnSpanBlock()))
- addChildToAnonymousColumnBlocks(newChild, beforeChild);
- else
- addChildIgnoringAnonymousColumnBlocks(newChild, beforeChild);
-}
-
</del><span class="cx"> static void getInlineRun(RenderObject* start, RenderObject* boundary,
</span><span class="cx"> RenderObject*& inlineRunStart,
</span><span class="cx"> RenderObject*& inlineRunEnd)
</span><span class="lines">@@ -944,7 +665,7 @@
</span><span class="cx"> ASSERT(child->isAnonymousBlock());
</span><span class="cx"> ASSERT(!child->childrenInline());
</span><span class="cx">
</span><del>- if (child->continuation() || (child->firstChild() && (child->isAnonymousColumnSpanBlock() || child->isAnonymousColumnsBlock())))
</del><ins>+ if (child->continuation())
</ins><span class="cx"> return;
</span><span class="cx">
</span><span class="cx"> RenderObject* firstAnChild = child->firstChild();
</span><span class="lines">@@ -1019,12 +740,7 @@
</span><span class="cx"> if (!canMergeAnonymousBlock(nextAnonymousBlock))
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><del>- if (!previous || !next)
- return true;
-
- // Make sure the types of the anonymous blocks match up.
- return previous->isAnonymousColumnsBlock() == next->isAnonymousColumnsBlock()
- && previous->isAnonymousColumnSpanBlock() == next->isAnonymousColumnSpanBlock();
</del><ins>+ return true;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void RenderBlock::collapseAnonymousBoxChild(RenderBlock* parent, RenderBlock* child)
</span><span class="lines">@@ -1054,9 +770,6 @@
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- // This protects against column split flows when anonymous blocks are getting merged.
- TemporaryChange<bool> columnFlowSplitEnabled(gColumnFlowSplitEnabled, false);
-
</del><span class="cx"> // If this child is a block, and if our previous and next siblings are
</span><span class="cx"> // both anonymous blocks with inline content, then we can go ahead and
</span><span class="cx"> // fold the inline content back together.
</span><span class="lines">@@ -1315,18 +1028,16 @@
</span><span class="cx"> flowThread->logicalWidthChangedInRegionsForBlock(this, relayoutChildren);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool RenderBlock::updateLogicalWidthAndColumnWidth()
</del><ins>+bool RenderBlock::recomputeLogicalWidth()
</ins><span class="cx"> {
</span><span class="cx"> LayoutUnit oldWidth = logicalWidth();
</span><del>- LayoutUnit oldColumnWidth = computedColumnWidth();
-
</del><ins>+
</ins><span class="cx"> updateLogicalWidth();
</span><del>- computeColumnCountAndWidth();
-
</del><ins>+
</ins><span class="cx"> bool hasBorderOrPaddingLogicalWidthChanged = m_hasBorderOrPaddingLogicalWidthChanged;
</span><span class="cx"> m_hasBorderOrPaddingLogicalWidthChanged = false;
</span><span class="cx">
</span><del>- return oldWidth != logicalWidth() || oldColumnWidth != computedColumnWidth() || hasBorderOrPaddingLogicalWidthChanged;
</del><ins>+ return oldWidth != logicalWidth() || hasBorderOrPaddingLogicalWidthChanged;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void RenderBlock::layoutBlock(bool, LayoutUnit)
</span><span class="lines">@@ -1337,25 +1048,15 @@
</span><span class="cx">
</span><span class="cx"> void RenderBlock::addOverflowFromChildren()
</span><span class="cx"> {
</span><del>- if (!hasColumns()) {
- if (childrenInline())
- addOverflowFromInlineChildren();
- else
- addOverflowFromBlockChildren();
-
- // If this block is flowed inside a flow thread, make sure its overflow is propagated to the containing regions.
- if (m_overflow) {
- if (RenderFlowThread* containingFlowThread = flowThreadContainingBlock())
- containingFlowThread->addRegionsVisualOverflow(this, m_overflow->visualOverflowRect());
- }
- } else {
- ColumnInfo* colInfo = columnInfo();
- if (columnCount(colInfo)) {
- LayoutRect lastRect = columnRectAt(colInfo, columnCount(colInfo) - 1);
- addLayoutOverflow(lastRect);
- if (!hasOverflowClip())
- addVisualOverflow(lastRect);
- }
</del><ins>+ if (childrenInline())
+ addOverflowFromInlineChildren();
+ else
+ addOverflowFromBlockChildren();
+
+ // If this block is flowed inside a flow thread, make sure its overflow is propagated to the containing regions.
+ if (m_overflow) {
+ if (RenderFlowThread* containingFlowThread = flowThreadContainingBlock())
+ containingFlowThread->addRegionsVisualOverflow(this, m_overflow->visualOverflowRect());
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1445,34 +1146,10 @@
</span><span class="cx"> flowThread->addRegionsVisualOverflowFromTheme(this);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool RenderBlock::isTopLayoutOverflowAllowed() const
-{
- bool hasTopOverflow = RenderBox::isTopLayoutOverflowAllowed();
- if (!hasColumns() || style().columnProgression() == NormalColumnProgression)
- return hasTopOverflow;
-
- if (!(isHorizontalWritingMode() ^ !style().hasInlineColumnAxis()))
- hasTopOverflow = !hasTopOverflow;
-
- return hasTopOverflow;
-}
-
-bool RenderBlock::isLeftLayoutOverflowAllowed() const
-{
- bool hasLeftOverflow = RenderBox::isLeftLayoutOverflowAllowed();
- if (!hasColumns() || style().columnProgression() == NormalColumnProgression)
- return hasLeftOverflow;
-
- if (isHorizontalWritingMode() ^ !style().hasInlineColumnAxis())
- hasLeftOverflow = !hasLeftOverflow;
-
- return hasLeftOverflow;
-}
-
</del><span class="cx"> bool RenderBlock::expandsToEncloseOverhangingFloats() const
</span><span class="cx"> {
</span><span class="cx"> return isInlineBlockOrInlineTable() || isFloatingOrOutOfFlowPositioned() || hasOverflowClip() || (parent() && parent()->isFlexibleBoxIncludingDeprecated())
</span><del>- || hasColumns() || isTableCell() || isTableCaption() || isFieldset() || isWritingModeRoot() || isRoot() || isRenderFlowThread();
</del><ins>+ || isTableCell() || isTableCaption() || isFieldset() || isWritingModeRoot() || isRoot() || isRenderFlowThread();
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> LayoutUnit RenderBlock::computeStartPositionDeltaForChildAvoidingFloats(const RenderBox& child, LayoutUnit childMarginStart, RenderRegion* region)
</span><span class="lines">@@ -1602,7 +1279,7 @@
</span><span class="cx"> if ((!posChildNeedsLayout() && !needsSimplifiedNormalFlowLayout()) || normalChildNeedsLayout() || selfNeedsLayout())
</span><span class="cx"> return false;
</span><span class="cx">
</span><del>- LayoutStateMaintainer statePusher(view(), *this, locationOffset(), hasColumns() || hasTransform() || hasReflection() || style().isFlippedBlocksWritingMode());
</del><ins>+ LayoutStateMaintainer statePusher(view(), *this, locationOffset(), hasTransform() || hasReflection() || style().isFlippedBlocksWritingMode());
</ins><span class="cx">
</span><span class="cx"> if (needsPositionedMovementLayout() && !tryLayoutDoingPositionedMovementOnly())
</span><span class="cx"> return false;
</span><span class="lines">@@ -1696,9 +1373,6 @@
</span><span class="cx"> TrackedRendererListHashSet* positionedDescendants = positionedObjects();
</span><span class="cx"> if (!positionedDescendants)
</span><span class="cx"> return;
</span><del>-
- if (hasColumns())
- view().layoutState()->clearPaginationInformation(); // Positioned objects are not part of the column flow, so they don't paginate with the columns.
</del><span class="cx">
</span><span class="cx"> for (auto it = positionedDescendants->begin(), end = positionedDescendants->end(); it != end; ++it) {
</span><span class="cx"> RenderBox& r = **it;
</span><span class="lines">@@ -1758,9 +1432,6 @@
</span><span class="cx"> r.layoutIfNeeded();
</span><span class="cx"> }
</span><span class="cx"> }
</span><del>-
- if (hasColumns())
- view().layoutState()->m_columnInfo = columnInfo(); // FIXME: Kind of gross. We just put this back into the layout state so that pop() will work.
</del><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void RenderBlock::markPositionedObjectsForLayout()
</span><span class="lines">@@ -1824,173 +1495,6 @@
</span><span class="cx"> layer()->paintOverflowControls(paintInfo.context, roundedIntPoint(adjustedPaintOffset), pixelSnappedIntRect(paintInfo.rect));
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void RenderBlock::paintColumnRules(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
-{
- if (!hasColumns() || paintInfo.context->paintingDisabled())
- return;
-
- const Color& ruleColor = style().visitedDependentColor(CSSPropertyWebkitColumnRuleColor);
- bool ruleTransparent = style().columnRuleIsTransparent();
- EBorderStyle ruleStyle = style().columnRuleStyle();
- LayoutUnit ruleThickness = style().columnRuleWidth();
- LayoutUnit colGap = columnGap();
- bool renderRule = ruleStyle > BHIDDEN && !ruleTransparent;
- if (!renderRule)
- return;
-
- ColumnInfo* colInfo = columnInfo();
- unsigned colCount = columnCount(colInfo);
-
- bool antialias = shouldAntialiasLines(paintInfo.context);
-
- if (colInfo->progressionIsInline()) {
- bool leftToRight = style().isLeftToRightDirection() ^ colInfo->progressionIsReversed();
- LayoutUnit currLogicalLeftOffset = leftToRight ? LayoutUnit() : contentLogicalWidth();
- LayoutUnit ruleAdd = logicalLeftOffsetForContent();
- LayoutUnit ruleLogicalLeft = leftToRight ? LayoutUnit() : contentLogicalWidth();
- LayoutUnit inlineDirectionSize = colInfo->desiredColumnWidth();
- BoxSide boxSide = isHorizontalWritingMode()
- ? leftToRight ? BSLeft : BSRight
- : leftToRight ? BSTop : BSBottom;
-
- for (unsigned i = 0; i < colCount; i++) {
- // Move to the next position.
- if (leftToRight) {
- ruleLogicalLeft += inlineDirectionSize + colGap / 2;
- currLogicalLeftOffset += inlineDirectionSize + colGap;
- } else {
- ruleLogicalLeft -= (inlineDirectionSize + colGap / 2);
- currLogicalLeftOffset -= (inlineDirectionSize + colGap);
- }
-
- // Now paint the column rule.
- if (i < colCount - 1) {
- LayoutUnit ruleLeft = isHorizontalWritingMode() ? paintOffset.x() + ruleLogicalLeft - ruleThickness / 2 + ruleAdd : paintOffset.x() + borderLeft() + paddingLeft();
- LayoutUnit ruleRight = isHorizontalWritingMode() ? ruleLeft + ruleThickness : ruleLeft + contentWidth();
- LayoutUnit ruleTop = isHorizontalWritingMode() ? paintOffset.y() + borderTop() + paddingTop() : paintOffset.y() + ruleLogicalLeft - ruleThickness / 2 + ruleAdd;
- LayoutUnit ruleBottom = isHorizontalWritingMode() ? ruleTop + contentHeight() : ruleTop + ruleThickness;
- IntRect pixelSnappedRuleRect = pixelSnappedIntRectFromEdges(ruleLeft, ruleTop, ruleRight, ruleBottom);
- drawLineForBoxSide(paintInfo.context, pixelSnappedRuleRect.x(), pixelSnappedRuleRect.y(), pixelSnappedRuleRect.maxX(), pixelSnappedRuleRect.maxY(), boxSide, ruleColor, ruleStyle, 0, 0, antialias);
- }
-
- ruleLogicalLeft = currLogicalLeftOffset;
- }
- } else {
- bool topToBottom = !style().isFlippedBlocksWritingMode() ^ colInfo->progressionIsReversed();
- LayoutUnit ruleLeft = isHorizontalWritingMode()
- ? borderLeft() + paddingLeft()
- : colGap / 2 - colGap - ruleThickness / 2 + (!colInfo->progressionIsReversed() ? borderAndPaddingBefore() : borderAndPaddingAfter());
- LayoutUnit ruleWidth = isHorizontalWritingMode() ? contentWidth() : ruleThickness;
- LayoutUnit ruleTop = isHorizontalWritingMode()
- ? colGap / 2 - colGap - ruleThickness / 2 + (!colInfo->progressionIsReversed() ? borderAndPaddingBefore() : borderAndPaddingAfter())
- : borderStart() + paddingStart();
- LayoutUnit ruleHeight = isHorizontalWritingMode() ? ruleThickness : contentHeight();
- LayoutRect ruleRect(ruleLeft, ruleTop, ruleWidth, ruleHeight);
-
- if (!topToBottom) {
- if (isHorizontalWritingMode())
- ruleRect.setY(height() - ruleRect.maxY());
- else
- ruleRect.setX(width() - ruleRect.maxX());
- }
-
- ruleRect.moveBy(paintOffset);
-
- BoxSide boxSide = isHorizontalWritingMode()
- ? topToBottom ? BSTop : BSBottom
- : topToBottom ? BSLeft : BSRight;
-
- LayoutSize step(0, topToBottom ? colInfo->columnHeight() + colGap : -(colInfo->columnHeight() + colGap));
- if (!isHorizontalWritingMode())
- step = step.transposedSize();
-
- for (unsigned i = 1; i < colCount; i++) {
- ruleRect.move(step);
- IntRect pixelSnappedRuleRect = pixelSnappedIntRect(ruleRect);
- drawLineForBoxSide(paintInfo.context, pixelSnappedRuleRect.x(), pixelSnappedRuleRect.y(), pixelSnappedRuleRect.maxX(), pixelSnappedRuleRect.maxY(), boxSide, ruleColor, ruleStyle, 0, 0, antialias);
- }
- }
-}
-
-LayoutUnit RenderBlock::initialBlockOffsetForPainting() const
-{
- ColumnInfo* colInfo = columnInfo();
- LayoutUnit result = 0;
- if (!colInfo->progressionIsInline() && colInfo->progressionIsReversed()) {
- LayoutRect colRect = columnRectAt(colInfo, 0);
- result = isHorizontalWritingMode() ? colRect.y() : colRect.x();
- result -= borderAndPaddingBefore();
- if (style().isFlippedBlocksWritingMode())
- result = -result;
- }
- return result;
-}
-
-LayoutUnit RenderBlock::blockDeltaForPaintingNextColumn() const
-{
- ColumnInfo* colInfo = columnInfo();
- LayoutUnit blockDelta = -colInfo->columnHeight();
- LayoutUnit colGap = columnGap();
- if (!colInfo->progressionIsInline()) {
- if (!colInfo->progressionIsReversed())
- blockDelta = colGap;
- else
- blockDelta -= (colInfo->columnHeight() + colGap);
- }
- if (style().isFlippedBlocksWritingMode())
- blockDelta = -blockDelta;
- return blockDelta;
-}
-
-void RenderBlock::paintColumnContents(PaintInfo& paintInfo, const LayoutPoint& paintOffset, bool paintingFloats)
-{
- // We need to do multiple passes, breaking up our child painting into strips.
- GraphicsContext* context = paintInfo.context;
- ColumnInfo* colInfo = columnInfo();
- unsigned colCount = columnCount(colInfo);
- if (!colCount)
- return;
- LayoutUnit colGap = columnGap();
- LayoutUnit currLogicalTopOffset = initialBlockOffsetForPainting();
- LayoutUnit blockDelta = blockDeltaForPaintingNextColumn();
- for (unsigned i = 0; i < colCount; i++) {
- // For each rect, we clip to the rect, and then we adjust our coords.
- LayoutRect colRect = columnRectAt(colInfo, i);
- flipForWritingMode(colRect);
-
- LayoutUnit logicalLeftOffset = (isHorizontalWritingMode() ? colRect.x() : colRect.y()) - logicalLeftOffsetForContent();
- LayoutSize offset = isHorizontalWritingMode() ? LayoutSize(logicalLeftOffset, currLogicalTopOffset) : LayoutSize(currLogicalTopOffset, logicalLeftOffset);
- colRect.moveBy(paintOffset);
- PaintInfo info(paintInfo);
- info.rect.intersect(pixelSnappedIntRect(colRect));
-
- if (!info.rect.isEmpty()) {
- GraphicsContextStateSaver stateSaver(*context);
- LayoutRect clipRect(colRect);
-
- if (i < colCount - 1) {
- if (isHorizontalWritingMode())
- clipRect.expand(colGap / 2, 0);
- else
- clipRect.expand(0, colGap / 2);
- }
- // Each strip pushes a clip, since column boxes are specified as being
- // like overflow:hidden.
- // FIXME: Content and column rules that extend outside column boxes at the edges of the multi-column element
- // are clipped according to the 'overflow' property.
- context->clip(pixelSnappedIntRect(clipRect));
-
- // Adjust our x and y when painting.
- LayoutPoint adjustedPaintOffset = paintOffset + offset;
- if (paintingFloats)
- paintFloats(info, adjustedPaintOffset, paintInfo.phase == PaintPhaseSelection || paintInfo.phase == PaintPhaseTextClip);
- else
- paintContents(info, adjustedPaintOffset);
- }
- currLogicalTopOffset += blockDelta;
- }
-}
-
</del><span class="cx"> void RenderBlock::paintContents(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
</span><span class="cx"> {
</span><span class="cx"> // Avoid painting descendants of the root element when stylesheets haven't loaded. This eliminates FOUC.
</span><span class="lines">@@ -2139,26 +1643,18 @@
</span><span class="cx"> return;
</span><span class="cx">
</span><span class="cx"> // 2. paint contents
</span><del>- if (paintPhase != PaintPhaseSelfOutline) {
- if (hasColumns())
- paintColumnContents(paintInfo, scrolledOffset);
- else
- paintContents(paintInfo, scrolledOffset);
- }
</del><ins>+ if (paintPhase != PaintPhaseSelfOutline)
+ paintContents(paintInfo, scrolledOffset);
</ins><span class="cx">
</span><span class="cx"> // 3. paint selection
</span><span class="cx"> // FIXME: Make this work with multi column layouts. For now don't fill gaps.
</span><span class="cx"> bool isPrinting = document().printing();
</span><del>- if (!isPrinting && !hasColumns())
</del><ins>+ if (!isPrinting)
</ins><span class="cx"> paintSelection(paintInfo, scrolledOffset); // Fill in gaps in selection on lines and between blocks.
</span><span class="cx">
</span><span class="cx"> // 4. paint floats.
</span><del>- if (paintPhase == PaintPhaseFloat || paintPhase == PaintPhaseSelection || paintPhase == PaintPhaseTextClip) {
- if (hasColumns())
- paintColumnContents(paintInfo, scrolledOffset, true);
- else
- paintFloats(paintInfo, scrolledOffset, paintPhase == PaintPhaseSelection || paintPhase == PaintPhaseTextClip);
- }
</del><ins>+ if (paintPhase == PaintPhaseFloat || paintPhase == PaintPhaseSelection || paintPhase == PaintPhaseTextClip)
+ paintFloats(paintInfo, scrolledOffset, paintPhase == PaintPhaseSelection || paintPhase == PaintPhaseTextClip);
</ins><span class="cx">
</span><span class="cx"> // 5. paint outline.
</span><span class="cx"> if ((paintPhase == PaintPhaseOutline || paintPhase == PaintPhaseSelfOutline) && hasOutline() && style().visibility() == VISIBLE)
</span><span class="lines">@@ -2413,7 +1909,7 @@
</span><span class="cx"> if (!isRenderBlockFlow()) // FIXME: Make multi-column selection gap filling work someday.
</span><span class="cx"> return result;
</span><span class="cx">
</span><del>- if (hasColumns() || hasTransform() || style().columnSpan() == ColumnSpanAll || isInFlowRenderFlowThread()) {
</del><ins>+ if (hasTransform() || style().columnSpan() == ColumnSpanAll || isInFlowRenderFlowThread()) {
</ins><span class="cx"> // FIXME: We should learn how to gap fill multiple columns and transforms eventually.
</span><span class="cx"> lastLogicalTop = blockDirectionOffset(rootBlock, offsetFromRootBlock) + logicalHeight();
</span><span class="cx"> lastLogicalLeft = logicalLeftSelectionOffset(rootBlock, logicalHeight(), cache);
</span><span class="lines">@@ -2994,18 +2490,12 @@
</span><span class="cx"> // Hit test descendants first.
</span><span class="cx"> LayoutSize scrolledOffset(localOffset - scrolledContentOffset());
</span><span class="cx">
</span><del>- // Hit test contents if we don't have columns.
- if (!hasColumns()) {
- if (hitTestContents(request, result, locationInContainer, toLayoutPoint(scrolledOffset), hitTestAction)) {
- updateHitTestResult(result, flipForWritingMode(locationInContainer.point() - localOffset));
- return true;
- }
- if (hitTestAction == HitTestFloat && hitTestFloats(request, result, locationInContainer, toLayoutPoint(scrolledOffset)))
- return true;
- } else if (hitTestColumns(request, result, locationInContainer, toLayoutPoint(scrolledOffset), hitTestAction)) {
</del><ins>+ if (hitTestContents(request, result, locationInContainer, toLayoutPoint(scrolledOffset), hitTestAction)) {
</ins><span class="cx"> updateHitTestResult(result, flipForWritingMode(locationInContainer.point() - localOffset));
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><ins>+ if (hitTestAction == HitTestFloat && hitTestFloats(request, result, locationInContainer, toLayoutPoint(scrolledOffset)))
+ return true;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // Check if the point is outside radii.
</span><span class="lines">@@ -3030,98 +2520,6 @@
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-class ColumnRectIterator {
- WTF_MAKE_NONCOPYABLE(ColumnRectIterator);
-public:
- ColumnRectIterator(const RenderBlock& block)
- : m_block(block)
- , m_colInfo(block.columnInfo())
- , m_direction(m_block.style().isFlippedBlocksWritingMode() ? 1 : -1)
- , m_isHorizontal(block.isHorizontalWritingMode())
- , m_logicalLeft(block.logicalLeftOffsetForContent())
- {
- int colCount = m_colInfo->columnCount();
- m_colIndex = colCount - 1;
-
- m_currLogicalTopOffset = m_block.initialBlockOffsetForPainting();
- m_currLogicalTopOffset = colCount * m_block.blockDeltaForPaintingNextColumn();
-
- update();
- }
-
- void advance()
- {
- ASSERT(hasMore());
- m_colIndex--;
- update();
- }
-
- LayoutRect columnRect() const { return m_colRect; }
- bool hasMore() const { return m_colIndex >= 0; }
-
- void adjust(LayoutSize& offset) const
- {
- LayoutUnit currLogicalLeftOffset = (m_isHorizontal ? m_colRect.x() : m_colRect.y()) - m_logicalLeft;
- offset += m_isHorizontal ? LayoutSize(currLogicalLeftOffset, m_currLogicalTopOffset) : LayoutSize(m_currLogicalTopOffset, currLogicalLeftOffset);
- }
-
-private:
- void update()
- {
- if (m_colIndex < 0)
- return;
- m_colRect = m_block.columnRectAt(const_cast<ColumnInfo*>(m_colInfo), m_colIndex);
- m_block.flipForWritingMode(m_colRect);
- m_currLogicalTopOffset -= m_block.blockDeltaForPaintingNextColumn();
- }
-
- const RenderBlock& m_block;
- const ColumnInfo* const m_colInfo;
- const int m_direction;
- const bool m_isHorizontal;
- const LayoutUnit m_logicalLeft;
- int m_colIndex;
- LayoutUnit m_currLogicalTopOffset;
- LayoutRect m_colRect;
-};
-
-bool RenderBlock::hitTestColumns(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction hitTestAction)
-{
- // We need to do multiple passes, breaking up our hit testing into strips.
- if (!hasColumns())
- return false;
-
- for (ColumnRectIterator it(*this); it.hasMore(); it.advance()) {
- LayoutRect hitRect = locationInContainer.boundingBox();
- LayoutRect colRect = it.columnRect();
- colRect.moveBy(accumulatedOffset);
- if (locationInContainer.intersects(colRect)) {
- // The point is inside this column.
- // Adjust accumulatedOffset to change where we hit test.
- LayoutSize offset;
- it.adjust(offset);
- LayoutPoint finalLocation = accumulatedOffset + offset;
- if (!result.isRectBasedTest() || colRect.contains(hitRect))
- return hitTestContents(request, result, locationInContainer, finalLocation, hitTestAction) || (hitTestAction == HitTestFloat && hitTestFloats(request, result, locationInContainer, finalLocation));
-
- hitTestContents(request, result, locationInContainer, finalLocation, hitTestAction);
- }
- }
-
- return false;
-}
-
-void RenderBlock::adjustForColumnRect(LayoutSize& offset, const LayoutPoint& locationInContainer) const
-{
- for (ColumnRectIterator it(*this); it.hasMore(); it.advance()) {
- LayoutRect colRect = it.columnRect();
- if (colRect.contains(locationInContainer)) {
- it.adjust(offset);
- return;
- }
- }
-}
-
</del><span class="cx"> bool RenderBlock::hitTestContents(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction hitTestAction)
</span><span class="cx"> {
</span><span class="cx"> if (childrenInline() && !isTable())
</span><span class="lines">@@ -3272,418 +2670,17 @@
</span><span class="cx"> {
</span><span class="cx"> offset = flipForWritingMode(offset);
</span><span class="cx"> offset += scrolledContentOffset();
</span><del>-
- if (hasColumns())
- adjustPointToColumnContents(offset);
-
</del><span class="cx"> offset = flipForWritingMode(offset);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-LayoutUnit RenderBlock::availableLogicalWidth() const
</del><ins>+void RenderBlock::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
</ins><span class="cx"> {
</span><del>- // If we have multiple columns, then the available logical width is reduced to our column width.
- if (hasColumns())
- return computedColumnWidth();
- return RenderBox::availableLogicalWidth();
-}
-
-int RenderBlock::columnGap() const
-{
- if (style().hasNormalColumnGap())
- return style().fontDescription().computedPixelSize(); // "1em" is recommended as the normal gap setting. Matches <p> margins.
- return static_cast<int>(style().columnGap());
-}
-
-void RenderBlock::computeColumnCountAndWidth()
-{
- // Calculate our column width and column count.
- // FIXME: Can overflow on fast/block/float/float-not-removed-from-next-sibling4.html, see https://bugs.webkit.org/show_bug.cgi?id=68744
- unsigned desiredColumnCount = 1;
- LayoutUnit desiredColumnWidth = contentLogicalWidth();
</del><ins>+ ASSERT(!childrenInline());
</ins><span class="cx">
</span><del>- // For now, we don't support multi-column layouts when printing, since we have to do a lot of work for proper pagination.
- if (document().paginated() || (style().hasAutoColumnCount() && style().hasAutoColumnWidth()) || !style().hasInlineColumnAxis()) {
- setComputedColumnCountAndWidth(desiredColumnCount, desiredColumnWidth);
- return;
- }
-
- LayoutUnit availWidth = desiredColumnWidth;
- LayoutUnit colGap = columnGap();
- LayoutUnit colWidth = std::max<LayoutUnit>(LayoutUnit::fromPixel(1), LayoutUnit(style().columnWidth()));
- int colCount = std::max<int>(1, style().columnCount());
</del><ins>+ computeBlockPreferredLogicalWidths(minLogicalWidth, maxLogicalWidth);
</ins><span class="cx">
</span><del>- if (style().hasAutoColumnWidth() && !style().hasAutoColumnCount()) {
- desiredColumnCount = colCount;
- desiredColumnWidth = std::max<LayoutUnit>(0, (availWidth - ((desiredColumnCount - 1) * colGap)) / desiredColumnCount);
- } else if (!style().hasAutoColumnWidth() && style().hasAutoColumnCount()) {
- desiredColumnCount = std::max<LayoutUnit>(1, (availWidth + colGap) / (colWidth + colGap));
- desiredColumnWidth = ((availWidth + colGap) / desiredColumnCount) - colGap;
- } else {
- desiredColumnCount = std::max<LayoutUnit>(std::min<LayoutUnit>(colCount, (availWidth + colGap) / (colWidth + colGap)), 1);
- desiredColumnWidth = ((availWidth + colGap) / desiredColumnCount) - colGap;
- }
- setComputedColumnCountAndWidth(desiredColumnCount, desiredColumnWidth);
-}
-
-bool RenderBlock::requiresColumns(int desiredColumnCount) const
-{
- // If overflow-y is set to paged-x or paged-y on the body or html element, we'll handle the paginating
- // in the RenderView instead.
- bool isPaginated = (style().overflowY() == OPAGEDX || style().overflowY() == OPAGEDY) && !(isRoot() || isBody());
-
- return firstChild()
- && (desiredColumnCount != 1 || !style().hasAutoColumnWidth() || !style().hasInlineColumnAxis() || isPaginated)
- && !firstChild()->isAnonymousColumnsBlock()
- && !firstChild()->isAnonymousColumnSpanBlock();
-}
-
-void RenderBlock::setComputedColumnCountAndWidth(int count, LayoutUnit width)
-{
- bool destroyColumns = !requiresColumns(count);
- if (destroyColumns) {
- if (hasColumns()) {
- gColumnInfoMap->take(this);
- setHasColumns(false);
- }
- } else {
- ColumnInfo* info;
- if (hasColumns())
- info = gColumnInfoMap->get(this);
- else {
- if (!gColumnInfoMap)
- gColumnInfoMap = new ColumnInfoMap;
- info = new ColumnInfo;
- gColumnInfoMap->add(this, std::unique_ptr<ColumnInfo>(info));
- setHasColumns(true);
- }
- info->setDesiredColumnCount(count);
- info->setDesiredColumnWidth(width);
- info->setProgressionIsInline(style().hasInlineColumnAxis());
- info->setProgressionIsReversed(style().columnProgression() == ReverseColumnProgression);
- }
-}
-
-void RenderBlock::updateColumnProgressionFromStyle(RenderStyle* style)
-{
- if (!hasColumns())
- return;
-
- ColumnInfo* info = gColumnInfoMap->get(this);
-
- bool needsLayout = false;
- bool oldProgressionIsInline = info->progressionIsInline();
- bool newProgressionIsInline = style->hasInlineColumnAxis();
- if (oldProgressionIsInline != newProgressionIsInline) {
- info->setProgressionIsInline(newProgressionIsInline);
- needsLayout = true;
- }
-
- bool oldProgressionIsReversed = info->progressionIsReversed();
- bool newProgressionIsReversed = style->columnProgression() == ReverseColumnProgression;
- if (oldProgressionIsReversed != newProgressionIsReversed) {
- info->setProgressionIsReversed(newProgressionIsReversed);
- needsLayout = true;
- }
-
- if (needsLayout)
- setNeedsLayoutAndPrefWidthsRecalc();
-}
-
-LayoutUnit RenderBlock::computedColumnWidth() const
-{
- if (!hasColumns())
- return contentLogicalWidth();
- return gColumnInfoMap->get(this)->desiredColumnWidth();
-}
-
-unsigned RenderBlock::computedColumnCount() const
-{
- if (!hasColumns())
- return 1;
- return gColumnInfoMap->get(this)->desiredColumnCount();
-}
-
-ColumnInfo* RenderBlock::columnInfo() const
-{
- if (!hasColumns())
- return 0;
- return gColumnInfoMap->get(this);
-}
-
-unsigned RenderBlock::columnCount(ColumnInfo* colInfo) const
-{
- ASSERT(hasColumns());
- ASSERT(gColumnInfoMap->get(this) == colInfo);
- return colInfo->columnCount();
-}
-
-LayoutRect RenderBlock::columnRectAt(ColumnInfo* colInfo, unsigned index) const
-{
- ASSERT(hasColumns() && gColumnInfoMap->get(this) == colInfo);
-
- // Compute the appropriate rect based off our information.
- LayoutUnit colLogicalWidth = colInfo->desiredColumnWidth();
- LayoutUnit colLogicalHeight = colInfo->columnHeight();
- LayoutUnit colLogicalTop = borderAndPaddingBefore();
- LayoutUnit colLogicalLeft = logicalLeftOffsetForContent();
- LayoutUnit colGap = columnGap();
- if (colInfo->progressionIsInline()) {
- if (style().isLeftToRightDirection() ^ colInfo->progressionIsReversed())
- colLogicalLeft += index * (colLogicalWidth + colGap);
- else
- colLogicalLeft += contentLogicalWidth() - colLogicalWidth - index * (colLogicalWidth + colGap);
- } else {
- if (!colInfo->progressionIsReversed())
- colLogicalTop += index * (colLogicalHeight + colGap);
- else
- colLogicalTop += contentLogicalHeight() - colLogicalHeight - index * (colLogicalHeight + colGap);
- }
-
- if (isHorizontalWritingMode())
- return LayoutRect(colLogicalLeft, colLogicalTop, colLogicalWidth, colLogicalHeight);
- return LayoutRect(colLogicalTop, colLogicalLeft, colLogicalHeight, colLogicalWidth);
-}
-
-void RenderBlock::adjustPointToColumnContents(LayoutPoint& point) const
-{
- // Just bail if we have no columns.
- if (!hasColumns())
- return;
-
- ColumnInfo* colInfo = columnInfo();
- if (!columnCount(colInfo))
- return;
-
- // Determine which columns we intersect.
- LayoutUnit colGap = columnGap();
- LayoutUnit halfColGap = colGap / 2;
- LayoutPoint columnPoint(columnRectAt(colInfo, 0).location());
- LayoutUnit logicalOffset = 0;
- for (unsigned i = 0; i < colInfo->columnCount(); i++) {
- // Add in half the column gap to the left and right of the rect.
- LayoutRect colRect = columnRectAt(colInfo, i);
- flipForWritingMode(colRect);
- if (isHorizontalWritingMode() == colInfo->progressionIsInline()) {
- LayoutRect gapAndColumnRect(colRect.x() - halfColGap, colRect.y(), colRect.width() + colGap, colRect.height());
- if (point.x() >= gapAndColumnRect.x() && point.x() < gapAndColumnRect.maxX()) {
- if (colInfo->progressionIsInline()) {
- // FIXME: The clamping that follows is not completely right for right-to-left
- // content.
- // Clamp everything above the column to its top left.
- if (point.y() < gapAndColumnRect.y())
- point = gapAndColumnRect.location();
- // Clamp everything below the column to the next column's top left. If there is
- // no next column, this still maps to just after this column.
- else if (point.y() >= gapAndColumnRect.maxY()) {
- point = gapAndColumnRect.location();
- point.move(0, gapAndColumnRect.height());
- }
- } else {
- if (point.x() < colRect.x())
- point.setX(colRect.x());
- else if (point.x() >= colRect.maxX())
- point.setX(colRect.maxX() - 1);
- }
-
- // We're inside the column. Translate the x and y into our column coordinate space.
- if (colInfo->progressionIsInline())
- point.move(columnPoint.x() - colRect.x(), (!style().isFlippedBlocksWritingMode() ? logicalOffset : -logicalOffset));
- else
- point.move((!style().isFlippedBlocksWritingMode() ? logicalOffset : -logicalOffset) - colRect.x() + borderLeft() + paddingLeft(), 0);
- return;
- }
-
- // Move to the next position.
- logicalOffset += colInfo->progressionIsInline() ? colRect.height() : colRect.width();
- } else {
- LayoutRect gapAndColumnRect(colRect.x(), colRect.y() - halfColGap, colRect.width(), colRect.height() + colGap);
- if (point.y() >= gapAndColumnRect.y() && point.y() < gapAndColumnRect.maxY()) {
- if (colInfo->progressionIsInline()) {
- // FIXME: The clamping that follows is not completely right for right-to-left
- // content.
- // Clamp everything above the column to its top left.
- if (point.x() < gapAndColumnRect.x())
- point = gapAndColumnRect.location();
- // Clamp everything below the column to the next column's top left. If there is
- // no next column, this still maps to just after this column.
- else if (point.x() >= gapAndColumnRect.maxX()) {
- point = gapAndColumnRect.location();
- point.move(gapAndColumnRect.width(), 0);
- }
- } else {
- if (point.y() < colRect.y())
- point.setY(colRect.y());
- else if (point.y() >= colRect.maxY())
- point.setY(colRect.maxY() - 1);
- }
-
- // We're inside the column. Translate the x and y into our column coordinate space.
- if (colInfo->progressionIsInline())
- point.move((!style().isFlippedBlocksWritingMode() ? logicalOffset : -logicalOffset), columnPoint.y() - colRect.y());
- else
- point.move(0, (!style().isFlippedBlocksWritingMode() ? logicalOffset : -logicalOffset) - colRect.y() + borderTop() + paddingTop());
- return;
- }
-
- // Move to the next position.
- logicalOffset += colInfo->progressionIsInline() ? colRect.width() : colRect.height();
- }
- }
-}
-
-void RenderBlock::adjustRectForColumns(LayoutRect& r) const
-{
- // Just bail if we have no columns.
- if (!hasColumns())
- return;
-
- ColumnInfo* colInfo = columnInfo();
-
- // Determine which columns we intersect.
- unsigned colCount = columnCount(colInfo);
- if (!colCount)
- return;
-
- // Begin with a result rect that is empty.
- LayoutRect result;
-
- bool isHorizontal = isHorizontalWritingMode();
- LayoutUnit beforeBorderPadding = borderAndPaddingBefore();
- LayoutUnit colHeight = colInfo->columnHeight();
- if (!colHeight)
- return;
-
- LayoutUnit startOffset = std::max(isHorizontal ? r.y() : r.x(), beforeBorderPadding);
- LayoutUnit endOffset = std::max(std::min<LayoutUnit>(isHorizontal ? r.maxY() : r.maxX(), beforeBorderPadding + colCount * colHeight), beforeBorderPadding);
-
- // FIXME: Can overflow on fast/block/float/float-not-removed-from-next-sibling4.html, see https://bugs.webkit.org/show_bug.cgi?id=68744
- unsigned startColumn = (startOffset - beforeBorderPadding) / colHeight;
- unsigned endColumn = (endOffset - beforeBorderPadding) / colHeight;
-
- if (startColumn == endColumn) {
- // The rect is fully contained within one column. Adjust for our offsets
- // and repaint only that portion.
- LayoutUnit logicalLeftOffset = logicalLeftOffsetForContent();
- LayoutRect colRect = columnRectAt(colInfo, startColumn);
- LayoutRect repaintRect = r;
-
- if (colInfo->progressionIsInline()) {
- if (isHorizontal)
- repaintRect.move(colRect.x() - logicalLeftOffset, - static_cast<int>(startColumn) * colHeight);
- else
- repaintRect.move(- static_cast<int>(startColumn) * colHeight, colRect.y() - logicalLeftOffset);
- } else {
- if (isHorizontal)
- repaintRect.move(0, colRect.y() - startColumn * colHeight - beforeBorderPadding);
- else
- repaintRect.move(colRect.x() - startColumn * colHeight - beforeBorderPadding, 0);
- }
- repaintRect.intersect(colRect);
- result.unite(repaintRect);
- } else {
- // We span multiple columns. We can just unite the start and end column to get the final
- // repaint rect.
- result.unite(columnRectAt(colInfo, startColumn));
- result.unite(columnRectAt(colInfo, endColumn));
- }
-
- r = result;
-}
-
-LayoutPoint RenderBlock::flipForWritingModeIncludingColumns(const LayoutPoint& point) const
-{
- ASSERT(hasColumns());
- if (!hasColumns() || !style().isFlippedBlocksWritingMode())
- return point;
- ColumnInfo* colInfo = columnInfo();
- LayoutUnit columnLogicalHeight = colInfo->columnHeight();
- LayoutUnit expandedLogicalHeight = borderAndPaddingBefore() + columnCount(colInfo) * columnLogicalHeight + borderAndPaddingAfter() + scrollbarLogicalHeight();
- if (isHorizontalWritingMode())
- return LayoutPoint(point.x(), expandedLogicalHeight - point.y());
- return LayoutPoint(expandedLogicalHeight - point.x(), point.y());
-}
-
-void RenderBlock::adjustStartEdgeForWritingModeIncludingColumns(LayoutRect& rect) const
-{
- ASSERT(hasColumns());
- if (!hasColumns() || !style().isFlippedBlocksWritingMode())
- return;
-
- ColumnInfo* colInfo = columnInfo();
- LayoutUnit columnLogicalHeight = colInfo->columnHeight();
- LayoutUnit expandedLogicalHeight = borderAndPaddingBefore() + columnCount(colInfo) * columnLogicalHeight + borderAndPaddingAfter() + scrollbarLogicalHeight();
-
- if (isHorizontalWritingMode())
- rect.setY(expandedLogicalHeight - rect.maxY());
- else
- rect.setX(expandedLogicalHeight - rect.maxX());
-}
-
-void RenderBlock::adjustForColumns(LayoutSize& offset, const LayoutPoint& point) const
-{
- if (!hasColumns())
- return;
-
- ColumnInfo* colInfo = columnInfo();
-
- LayoutUnit logicalLeft = logicalLeftOffsetForContent();
- unsigned colCount = columnCount(colInfo);
- LayoutUnit colLogicalWidth = colInfo->desiredColumnWidth();
- LayoutUnit colLogicalHeight = colInfo->columnHeight();
-
- for (unsigned i = 0; i < colCount; ++i) {
- // Compute the edges for a given column in the block progression direction.
- LayoutRect sliceRect = LayoutRect(logicalLeft, borderAndPaddingBefore() + i * colLogicalHeight, colLogicalWidth, colLogicalHeight);
- if (!isHorizontalWritingMode())
- sliceRect = sliceRect.transposedRect();
-
- LayoutUnit logicalOffset = i * colLogicalHeight;
-
- // Now we're in the same coordinate space as the point. See if it is inside the rectangle.
- if (isHorizontalWritingMode()) {
- if (point.y() >= sliceRect.y() && point.y() < sliceRect.maxY()) {
- if (colInfo->progressionIsInline())
- offset.expand(columnRectAt(colInfo, i).x() - logicalLeft, -logicalOffset);
- else
- offset.expand(0, columnRectAt(colInfo, i).y() - logicalOffset - borderAndPaddingBefore());
- return;
- }
- } else {
- if (point.x() >= sliceRect.x() && point.x() < sliceRect.maxX()) {
- if (colInfo->progressionIsInline())
- offset.expand(-logicalOffset, columnRectAt(colInfo, i).y() - logicalLeft);
- else
- offset.expand(columnRectAt(colInfo, i).x() - logicalOffset - borderAndPaddingBefore(), 0);
- return;
- }
- }
- }
-}
-
-void RenderBlock::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
-{
- if (childrenInline()) {
- // FIXME: Remove this const_cast.
- const_cast<RenderBlock*>(this)->computeInlinePreferredLogicalWidths(minLogicalWidth, maxLogicalWidth);
- } else
- computeBlockPreferredLogicalWidths(minLogicalWidth, maxLogicalWidth);
-
</del><span class="cx"> maxLogicalWidth = std::max(minLogicalWidth, maxLogicalWidth);
</span><span class="cx">
</span><del>- adjustIntrinsicLogicalWidthsForColumns(minLogicalWidth, maxLogicalWidth);
-
- if (!style().autoWrap() && childrenInline()) {
- // A horizontal marquee with inline children has no minimum width.
- if (layer() && layer()->marquee() && layer()->marquee()->isHorizontal())
- minLogicalWidth = 0;
- }
-
- if (isTableCell()) {
- Length tableCellWidth = toRenderTableCell(this)->styleOrColLogicalWidth();
- if (tableCellWidth.isFixed() && tableCellWidth.value() > 0)
- maxLogicalWidth = std::max(minLogicalWidth, adjustContentBoxLogicalWidthForBoxSizing(tableCellWidth.value()));
- }
-
</del><span class="cx"> int scrollbarWidth = instrinsicScrollbarLogicalWidth();
</span><span class="cx"> maxLogicalWidth += scrollbarWidth;
</span><span class="cx"> minLogicalWidth += scrollbarWidth;
</span><span class="lines">@@ -3728,32 +2725,6 @@
</span><span class="cx"> setPreferredLogicalWidthsDirty(false);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void RenderBlock::adjustIntrinsicLogicalWidthsForColumns(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
-{
- // FIXME: Move this code to RenderBlockFlow.
-
- if (!style().hasAutoColumnCount() || !style().hasAutoColumnWidth()) {
- // The min/max intrinsic widths calculated really tell how much space elements need when
- // laid out inside the columns. In order to eventually end up with the desired column width,
- // we need to convert them to values pertaining to the multicol container.
- int columnCount = style().hasAutoColumnCount() ? 1 : style().columnCount();
- LayoutUnit columnWidth;
- LayoutUnit gapExtra = (columnCount - 1) * columnGap();
- if (style().hasAutoColumnWidth())
- minLogicalWidth = minLogicalWidth * columnCount + gapExtra;
- else {
- columnWidth = style().columnWidth();
- minLogicalWidth = std::min(minLogicalWidth, columnWidth);
- }
- // FIXME: If column-count is auto here, we should resolve it to calculate the maximum
- // intrinsic width, instead of pretending that it's 1. The only way to do that is by
- // performing a layout pass, but this is not an appropriate time or place for layout. The
- // good news is that if height is unconstrained and there are no explicit breaks, the
- // resolved column-count really should be 1.
- maxLogicalWidth = std::max(maxLogicalWidth, columnWidth) * columnCount + gapExtra;
- }
-}
-
</del><span class="cx"> struct InlineMinMaxIterator {
</span><span class="cx"> /* InlineMinMaxIterator is a class that will iterate over all render objects that contribute to
</span><span class="cx"> inline min/max width calculations. Note the following about the way it walks:
</span><span class="lines">@@ -4822,18 +3793,9 @@
</span><span class="cx">
</span><span class="cx"> RenderBox* RenderBlock::createAnonymousBoxWithSameTypeAs(const RenderObject* parent) const
</span><span class="cx"> {
</span><del>- if (isAnonymousColumnsBlock())
- return createAnonymousColumnsWithParentRenderer(parent);
- if (isAnonymousColumnSpanBlock())
- return createAnonymousColumnSpanWithParentRenderer(parent);
</del><span class="cx"> return createAnonymousWithParentRendererAndDisplay(parent, style().display());
</span><span class="cx"> }
</span><span class="cx">
</span><del>-ColumnInfo::PaginationUnit RenderBlock::paginationUnit() const
-{
- return ColumnInfo::Column;
-}
-
</del><span class="cx"> LayoutUnit RenderBlock::offsetFromLogicalTopOfFirstPage() const
</span><span class="cx"> {
</span><span class="cx"> LayoutState* layoutState = view().layoutState();
</span><span class="lines">@@ -4884,8 +3846,7 @@
</span><span class="cx"> bool RenderBlock::childBoxIsUnsplittableForFragmentation(const RenderBox& child) const
</span><span class="cx"> {
</span><span class="cx"> RenderFlowThread* flowThread = flowThreadContainingBlock();
</span><del>- bool isInsideMulticolFlowThread = flowThread && !flowThread->isRenderNamedFlowThread();
- bool checkColumnBreaks = isInsideMulticolFlowThread || view().layoutState()->isPaginatingColumns();
</del><ins>+ bool checkColumnBreaks = flowThread && flowThread->shouldCheckColumnBreaks();
</ins><span class="cx"> bool checkPageBreaks = !checkColumnBreaks && view().layoutState()->m_pageLogicalHeight;
</span><span class="cx"> bool checkRegionBreaks = flowThread && flowThread->isRenderNamedFlowThread();
</span><span class="cx"> return child.isUnsplittableForPagination() || (checkColumnBreaks && child.style().columnBreakInside() == PBAVOID)
</span><span class="lines">@@ -5034,10 +3995,6 @@
</span><span class="cx"> return "RenderBlock (floating)";
</span><span class="cx"> if (isOutOfFlowPositioned())
</span><span class="cx"> return "RenderBlock (positioned)";
</span><del>- if (isAnonymousColumnsBlock())
- return "RenderBlock (anonymous multi-column)";
- if (isAnonymousColumnSpanBlock())
- return "RenderBlock (anonymous multi-column span)";
</del><span class="cx"> if (isAnonymousBlock())
</span><span class="cx"> return "RenderBlock (anonymous)";
</span><span class="cx"> // FIXME: Temporary hack while the new generated content system is being implemented.
</span><span class="lines">@@ -5134,72 +4091,6 @@
</span><span class="cx"> return newBox;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-RenderBlock* RenderBlock::createAnonymousColumnsWithParentRenderer(const RenderObject* parent)
-{
- auto newStyle = RenderStyle::createAnonymousStyleWithDisplay(&parent->style(), BLOCK);
- newStyle.get().inheritColumnPropertiesFrom(&parent->style());
-
- RenderBlock* newBox = new RenderBlockFlow(parent->document(), std::move(newStyle));
- newBox->initializeStyle();
- return newBox;
-}
-
-RenderBlock* RenderBlock::createAnonymousColumnSpanWithParentRenderer(const RenderObject* parent)
-{
- auto newStyle = RenderStyle::createAnonymousStyleWithDisplay(&parent->style(), BLOCK);
- newStyle.get().setColumnSpan(ColumnSpanAll);
-
- RenderBlock* newBox = new RenderBlockFlow(parent->document(), std::move(newStyle));
- newBox->initializeStyle();
- return newBox;
-}
-
-void RenderBlock::computeLineGridPaginationOrigin(LayoutState& layoutState) const
-{
- if (!hasColumns() || !style().hasInlineColumnAxis())
- return;
-
- // We need to cache a line grid pagination origin so that we understand how to reset the line grid
- // at the top of each column.
- // Get the current line grid and offset.
- const auto lineGrid = layoutState.lineGrid();
- if (!lineGrid)
- return;
-
- // Get the hypothetical line box used to establish the grid.
- auto lineGridBox = lineGrid->lineGridBox();
- if (!lineGridBox)
- return;
-
- bool isHorizontalWritingMode = lineGrid->isHorizontalWritingMode();
-
- LayoutUnit lineGridBlockOffset = isHorizontalWritingMode ? layoutState.lineGridOffset().height() : layoutState.lineGridOffset().width();
-
- // Now determine our position on the grid. Our baseline needs to be adjusted to the nearest baseline multiple
- // as established by the line box.
- // FIXME: Need to handle crazy line-box-contain values that cause the root line box to not be considered. I assume
- // the grid should honor line-box-contain.
- LayoutUnit gridLineHeight = lineGridBox->lineBottomWithLeading() - lineGridBox->lineTopWithLeading();
- if (!gridLineHeight)
- return;
-
- LayoutUnit firstLineTopWithLeading = lineGridBlockOffset + lineGridBox->lineTopWithLeading();
-
- if (layoutState.isPaginated() && layoutState.pageLogicalHeight()) {
- LayoutUnit pageLogicalTop = isHorizontalWritingMode ? layoutState.pageOffset().height() : layoutState.pageOffset().width();
- if (pageLogicalTop > firstLineTopWithLeading) {
- // Shift to the next highest line grid multiple past the page logical top. Cache the delta
- // between this new value and the page logical top as the pagination origin.
- LayoutUnit remainder = roundToInt(pageLogicalTop - firstLineTopWithLeading) % roundToInt(gridLineHeight);
- LayoutUnit paginationDelta = gridLineHeight - remainder;
- if (isHorizontalWritingMode)
- layoutState.setLineGridPaginationOrigin(LayoutSize(layoutState.lineGridPaginationOrigin().width(), paginationDelta));
- else
- layoutState.setLineGridPaginationOrigin(LayoutSize(paginationDelta, layoutState.lineGridPaginationOrigin().height()));
- }
- }
-}
-
</del><span class="cx"> #ifndef NDEBUG
</span><span class="cx"> void RenderBlock::checkPositionedObjectsNeedLayout()
</span><span class="cx"> {
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderBlockh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderBlock.h (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderBlock.h 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/Source/WebCore/rendering/RenderBlock.h 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -23,7 +23,6 @@
</span><span class="cx"> #ifndef RenderBlock_h
</span><span class="cx"> #define RenderBlock_h
</span><span class="cx">
</span><del>-#include "ColumnInfo.h"
</del><span class="cx"> #include "GapRects.h"
</span><span class="cx"> #include "RenderBox.h"
</span><span class="cx"> #include "TextRun.h"
</span><span class="lines">@@ -164,9 +163,7 @@
</span><span class="cx"> }
</span><span class="cx"> LayoutUnit pixelSnappedLogicalRightOffsetForLine(LayoutUnit position, bool shouldIndentText, LayoutUnit logicalHeight = 0) const
</span><span class="cx"> {
</span><del>- // FIXME: Multicolumn layouts break carrying over subpixel values to the logical right offset because the lines may be shifted
- // by a subpixel value for all but the first column. This can lead to the actual pixel snapped width of the column being off
- // by one pixel when rendered versus layed out, which can result in the line being clipped. For now, we have to floor.
</del><ins>+ // FIXME: Now that we have a new multicolumn implementation, can this be fixed?
</ins><span class="cx"> // https://bugs.webkit.org/show_bug.cgi?id=105461
</span><span class="cx"> return floorToInt(logicalRightOffsetForLine(position, shouldIndentText, logicalHeight));
</span><span class="cx"> }
</span><span class="lines">@@ -184,13 +181,7 @@
</span><span class="cx"> LayoutUnit textIndentOffset() const;
</span><span class="cx">
</span><span class="cx"> virtual VisiblePosition positionForPoint(const LayoutPoint&, const RenderRegion*) override;
</span><del>-
- // Block flows subclass availableWidth to handle multi column layout (shrinking the width available to children when laying out.)
- virtual LayoutUnit availableLogicalWidth() const override final;
</del><span class="cx">
</span><del>- LayoutPoint flipForWritingModeIncludingColumns(const LayoutPoint&) const;
- void adjustStartEdgeForWritingModeIncludingColumns(LayoutRect&) const;
-
</del><span class="cx"> GapRects selectionGapRectsForRepaint(const RenderLayerModelObject* repaintContainer);
</span><span class="cx"> LayoutRect logicalLeftSelectionGap(RenderBlock& rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
</span><span class="cx"> RenderObject* selObj, LayoutUnit logicalLeft, LayoutUnit logicalTop, LayoutUnit logicalHeight, const LogicalSelectionOffsetCaches&, const PaintInfo*);
</span><span class="lines">@@ -201,10 +192,6 @@
</span><span class="cx">
</span><span class="cx"> LayoutRect logicalRectToPhysicalRect(const LayoutPoint& physicalPosition, const LayoutRect& logicalRect);
</span><span class="cx">
</span><del>- void adjustRectForColumns(LayoutRect&) const;
- virtual void adjustForColumns(LayoutSize&, const LayoutPoint&) const override final;
- void adjustForColumnRect(LayoutSize& offset, const LayoutPoint& locationInContainer) const;
-
</del><span class="cx"> void addContinuationWithOutline(RenderInline*);
</span><span class="cx"> bool paintsContinuationOutline(RenderInline*);
</span><span class="cx">
</span><span class="lines">@@ -217,11 +204,7 @@
</span><span class="cx"> using RenderBoxModelObject::setContinuation;
</span><span class="cx">
</span><span class="cx"> static RenderBlock* createAnonymousWithParentRendererAndDisplay(const RenderObject*, EDisplay = BLOCK);
</span><del>- static RenderBlock* createAnonymousColumnsWithParentRenderer(const RenderObject*);
- static RenderBlock* createAnonymousColumnSpanWithParentRenderer(const RenderObject*);
</del><span class="cx"> RenderBlock* createAnonymousBlock(EDisplay display = BLOCK) const { return createAnonymousWithParentRendererAndDisplay(this, display); }
</span><del>- RenderBlock* createAnonymousColumnsBlock() const { return createAnonymousColumnsWithParentRenderer(this); }
- RenderBlock* createAnonymousColumnSpanBlock() const { return createAnonymousColumnSpanWithParentRenderer(this); }
</del><span class="cx"> static void collapseAnonymousBoxChild(RenderBlock* parent, RenderBlock* child);
</span><span class="cx">
</span><span class="cx"> virtual RenderBox* createAnonymousBoxWithSameTypeAs(const RenderObject* parent) const override;
</span><span class="lines">@@ -248,20 +231,7 @@
</span><span class="cx">
</span><span class="cx"> static TextRun constructTextRun(RenderObject* context, const Font&, const UChar* characters, int length, const RenderStyle&,
</span><span class="cx"> TextRun::ExpansionBehavior = TextRun::AllowTrailingExpansion | TextRun::ForbidLeadingExpansion);
</span><del>-
- ColumnInfo* columnInfo() const;
- int columnGap() const;
-
- // FIXME: Can devirtualize this and only have the RenderBlockFlow version once the old multi-column code is gone.
- virtual void updateColumnProgressionFromStyle(RenderStyle*);
</del><span class="cx">
</span><del>- LayoutUnit initialBlockOffsetForPainting() const;
- LayoutUnit blockDeltaForPaintingNextColumn() const;
-
- // These two functions take the ColumnInfo* to avoid repeated lookups of the info in the global HashMap.
- unsigned columnCount(ColumnInfo*) const;
- LayoutRect columnRectAt(ColumnInfo*, unsigned) const;
-
</del><span class="cx"> LayoutUnit paginationStrut() const;
</span><span class="cx"> void setPaginationStrut(LayoutUnit);
</span><span class="cx">
</span><span class="lines">@@ -380,8 +350,7 @@
</span><span class="cx">
</span><span class="cx"> virtual void computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const override;
</span><span class="cx"> virtual void computePreferredLogicalWidths() override;
</span><del>- void adjustIntrinsicLogicalWidthsForColumns(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const;
-
</del><ins>+
</ins><span class="cx"> virtual int firstLineBaseline() const override;
</span><span class="cx"> virtual int inlineBlockBaseline(LineDirectionMode) const override;
</span><span class="cx">
</span><span class="lines">@@ -404,21 +373,12 @@
</span><span class="cx"> bool simplifiedLayout();
</span><span class="cx"> virtual void simplifiedNormalFlowLayout();
</span><span class="cx">
</span><del>- // FIXME: Can de-virtualize this once old columns go away.
- virtual void setComputedColumnCountAndWidth(int, LayoutUnit);
-
</del><span class="cx"> bool childBoxIsUnsplittableForFragmentation(const RenderBox& child) const;
</span><span class="cx">
</span><span class="cx"> public:
</span><span class="cx"> virtual void computeOverflow(LayoutUnit oldClientAfterEdge, bool recomputeFloats = false);
</span><span class="cx"> void clearLayoutOverflow();
</span><span class="cx">
</span><del>- bool isTopLayoutOverflowAllowed() const override;
- bool isLeftLayoutOverflowAllowed() const override;
-
- // FIXME: Can devirtualize once old column code is gone.
- virtual void computeLineGridPaginationOrigin(LayoutState&) const;
-
</del><span class="cx"> // Adjust from painting offsets to the local coords of this renderer
</span><span class="cx"> void offsetForContents(LayoutPoint&) const;
</span><span class="cx">
</span><span class="lines">@@ -462,10 +422,7 @@
</span><span class="cx">
</span><span class="cx"> void addChildToContinuation(RenderObject* newChild, RenderObject* beforeChild);
</span><span class="cx"> virtual void addChildIgnoringContinuation(RenderObject* newChild, RenderObject* beforeChild) override;
</span><del>- void addChildToAnonymousColumnBlocks(RenderObject* newChild, RenderObject* beforeChild);
</del><span class="cx">
</span><del>- void addChildIgnoringAnonymousColumnBlocks(RenderObject* newChild, RenderObject* beforeChild = 0);
-
</del><span class="cx"> virtual bool isSelfCollapsingBlock() const override final;
</span><span class="cx"> // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
</span><span class="cx"> virtual bool hasLines() const { return false; }
</span><span class="lines">@@ -482,16 +439,14 @@
</span><span class="cx"> virtual void paintFloats(PaintInfo&, const LayoutPoint&, bool) { }
</span><span class="cx"> virtual void paintInlineChildren(PaintInfo&, const LayoutPoint&) { }
</span><span class="cx"> void paintContents(PaintInfo&, const LayoutPoint&);
</span><del>- void paintColumnContents(PaintInfo&, const LayoutPoint&, bool paintFloats = false);
- virtual void paintColumnRules(PaintInfo&, const LayoutPoint&);
</del><ins>+ virtual void paintColumnRules(PaintInfo&, const LayoutPoint&) { };
</ins><span class="cx"> void paintSelection(PaintInfo&, const LayoutPoint&);
</span><span class="cx"> void paintCaret(PaintInfo&, const LayoutPoint&, CaretType);
</span><span class="cx">
</span><span class="cx"> virtual bool avoidsFloats() const override;
</span><span class="cx">
</span><del>- bool hitTestColumns(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction);
</del><span class="cx"> virtual bool hitTestContents(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction);
</span><del>- // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
</del><ins>+ // FIXME-BLOCKFLOW: Remove virtualization when all callers have moved to RenderBlockFlow
</ins><span class="cx"> virtual bool hitTestFloats(const HitTestRequest&, HitTestResult&, const HitTestLocation&, const LayoutPoint&) { return false; }
</span><span class="cx"> virtual bool hitTestInlineChildren(const HitTestRequest&, HitTestResult&, const HitTestLocation&, const LayoutPoint&, HitTestAction) { return false; }
</span><span class="cx">
</span><span class="lines">@@ -535,22 +490,13 @@
</span><span class="cx"> virtual void absoluteRects(Vector<IntRect>&, const LayoutPoint& accumulatedOffset) const override;
</span><span class="cx"> virtual void absoluteQuads(Vector<FloatQuad>&, bool* wasFixed) const override;
</span><span class="cx">
</span><del>- // FIXME: Can de-virtualize once old columns go away.
- virtual LayoutUnit computedColumnWidth() const;
- virtual unsigned computedColumnCount() const;
-
</del><span class="cx"> void paintContinuationOutlines(PaintInfo&, const LayoutPoint&);
</span><span class="cx">
</span><span class="cx"> virtual LayoutRect localCaretRect(InlineBox*, int caretOffset, LayoutUnit* extraWidthToEndOfLine = 0) override final;
</span><del>-
- void adjustPointToColumnContents(LayoutPoint&) const;
</del><span class="cx">
</span><span class="cx"> // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
</span><span class="cx"> virtual VisiblePosition positionForPointWithInlineChildren(const LayoutPoint&, const RenderRegion*);
</span><span class="cx">
</span><del>- virtual void computeColumnCountAndWidth();
- void makeChildrenAnonymousColumnBlocks(RenderObject* beforeChild, RenderBlock* newBlockBox, RenderObject* newChild);
-
</del><span class="cx"> bool expandsToEncloseOverhangingFloats() const;
</span><span class="cx">
</span><span class="cx"> void splitBlocks(RenderBlock* fromBlock, RenderBlock* toBlock, RenderBlock* middleBlock,
</span><span class="lines">@@ -559,21 +505,16 @@
</span><span class="cx"> RenderObject* newChild, RenderBoxModelObject* oldCont);
</span><span class="cx"> RenderPtr<RenderBlock> clone() const;
</span><span class="cx"> RenderBlock* continuationBefore(RenderObject* beforeChild);
</span><del>- RenderBlock* containingColumnsBlock(bool allowAnonymousColumnBlock = true);
- RenderBlock* columnsBlockForSpanningElement(RenderObject* newChild);
</del><span class="cx">
</span><span class="cx"> private:
</span><span class="cx"> bool hasRareData() const;
</span><span class="cx">
</span><span class="cx"> protected:
</span><span class="cx"> void dirtyForLayoutFromPercentageHeightDescendants();
</span><del>-
- virtual ColumnInfo::PaginationUnit paginationUnit() const;
</del><span class="cx">
</span><span class="cx"> protected:
</span><del>- virtual bool requiresColumns(int computedColumnCount) const;
-
- bool updateLogicalWidthAndColumnWidth();
</del><ins>+ bool recomputeLogicalWidth();
+
</ins><span class="cx"> public:
</span><span class="cx"> virtual LayoutUnit offsetFromLogicalTopOfFirstPage() const override;
</span><span class="cx"> RenderRegion* regionAtBlockOffset(LayoutUnit) const;
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderBlockFlowcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderBlockFlow.cpp (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderBlockFlow.cpp 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/Source/WebCore/rendering/RenderBlockFlow.cpp 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -35,9 +35,11 @@
</span><span class="cx"> #include "RenderIterator.h"
</span><span class="cx"> #include "RenderLayer.h"
</span><span class="cx"> #include "RenderListItem.h"
</span><ins>+#include "RenderMarquee.h"
</ins><span class="cx"> #include "RenderMultiColumnFlowThread.h"
</span><span class="cx"> #include "RenderMultiColumnSet.h"
</span><span class="cx"> #include "RenderNamedFlowFragment.h"
</span><ins>+#include "RenderTableCell.h"
</ins><span class="cx"> #include "RenderText.h"
</span><span class="cx"> #include "RenderView.h"
</span><span class="cx"> #include "SimpleLineLayoutFunctions.h"
</span><span class="lines">@@ -322,6 +324,108 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+void RenderBlockFlow::adjustIntrinsicLogicalWidthsForColumns(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
+{
+ if (!style().hasAutoColumnCount() || !style().hasAutoColumnWidth()) {
+ // The min/max intrinsic widths calculated really tell how much space elements need when
+ // laid out inside the columns. In order to eventually end up with the desired column width,
+ // we need to convert them to values pertaining to the multicol container.
+ int columnCount = style().hasAutoColumnCount() ? 1 : style().columnCount();
+ LayoutUnit columnWidth;
+ LayoutUnit colGap = columnGap();
+ LayoutUnit gapExtra = (columnCount - 1) * colGap;
+ if (style().hasAutoColumnWidth())
+ minLogicalWidth = minLogicalWidth * columnCount + gapExtra;
+ else {
+ columnWidth = style().columnWidth();
+ minLogicalWidth = std::min(minLogicalWidth, columnWidth);
+ }
+ // FIXME: If column-count is auto here, we should resolve it to calculate the maximum
+ // intrinsic width, instead of pretending that it's 1. The only way to do that is by
+ // performing a layout pass, but this is not an appropriate time or place for layout. The
+ // good news is that if height is unconstrained and there are no explicit breaks, the
+ // resolved column-count really should be 1.
+ maxLogicalWidth = std::max(maxLogicalWidth, columnWidth) * columnCount + gapExtra;
+ }
+}
+
+void RenderBlockFlow::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
+{
+ if (childrenInline()) {
+ // FIXME: Remove this const_cast.
+ const_cast<RenderBlockFlow*>(this)->computeInlinePreferredLogicalWidths(minLogicalWidth, maxLogicalWidth);
+ } else
+ computeBlockPreferredLogicalWidths(minLogicalWidth, maxLogicalWidth);
+
+ maxLogicalWidth = std::max(minLogicalWidth, maxLogicalWidth);
+
+ adjustIntrinsicLogicalWidthsForColumns(minLogicalWidth, maxLogicalWidth);
+
+ if (!style().autoWrap() && childrenInline()) {
+ // A horizontal marquee with inline children has no minimum width.
+ if (layer() && layer()->marquee() && layer()->marquee()->isHorizontal())
+ minLogicalWidth = 0;
+ }
+
+ if (isTableCell()) {
+ Length tableCellWidth = toRenderTableCell(this)->styleOrColLogicalWidth();
+ if (tableCellWidth.isFixed() && tableCellWidth.value() > 0)
+ maxLogicalWidth = std::max(minLogicalWidth, adjustContentBoxLogicalWidthForBoxSizing(tableCellWidth.value()));
+ }
+
+ int scrollbarWidth = instrinsicScrollbarLogicalWidth();
+ maxLogicalWidth += scrollbarWidth;
+ minLogicalWidth += scrollbarWidth;
+}
+
+bool RenderBlockFlow::recomputeLogicalWidthAndColumnWidth()
+{
+ bool changed = recomputeLogicalWidth();
+
+ LayoutUnit oldColumnWidth = computedColumnWidth();
+ computeColumnCountAndWidth();
+
+ return changed || oldColumnWidth != computedColumnWidth();
+}
+
+LayoutUnit RenderBlockFlow::columnGap() const
+{
+ if (style().hasNormalColumnGap())
+ return style().fontDescription().computedPixelSize(); // "1em" is recommended as the normal gap setting. Matches <p> margins.
+ return style().columnGap();
+}
+
+void RenderBlockFlow::computeColumnCountAndWidth()
+{
+ // Calculate our column width and column count.
+ // FIXME: Can overflow on fast/block/float/float-not-removed-from-next-sibling4.html, see https://bugs.webkit.org/show_bug.cgi?id=68744
+ unsigned desiredColumnCount = 1;
+ LayoutUnit desiredColumnWidth = contentLogicalWidth();
+
+ // For now, we don't support multi-column layouts when printing, since we have to do a lot of work for proper pagination.
+ if (document().paginated() || (style().hasAutoColumnCount() && style().hasAutoColumnWidth()) || !style().hasInlineColumnAxis()) {
+ setComputedColumnCountAndWidth(desiredColumnCount, desiredColumnWidth);
+ return;
+ }
+
+ LayoutUnit availWidth = desiredColumnWidth;
+ LayoutUnit colGap = columnGap();
+ LayoutUnit colWidth = std::max<LayoutUnit>(LayoutUnit::fromPixel(1), LayoutUnit(style().columnWidth()));
+ int colCount = std::max<int>(1, style().columnCount());
+
+ if (style().hasAutoColumnWidth() && !style().hasAutoColumnCount()) {
+ desiredColumnCount = colCount;
+ desiredColumnWidth = std::max<LayoutUnit>(0, (availWidth - ((desiredColumnCount - 1) * colGap)) / desiredColumnCount);
+ } else if (!style().hasAutoColumnWidth() && style().hasAutoColumnCount()) {
+ desiredColumnCount = std::max<LayoutUnit>(1, (availWidth + colGap) / (colWidth + colGap));
+ desiredColumnWidth = ((availWidth + colGap) / desiredColumnCount) - colGap;
+ } else {
+ desiredColumnCount = std::max<LayoutUnit>(std::min<LayoutUnit>(colCount, (availWidth + colGap) / (colWidth + colGap)), 1);
+ desiredColumnWidth = ((availWidth + colGap) / desiredColumnCount) - colGap;
+ }
+ setComputedColumnCountAndWidth(desiredColumnCount, desiredColumnWidth);
+}
+
</ins><span class="cx"> void RenderBlockFlow::layoutBlock(bool relayoutChildren, LayoutUnit pageLogicalHeight)
</span><span class="cx"> {
</span><span class="cx"> ASSERT(needsLayout());
</span><span class="lines">@@ -331,7 +435,7 @@
</span><span class="cx">
</span><span class="cx"> LayoutRepainter repainter(*this, checkForRepaintDuringLayout());
</span><span class="cx">
</span><del>- if (updateLogicalWidthAndColumnWidth())
</del><ins>+ if (recomputeLogicalWidthAndColumnWidth())
</ins><span class="cx"> relayoutChildren = true;
</span><span class="cx">
</span><span class="cx"> rebuildFloatingObjectSetFromIntrudingFloats();
</span><span class="lines">@@ -342,11 +446,10 @@
</span><span class="cx"> setLogicalHeight(0);
</span><span class="cx">
</span><span class="cx"> bool pageLogicalHeightChanged = false;
</span><del>- bool hasSpecifiedPageLogicalHeight = false;
- checkForPaginationLogicalHeightChange(relayoutChildren, pageLogicalHeight, pageLogicalHeightChanged, hasSpecifiedPageLogicalHeight);
</del><ins>+ checkForPaginationLogicalHeightChange(relayoutChildren, pageLogicalHeight, pageLogicalHeightChanged);
</ins><span class="cx">
</span><span class="cx"> const RenderStyle& styleToUse = style();
</span><del>- LayoutStateMaintainer statePusher(view(), *this, locationOffset(), hasColumns() || hasTransform() || hasReflection() || styleToUse.isFlippedBlocksWritingMode(), pageLogicalHeight, pageLogicalHeightChanged, columnInfo());
</del><ins>+ LayoutStateMaintainer statePusher(view(), *this, locationOffset(), hasTransform() || hasReflection() || styleToUse.isFlippedBlocksWritingMode(), pageLogicalHeight, pageLogicalHeightChanged);
</ins><span class="cx">
</span><span class="cx"> preparePaginationBeforeBlockLayout(relayoutChildren);
</span><span class="cx"> if (!relayoutChildren)
</span><span class="lines">@@ -386,7 +489,7 @@
</span><span class="cx"> if (lowestFloatLogicalBottom() > (logicalHeight() - toAdd) && expandsToEncloseOverhangingFloats())
</span><span class="cx"> setLogicalHeight(lowestFloatLogicalBottom() + toAdd);
</span><span class="cx">
</span><del>- if (relayoutForPagination(hasSpecifiedPageLogicalHeight, pageLogicalHeight, statePusher) || relayoutToAvoidWidows(statePusher)) {
</del><ins>+ if (relayoutForPagination(statePusher) || relayoutToAvoidWidows(statePusher)) {
</ins><span class="cx"> ASSERT(!shouldBreakAtLineToAvoidWidow());
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="lines">@@ -458,9 +561,6 @@
</span><span class="cx"> else
</span><span class="cx"> repaintRect = LayoutRect(repaintLogicalTop, repaintLogicalLeft, repaintLogicalBottom - repaintLogicalTop, repaintLogicalRight - repaintLogicalLeft);
</span><span class="cx">
</span><del>- // The repaint rect may be split across columns, in which case adjustRectForColumns() will return the union.
- adjustRectForColumns(repaintRect);
-
</del><span class="cx"> repaintRect.inflate(maximalOutlineSize(PaintPhaseOutline));
</span><span class="cx">
</span><span class="cx"> if (hasOverflowClip()) {
</span><span class="lines">@@ -1357,7 +1457,7 @@
</span><span class="cx"> {
</span><span class="cx"> RenderBlock* curr = child.containingBlock();
</span><span class="cx"> while (curr && curr != &child.view()) {
</span><del>- if (curr->hasColumns() || curr->isRenderFlowThread())
</del><ins>+ if (curr->isRenderFlowThread())
</ins><span class="cx"> return true;
</span><span class="cx"> if (curr->isFloatingOrOutOfFlowPositioned())
</span><span class="cx"> return false;
</span><span class="lines">@@ -1371,7 +1471,7 @@
</span><span class="cx"> // FIXME: Add page break checking here when we support printing.
</span><span class="cx"> RenderFlowThread* flowThread = flowThreadContainingBlock();
</span><span class="cx"> bool isInsideMulticolFlowThread = flowThread && !flowThread->isRenderNamedFlowThread();
</span><del>- bool checkColumnBreaks = isInsideMulticolFlowThread || view().layoutState()->isPaginatingColumns();
</del><ins>+ bool checkColumnBreaks = flowThread && flowThread->shouldCheckColumnBreaks();
</ins><span class="cx"> bool checkPageBreaks = !checkColumnBreaks && view().layoutState()->m_pageLogicalHeight; // FIXME: Once columns can print we have to check this.
</span><span class="cx"> bool checkRegionBreaks = flowThread && flowThread->isRenderNamedFlowThread();
</span><span class="cx"> bool checkBeforeAlways = (checkColumnBreaks && child.style().columnBreakBefore() == PBALWAYS)
</span><span class="lines">@@ -1381,8 +1481,6 @@
</span><span class="cx"> if (checkColumnBreaks) {
</span><span class="cx"> if (isInsideMulticolFlowThread)
</span><span class="cx"> checkRegionBreaks = true;
</span><del>- else
- view().layoutState()->addForcedColumnBreak(&child, logicalOffset);
</del><span class="cx"> }
</span><span class="cx"> if (checkRegionBreaks) {
</span><span class="cx"> LayoutUnit offsetBreakAdjustment = 0;
</span><span class="lines">@@ -1399,7 +1497,7 @@
</span><span class="cx"> // FIXME: Add page break checking here when we support printing.
</span><span class="cx"> RenderFlowThread* flowThread = flowThreadContainingBlock();
</span><span class="cx"> bool isInsideMulticolFlowThread = flowThread && !flowThread->isRenderNamedFlowThread();
</span><del>- bool checkColumnBreaks = isInsideMulticolFlowThread || view().layoutState()->isPaginatingColumns();
</del><ins>+ bool checkColumnBreaks = flowThread && flowThread->shouldCheckColumnBreaks();
</ins><span class="cx"> bool checkPageBreaks = !checkColumnBreaks && view().layoutState()->m_pageLogicalHeight; // FIXME: Once columns can print we have to check this.
</span><span class="cx"> bool checkRegionBreaks = flowThread && flowThread->isRenderNamedFlowThread();
</span><span class="cx"> bool checkAfterAlways = (checkColumnBreaks && child.style().columnBreakAfter() == PBALWAYS)
</span><span class="lines">@@ -1414,8 +1512,6 @@
</span><span class="cx"> if (checkColumnBreaks) {
</span><span class="cx"> if (isInsideMulticolFlowThread)
</span><span class="cx"> checkRegionBreaks = true;
</span><del>- else
- view().layoutState()->addForcedColumnBreak(&child, logicalOffset);
</del><span class="cx"> }
</span><span class="cx"> if (checkRegionBreaks) {
</span><span class="cx"> LayoutUnit offsetBreakAdjustment = 0;
</span><span class="lines">@@ -1714,8 +1810,6 @@
</span><span class="cx"> {
</span><span class="cx"> if (RenderFlowThread* flowThread = flowThreadContainingBlock())
</span><span class="cx"> flowThread->updateMinimumPageHeight(this, offsetFromLogicalTopOfFirstPage() + offset, minHeight);
</span><del>- else if (ColumnInfo* colInfo = view().layoutState()->m_columnInfo)
- colInfo->updateMinimumColumnHeight(minHeight);
</del><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> LayoutUnit RenderBlockFlow::nextPageLogicalTop(LayoutUnit logicalOffset, PageBoundaryRule pageBoundaryRule) const
</span><span class="lines">@@ -1967,7 +2061,7 @@
</span><span class="cx"> {
</span><span class="cx"> RenderBlock::computeOverflow(oldClientAfterEdge, recomputeFloats);
</span><span class="cx">
</span><del>- if (!hasColumns() && !multiColumnFlowThread() && (recomputeFloats || isRoot() || expandsToEncloseOverhangingFloats() || hasSelfPaintingLayer()))
</del><ins>+ if (!multiColumnFlowThread() && (recomputeFloats || isRoot() || expandsToEncloseOverhangingFloats() || hasSelfPaintingLayer()))
</ins><span class="cx"> addOverflowFromFloats();
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -2422,7 +2516,7 @@
</span><span class="cx"> LayoutUnit RenderBlockFlow::addOverhangingFloats(RenderBlockFlow& child, bool makeChildPaintOtherFloats)
</span><span class="cx"> {
</span><span class="cx"> // Prevent floats from being added to the canvas by the root element, e.g., <html>.
</span><del>- if (child.hasOverflowClip() || !child.containsFloats() || child.isRoot() || child.hasColumns() || child.isWritingModeRoot() || child.isRenderFlowThread() || child.isRenderRegion())
</del><ins>+ if (child.hasOverflowClip() || !child.containsFloats() || child.isRoot() || child.isWritingModeRoot() || child.isRenderFlowThread() || child.isRenderRegion())
</ins><span class="cx"> return 0;
</span><span class="cx">
</span><span class="cx"> LayoutUnit childLogicalTop = child.logicalTop();
</span><span class="lines">@@ -2480,7 +2574,7 @@
</span><span class="cx">
</span><span class="cx"> bool RenderBlockFlow::hasOverhangingFloat(RenderBox& renderer)
</span><span class="cx"> {
</span><del>- if (!m_floatingObjects || hasColumns() || !parent())
</del><ins>+ if (!m_floatingObjects || !parent())
</ins><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
</span><span class="lines">@@ -3221,61 +3315,11 @@
</span><span class="cx"> m_lineBoxes.paint(this, paintInfo, paintOffset);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool RenderBlockFlow::relayoutForPagination(bool hasSpecifiedPageLogicalHeight, LayoutUnit pageLogicalHeight, LayoutStateMaintainer& statePusher)
</del><ins>+bool RenderBlockFlow::relayoutForPagination(LayoutStateMaintainer& statePusher)
</ins><span class="cx"> {
</span><del>- if (!hasColumns() && !multiColumnFlowThread())
</del><ins>+ if (!multiColumnFlowThread() || !multiColumnFlowThread()->shouldRelayoutForPagination())
</ins><span class="cx"> return false;
</span><del>-
- if (hasColumns()) {
- RefPtr<RenderOverflow> savedOverflow = m_overflow.release();
- if (childrenInline())
- addOverflowFromInlineChildren();
- else
- addOverflowFromBlockChildren();
- LayoutUnit layoutOverflowLogicalBottom = (isHorizontalWritingMode() ? layoutOverflowRect().maxY() : layoutOverflowRect().maxX()) - borderAndPaddingBefore();
-
- // FIXME: We don't balance properly at all in the presence of forced page breaks. We need to understand what
- // the distance between forced page breaks is so that we can avoid making the minimum column height too tall.
- ColumnInfo* colInfo = columnInfo();
- if (!hasSpecifiedPageLogicalHeight) {
- LayoutUnit columnHeight = pageLogicalHeight;
- int minColumnCount = colInfo->forcedBreaks() + 1;
- int desiredColumnCount = colInfo->desiredColumnCount();
- if (minColumnCount >= desiredColumnCount) {
- // The forced page breaks are in control of the balancing. Just set the column height to the
- // maximum page break distance.
- if (!pageLogicalHeight) {
- LayoutUnit distanceBetweenBreaks = std::max<LayoutUnit>(colInfo->maximumDistanceBetweenForcedBreaks(),
- view().layoutState()->pageLogicalOffset(this, borderAndPaddingBefore() + layoutOverflowLogicalBottom) - colInfo->forcedBreakOffset());
- columnHeight = std::max(colInfo->minimumColumnHeight(), distanceBetweenBreaks);
- }
- } else if (layoutOverflowLogicalBottom > boundedMultiply(pageLogicalHeight, desiredColumnCount)) {
- // Now that we know the intrinsic height of the columns, we have to rebalance them.
- columnHeight = std::max<LayoutUnit>(colInfo->minimumColumnHeight(), ceilf((float)layoutOverflowLogicalBottom / desiredColumnCount));
- }
-
- if (columnHeight && columnHeight != pageLogicalHeight) {
- statePusher.pop();
- setEverHadLayout(true);
- layoutBlock(false, columnHeight);
- return true;
- }
- }
-
- if (pageLogicalHeight)
- colInfo->setColumnCountAndHeight(ceilf((float)layoutOverflowLogicalBottom / pageLogicalHeight), pageLogicalHeight);
-
- if (columnCount(colInfo)) {
- setLogicalHeight(borderAndPaddingBefore() + colInfo->columnHeight() + borderAndPaddingAfter() + scrollbarLogicalHeight());
- clearOverflow();
- } else
- m_overflow = savedOverflow.release();
- return false;
- }
</del><span class="cx">
</span><del>- if (!multiColumnFlowThread()->shouldRelayoutForPagination())
- return false;
-
</del><span class="cx"> multiColumnFlowThread()->setNeedsHeightsRecalculation(false);
</span><span class="cx"> multiColumnFlowThread()->setInBalancingPass(true); // Prevent re-entering this method (and recursion into layout).
</span><span class="cx">
</span><span class="lines">@@ -3580,10 +3624,10 @@
</span><span class="cx"> RenderBlock::removeChild(oldChild);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void RenderBlockFlow::checkForPaginationLogicalHeightChange(bool& relayoutChildren, LayoutUnit& pageLogicalHeight, bool& pageLogicalHeightChanged, bool& hasSpecifiedPageLogicalHeight)
</del><ins>+void RenderBlockFlow::checkForPaginationLogicalHeightChange(bool& relayoutChildren, LayoutUnit& pageLogicalHeight, bool& pageLogicalHeightChanged)
</ins><span class="cx"> {
</span><del>- // If we don't use either of the two column implementations or a flow thread, then bail.
- if (!isRenderFlowThread() && !multiColumnFlowThread() && !hasColumns())
</del><ins>+ // If we don't use columns or flow threads, then bail.
+ if (!isRenderFlowThread() && !multiColumnFlowThread())
</ins><span class="cx"> return;
</span><span class="cx">
</span><span class="cx"> // We don't actually update any of the variables. We just subclassed to adjust our column height.
</span><span class="lines">@@ -3595,30 +3639,6 @@
</span><span class="cx"> flowThread->setColumnHeightAvailable(std::max<LayoutUnit>(columnHeight, 0));
</span><span class="cx"> if (oldHeightAvailable != flowThread->columnHeightAvailable())
</span><span class="cx"> relayoutChildren = true;
</span><del>- } else if (hasColumns()) {
- ColumnInfo* colInfo = columnInfo();
-
- if (!pageLogicalHeight) {
- // We need to go ahead and set our explicit page height if one exists, so that we can
- // avoid doing two layout passes.
- updateLogicalHeight();
- LayoutUnit columnHeight = isRenderView() ? view().pageOrViewLogicalHeight() : contentLogicalHeight();
- if (columnHeight > 0) {
- pageLogicalHeight = columnHeight;
- hasSpecifiedPageLogicalHeight = true;
- }
- setLogicalHeight(0);
- }
-
- if (colInfo->columnHeight() != pageLogicalHeight && everHadLayout())
- pageLogicalHeightChanged = true;
-
- colInfo->setColumnHeight(pageLogicalHeight);
-
- if (!hasSpecifiedPageLogicalHeight && !pageLogicalHeight)
- colInfo->clearForcedBreaks();
-
- colInfo->setPaginationUnit(paginationUnit());
</del><span class="cx"> } else if (isRenderFlowThread()) {
</span><span class="cx"> RenderFlowThread* flowThread = toRenderFlowThread(this);
</span><span class="cx">
</span><span class="lines">@@ -3637,11 +3657,17 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+bool RenderBlockFlow::requiresColumns(int desiredColumnCount) const
+{
+ // If overflow-y is set to paged-x or paged-y on the body or html element, we'll handle the paginating
+ // in the RenderView instead.
+ bool isPaginated = (style().overflowY() == OPAGEDX || style().overflowY() == OPAGEDY) && !(isRoot() || isBody());
+
+ return firstChild() && (desiredColumnCount != 1 || !style().hasAutoColumnWidth() || !style().hasInlineColumnAxis() || isPaginated);
+}
+
</ins><span class="cx"> void RenderBlockFlow::setComputedColumnCountAndWidth(int count, LayoutUnit width)
</span><span class="cx"> {
</span><del>- if (!document().regionBasedColumnsEnabled())
- return RenderBlock::setComputedColumnCountAndWidth(count, width);
-
</del><span class="cx"> bool destroyColumns = !requiresColumns(count);
</span><span class="cx"> if (destroyColumns) {
</span><span class="cx"> if (multiColumnFlowThread())
</span><span class="lines">@@ -3657,9 +3683,6 @@
</span><span class="cx">
</span><span class="cx"> void RenderBlockFlow::updateColumnProgressionFromStyle(RenderStyle* style)
</span><span class="cx"> {
</span><del>- if (!document().regionBasedColumnsEnabled())
- return RenderBlock::updateColumnProgressionFromStyle(style);
-
</del><span class="cx"> if (!multiColumnFlowThread())
</span><span class="cx"> return;
</span><span class="cx">
</span><span class="lines">@@ -3684,9 +3707,6 @@
</span><span class="cx">
</span><span class="cx"> LayoutUnit RenderBlockFlow::computedColumnWidth() const
</span><span class="cx"> {
</span><del>- if (!document().regionBasedColumnsEnabled())
- return RenderBlock::computedColumnWidth();
-
</del><span class="cx"> if (multiColumnFlowThread())
</span><span class="cx"> return multiColumnFlowThread()->computedColumnWidth();
</span><span class="cx"> return contentLogicalWidth();
</span><span class="lines">@@ -3694,9 +3714,6 @@
</span><span class="cx">
</span><span class="cx"> unsigned RenderBlockFlow::computedColumnCount() const
</span><span class="cx"> {
</span><del>- if (!document().regionBasedColumnsEnabled())
- return RenderBlock::computedColumnCount();
-
</del><span class="cx"> if (multiColumnFlowThread())
</span><span class="cx"> return multiColumnFlowThread()->computedColumnCount();
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderBlockFlowh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderBlockFlow.h (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderBlockFlow.h 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/Source/WebCore/rendering/RenderBlockFlow.h 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -384,9 +384,11 @@
</span><span class="cx"> void createMultiColumnFlowThread();
</span><span class="cx"> void destroyMultiColumnFlowThread();
</span><span class="cx">
</span><del>- virtual void updateColumnProgressionFromStyle(RenderStyle*) override;
</del><ins>+ void updateColumnProgressionFromStyle(RenderStyle*);
</ins><span class="cx">
</span><span class="cx"> protected:
</span><ins>+ virtual void computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const override;
+
</ins><span class="cx"> // A page break is required at some offset due to space shortage in the current fragmentainer.
</span><span class="cx"> void setPageBreak(LayoutUnit offset, LayoutUnit spaceShortage);
</span><span class="cx">
</span><span class="lines">@@ -442,22 +444,28 @@
</span><span class="cx">
</span><span class="cx"> virtual bool isMultiColumnBlockFlow() const override { return multiColumnFlowThread(); }
</span><span class="cx">
</span><del>- virtual void setComputedColumnCountAndWidth(int, LayoutUnit) override;
</del><ins>+ void setComputedColumnCountAndWidth(int, LayoutUnit);
</ins><span class="cx">
</span><del>- virtual LayoutUnit computedColumnWidth() const override;
- virtual unsigned computedColumnCount() const override;
</del><ins>+ LayoutUnit computedColumnWidth() const;
+ unsigned computedColumnCount() const;
</ins><span class="cx">
</span><span class="cx"> bool isTopLayoutOverflowAllowed() const override;
</span><span class="cx"> bool isLeftLayoutOverflowAllowed() const override;
</span><span class="cx">
</span><span class="cx"> void moveFloatsTo(RenderBlockFlow* toBlock);
</span><ins>+
+ virtual void computeColumnCountAndWidth();
+ virtual bool requiresColumns(int) const;
</ins><span class="cx">
</span><span class="cx"> private:
</span><ins>+ bool recomputeLogicalWidthAndColumnWidth();
+ LayoutUnit columnGap() const;
+
</ins><span class="cx"> // Called to lay out the legend for a fieldset or the ruby text of a ruby run. Also used by multi-column layout to handle
</span><span class="cx"> // the flow thread child.
</span><span class="cx"> virtual RenderObject* layoutSpecialExcludedChild(bool /*relayoutChildren*/);
</span><span class="cx">
</span><del>- void checkForPaginationLogicalHeightChange(bool& relayoutChildren, LayoutUnit& pageLogicalHeight, bool& pageLogicalHeightChanged, bool& hasSpecifiedPageLogicalHeight);
</del><ins>+ void checkForPaginationLogicalHeightChange(bool& relayoutChildren, LayoutUnit& pageLogicalHeight, bool& pageLogicalHeightChanged);
</ins><span class="cx">
</span><span class="cx"> virtual void paintInlineChildren(PaintInfo&, const LayoutPoint&) override;
</span><span class="cx"> virtual void paintFloats(PaintInfo&, const LayoutPoint&, bool preservePhase = false) override;
</span><span class="lines">@@ -490,7 +498,7 @@
</span><span class="cx"> LayoutUnit addOverhangingFloats(RenderBlockFlow& child, bool makeChildPaintOtherFloats);
</span><span class="cx"> bool hasOverhangingFloat(RenderBox&);
</span><span class="cx"> void addIntrudingFloats(RenderBlockFlow* prev, LayoutUnit xoffset, LayoutUnit yoffset);
</span><del>- bool hasOverhangingFloats() { return parent() && !hasColumns() && containsFloats() && lowestFloatLogicalBottom() > logicalHeight(); }
</del><ins>+ bool hasOverhangingFloats() { return parent() && containsFloats() && lowestFloatLogicalBottom() > logicalHeight(); }
</ins><span class="cx"> LayoutUnit getClearDelta(RenderBox& child, LayoutUnit yPos);
</span><span class="cx">
</span><span class="cx"> void determineLogicalLeftPositionForChild(RenderBox& child, ApplyLayoutDeltaMode = DoNotApplyLayoutDelta);
</span><span class="lines">@@ -527,7 +535,9 @@
</span><span class="cx"> virtual ETextAlign textAlignmentForLine(bool endsWithSoftBreak) const;
</span><span class="cx"> virtual void adjustInlineDirectionLineBounds(int /* expansionOpportunityCount */, float& /* logicalLeft */, float& /* logicalWidth */) const { }
</span><span class="cx">
</span><del>-private:
</del><ins>+private:
+ void adjustIntrinsicLogicalWidthsForColumns(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const;
+
</ins><span class="cx"> void layoutLineBoxes(bool relayoutChildren, LayoutUnit& repaintLogicalTop, LayoutUnit& repaintLogicalBottom);
</span><span class="cx"> void layoutSimpleLines(LayoutUnit& repaintLogicalTop, LayoutUnit& repaintLogicalBottom);
</span><span class="cx">
</span><span class="lines">@@ -581,7 +591,7 @@
</span><span class="cx"> void createRenderNamedFlowFragmentIfNeeded();
</span><span class="cx">
</span><span class="cx"> // Pagination routines.
</span><del>- virtual bool relayoutForPagination(bool hasSpecifiedPageLogicalHeight, LayoutUnit pageLogicalHeight, LayoutStateMaintainer&);
</del><ins>+ bool relayoutForPagination(LayoutStateMaintainer&);
</ins><span class="cx">
</span><span class="cx"> bool hasRareBlockFlowData() const { return m_rareBlockFlowData.get(); }
</span><span class="cx"> RenderBlockFlowRareData* rareBlockFlowData() const { ASSERT_WITH_SECURITY_IMPLICATION(hasRareBlockFlowData()); return m_rareBlockFlowData.get(); }
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderBoxcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderBox.cpp (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderBox.cpp 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/Source/WebCore/rendering/RenderBox.cpp 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -374,7 +374,7 @@
</span><span class="cx"> const Pagination& pagination = view().frameView().pagination();
</span><span class="cx"> if (viewChangedWritingMode && pagination.mode != Pagination::Unpaginated) {
</span><span class="cx"> viewStyle.setColumnStylesFromPaginationMode(pagination.mode);
</span><del>- if (view().hasColumns() || view().multiColumnFlowThread())
</del><ins>+ if (view().multiColumnFlowThread())
</ins><span class="cx"> view().updateColumnProgressionFromStyle(&viewStyle);
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="lines">@@ -1970,7 +1970,7 @@
</span><span class="cx"> RenderBoxModelObject::mapAbsoluteToLocalPoint(mode, transformState);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-LayoutSize RenderBox::offsetFromContainer(RenderObject* o, const LayoutPoint& point, bool* offsetDependsOnPoint) const
</del><ins>+LayoutSize RenderBox::offsetFromContainer(RenderObject* o, const LayoutPoint&, bool* offsetDependsOnPoint) const
</ins><span class="cx"> {
</span><span class="cx"> // A region "has" boxes inside it without being their container.
</span><span class="cx"> ASSERT(o == container() || o->isRenderRegion());
</span><span class="lines">@@ -1979,23 +1979,9 @@
</span><span class="cx"> if (isInFlowPositioned())
</span><span class="cx"> offset += offsetForInFlowPosition();
</span><span class="cx">
</span><del>- if (!isInline() || isReplaced()) {
- if (!style().hasOutOfFlowPosition() && o->hasColumns()) {
- RenderBlock* block = toRenderBlock(o);
- LayoutRect columnRect(frameRect());
- block->adjustStartEdgeForWritingModeIncludingColumns(columnRect);
- offset += toLayoutSize(columnRect.location());
- LayoutPoint columnPoint = block->flipForWritingModeIncludingColumns(point + offset);
- offset = toLayoutSize(block->flipForWritingModeIncludingColumns(toLayoutPoint(offset)));
- o->adjustForColumns(offset, columnPoint);
- offset = block->flipForWritingMode(offset);
</del><ins>+ if (!isInline() || isReplaced())
+ offset += topLeftLocationOffset();
</ins><span class="cx">
</span><del>- if (offsetDependsOnPoint)
- *offsetDependsOnPoint = true;
- } else
- offset += topLeftLocationOffset();
- }
-
</del><span class="cx"> if (o->isBox())
</span><span class="cx"> offset -= toRenderBox(o)->scrolledContentOffset();
</span><span class="cx">
</span><span class="lines">@@ -2171,13 +2157,6 @@
</span><span class="cx"> // flag on the RenderObject has been cleared, so use the one on the style().
</span><span class="cx"> topLeft += layer()->offsetForInFlowPosition();
</span><span class="cx"> }
</span><del>-
- if (position != AbsolutePosition && position != FixedPosition && o->hasColumns() && o->isRenderBlockFlow()) {
- LayoutRect repaintRect(topLeft, rect.size());
- toRenderBlock(o)->adjustRectForColumns(repaintRect);
- topLeft = repaintRect.location();
- rect = repaintRect;
- }
</del><span class="cx">
</span><span class="cx"> // FIXME: We ignore the lightweight clipping rect that controls use, since if |o| is in mid-layout,
</span><span class="cx"> // its controlClipRect will be wrong. For overflow clip we use the values cached by the layer.
</span><span class="lines">@@ -4670,13 +4649,6 @@
</span><span class="cx"> return isHorizontalWritingMode() ? LayoutPoint(position.x(), height() - position.y()) : LayoutPoint(width() - position.x(), position.y());
</span><span class="cx"> }
</span><span class="cx">
</span><del>-LayoutPoint RenderBox::flipForWritingModeIncludingColumns(const LayoutPoint& point) const
-{
- if (!hasColumns() || !style().isFlippedBlocksWritingMode())
- return flipForWritingMode(point);
- return toRenderBlock(this)->flipForWritingModeIncludingColumns(point);
-}
-
</del><span class="cx"> LayoutSize RenderBox::flipForWritingMode(const LayoutSize& offset) const
</span><span class="cx"> {
</span><span class="cx"> if (!style().isFlippedBlocksWritingMode())
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderBoxh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderBox.h (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderBox.h 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/Source/WebCore/rendering/RenderBox.h 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -446,7 +446,6 @@
</span><span class="cx"> static bool percentageLogicalHeightIsResolvableFromBlock(const RenderBlock* containingBlock, bool outOfFlowPositioned);
</span><span class="cx"> LayoutUnit computePercentageLogicalHeight(const Length& height) const;
</span><span class="cx">
</span><del>- // Block flows subclass availableWidth/Height to handle multi column layout (shrinking the width/height available to children when laying out.)
</del><span class="cx"> virtual LayoutUnit availableLogicalWidth() const { return contentLogicalWidth(); }
</span><span class="cx"> virtual LayoutUnit availableLogicalHeight(AvailableLogicalHeightType) const;
</span><span class="cx"> LayoutUnit availableLogicalHeightUsing(const Length&, AvailableLogicalHeightType) const;
</span><span class="lines">@@ -544,7 +543,6 @@
</span><span class="cx"> LayoutPoint flipForWritingModeForChild(const RenderBox* child, const LayoutPoint&) const;
</span><span class="cx"> LayoutUnit flipForWritingMode(LayoutUnit position) const; // The offset is in the block direction (y for horizontal writing modes, x for vertical writing modes).
</span><span class="cx"> LayoutPoint flipForWritingMode(const LayoutPoint&) const;
</span><del>- LayoutPoint flipForWritingModeIncludingColumns(const LayoutPoint&) const;
</del><span class="cx"> LayoutSize flipForWritingMode(const LayoutSize&) const;
</span><span class="cx"> void flipForWritingMode(LayoutRect&) const;
</span><span class="cx"> FloatPoint flipForWritingMode(const FloatPoint&) const;
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderBoxModelObjectcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderBoxModelObject.cpp (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderBoxModelObject.cpp 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/Source/WebCore/rendering/RenderBoxModelObject.cpp 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -301,7 +301,6 @@
</span><span class="cx"> return LayoutPoint();
</span><span class="cx">
</span><span class="cx"> LayoutPoint referencePoint = startPoint;
</span><del>- referencePoint.move(parent()->offsetForColumns(referencePoint));
</del><span class="cx">
</span><span class="cx"> // If the offsetParent of the element is null, or is the HTML body element,
</span><span class="cx"> // return the distance between the canvas origin and the left border edge
</span><span class="lines">@@ -330,7 +329,6 @@
</span><span class="cx"> } else if (!isOutOfFlowPositioned()) {
</span><span class="cx"> if (curr->isBox() && !curr->isTableRow())
</span><span class="cx"> referencePoint.moveBy(toRenderBox(curr)->topLeftLocation());
</span><del>- referencePoint.move(curr->parent()->offsetForColumns(referencePoint));
</del><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> curr = curr->parent();
</span><span class="lines">@@ -2651,13 +2649,6 @@
</span><span class="cx">
</span><span class="cx"> LayoutSize containerOffset = offsetFromContainer(o, LayoutPoint());
</span><span class="cx">
</span><del>- if (!style().hasOutOfFlowPosition() && o->hasColumns()) {
- RenderBlock* block = toRenderBlock(o);
- LayoutPoint point(roundedLayoutPoint(transformState.mappedPoint()));
- point -= containerOffset;
- block->adjustForColumnRect(containerOffset, point);
- }
-
</del><span class="cx"> bool preserve3D = mode & UseTransforms && (o->style().preserves3D() || style().preserves3D());
</span><span class="cx"> if (mode & UseTransforms && shouldUseTransformFromContainer(o)) {
</span><span class="cx"> TransformationMatrix t;
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderBoxModelObjecth"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderBoxModelObject.h (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderBoxModelObject.h 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/Source/WebCore/rendering/RenderBoxModelObject.h 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -89,7 +89,7 @@
</span><span class="cx">
</span><span class="cx"> virtual void updateFromStyle() override;
</span><span class="cx">
</span><del>- virtual bool requiresLayer() const override { return isRoot() || isPositioned() || createsGroup() || hasClipPath() || hasTransform() || hasHiddenBackface() || hasReflection() || style().specifiesColumns(); }
</del><ins>+ virtual bool requiresLayer() const override { return isRoot() || isPositioned() || createsGroup() || hasClipPath() || hasTransform() || hasHiddenBackface() || hasReflection(); }
</ins><span class="cx">
</span><span class="cx"> // This will work on inlines to return the bounding box of all of the lines' border boxes.
</span><span class="cx"> virtual IntRect borderBoundingBox() const = 0;
</span><span class="lines">@@ -181,7 +181,7 @@
</span><span class="cx">
</span><span class="cx"> virtual void setSelectionState(SelectionState) override;
</span><span class="cx">
</span><del>- bool canHaveBoxInfoInRegion() const { return !isFloating() && !isReplaced() && !isInline() && !hasColumns() && !isTableCell() && isRenderBlock() && !isRenderSVGBlock(); }
</del><ins>+ bool canHaveBoxInfoInRegion() const { return !isFloating() && !isReplaced() && !isInline() && !isTableCell() && isRenderBlock() && !isRenderSVGBlock(); }
</ins><span class="cx">
</span><span class="cx"> void getGeometryForBackgroundImage(const RenderLayerModelObject* paintContainer, FloatRect& destRect, FloatPoint& phase, FloatSize& tileSize) const;
</span><span class="cx"> void contentChanged(ContentChangeType);
</span><span class="lines">@@ -275,8 +275,7 @@
</span><span class="cx"> void setFirstLetterRemainingText(RenderTextFragment*);
</span><span class="cx">
</span><span class="cx"> // These functions are only used internally to manipulate the render tree structure via remove/insert/appendChildNode.
</span><del>- // Since they are typically called only to move objects around within anonymous blocks (which only have layers in
- // the case of column spans), the default for fullRemoveInsert is false rather than true.
</del><ins>+ // Since they are typically called only to move objects around within anonymous blocks, the default for fullRemoveInsert is false rather than true.
</ins><span class="cx"> void moveChildTo(RenderBoxModelObject* toBoxModelObject, RenderObject* child, RenderObject* beforeChild, bool fullRemoveInsert = false);
</span><span class="cx"> void moveChildTo(RenderBoxModelObject* toBoxModelObject, RenderObject* child, bool fullRemoveInsert = false)
</span><span class="cx"> {
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderFlexibleBoxcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderFlexibleBox.cpp (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderFlexibleBox.cpp 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/Source/WebCore/rendering/RenderFlexibleBox.cpp 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -259,7 +259,7 @@
</span><span class="cx">
</span><span class="cx"> LayoutRepainter repainter(*this, checkForRepaintDuringLayout());
</span><span class="cx">
</span><del>- if (updateLogicalWidthAndColumnWidth())
</del><ins>+ if (recomputeLogicalWidth())
</ins><span class="cx"> relayoutChildren = true;
</span><span class="cx">
</span><span class="cx"> LayoutUnit previousHeight = logicalHeight();
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderFlowThreadh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderFlowThread.h (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderFlowThread.h 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/Source/WebCore/rendering/RenderFlowThread.h 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -233,6 +233,9 @@
</span><span class="cx">
</span><span class="cx"> ContainingRegionMap& containingRegionMap();
</span><span class="cx">
</span><ins>+ // FIXME: Eventually as column and region flow threads start nesting, this may end up changing.
+ virtual bool shouldCheckColumnBreaks() const { return false; }
+
</ins><span class="cx"> private:
</span><span class="cx"> virtual bool isRenderFlowThread() const override final { return true; }
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderGeometryMapcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderGeometryMap.cpp (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderGeometryMap.cpp 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/Source/WebCore/rendering/RenderGeometryMap.cpp 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -166,7 +166,7 @@
</span><span class="cx"> if (style.position() == FixedPosition || style.isFlippedBlocksWritingMode())
</span><span class="cx"> return false;
</span><span class="cx">
</span><del>- if (current->hasColumns() || current->hasTransform() || current->isRenderFlowThread())
</del><ins>+ if (current->hasTransform() || current->isRenderFlowThread())
</ins><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> if (current->isSVGRoot())
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderInlinecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderInline.cpp (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderInline.cpp 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/Source/WebCore/rendering/RenderInline.cpp 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -1122,9 +1122,6 @@
</span><span class="cx"> if (hitRepaintContainer || !cb)
</span><span class="cx"> return repaintRect;
</span><span class="cx">
</span><del>- if (cb->hasColumns())
- cb->adjustRectForColumns(repaintRect);
-
</del><span class="cx"> if (cb->hasOverflowClip())
</span><span class="cx"> cb->applyCachedClipAndScrollOffsetForRepaint(repaintRect);
</span><span class="cx">
</span><span class="lines">@@ -1174,16 +1171,6 @@
</span><span class="cx">
</span><span class="cx"> LayoutPoint topLeft = rect.location();
</span><span class="cx">
</span><del>- if (o->isRenderBlockFlow() && !style().hasOutOfFlowPosition()) {
- RenderBlock* cb = toRenderBlock(o);
- if (cb->hasColumns()) {
- LayoutRect repaintRect(topLeft, rect.size());
- cb->adjustRectForColumns(repaintRect);
- topLeft = repaintRect.location();
- rect = repaintRect;
- }
- }
-
</del><span class="cx"> if (style().hasInFlowPosition() && layer()) {
</span><span class="cx"> // Apply the in-flow position offset when invalidating a rectangle. The layer
</span><span class="cx"> // is translated, but the render box isn't, so we need to do this to get the
</span><span class="lines">@@ -1212,7 +1199,7 @@
</span><span class="cx"> o->computeRectForRepaint(repaintContainer, rect, fixed);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-LayoutSize RenderInline::offsetFromContainer(RenderObject* container, const LayoutPoint& point, bool* offsetDependsOnPoint) const
</del><ins>+LayoutSize RenderInline::offsetFromContainer(RenderObject* container, const LayoutPoint&, bool* offsetDependsOnPoint) const
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(container == this->container());
</span><span class="cx">
</span><span class="lines">@@ -1220,15 +1207,11 @@
</span><span class="cx"> if (isInFlowPositioned())
</span><span class="cx"> offset += offsetForInFlowPosition();
</span><span class="cx">
</span><del>- container->adjustForColumns(offset, point);
-
</del><span class="cx"> if (container->isBox())
</span><span class="cx"> offset -= toRenderBox(container)->scrolledContentOffset();
</span><span class="cx">
</span><span class="cx"> if (offsetDependsOnPoint)
</span><del>- *offsetDependsOnPoint = container->hasColumns()
- || (container->isBox() && container->style().isFlippedBlocksWritingMode())
- || container->isRenderFlowThread();
</del><ins>+ *offsetDependsOnPoint = (container->isBox() && container->style().isFlippedBlocksWritingMode()) || container->isRenderFlowThread();
</ins><span class="cx">
</span><span class="cx"> return offset;
</span><span class="cx"> }
</span><span class="lines">@@ -1254,8 +1237,8 @@
</span><span class="cx">
</span><span class="cx"> if (mode & ApplyContainerFlip && o->isBox()) {
</span><span class="cx"> if (o->style().isFlippedBlocksWritingMode()) {
</span><del>- IntPoint centerPoint = roundedIntPoint(transformState.mappedPoint());
- transformState.move(toRenderBox(o)->flipForWritingModeIncludingColumns(centerPoint) - centerPoint);
</del><ins>+ LayoutPoint centerPoint = roundedLayoutPoint(transformState.mappedPoint());
+ transformState.move(toRenderBox(o)->flipForWritingMode(centerPoint) - centerPoint);
</ins><span class="cx"> }
</span><span class="cx"> mode &= ~ApplyContainerFlip;
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderLayercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderLayer.cpp (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderLayer.cpp 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/Source/WebCore/rendering/RenderLayer.cpp 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -46,7 +46,6 @@
</span><span class="cx">
</span><span class="cx"> #include "AnimationController.h"
</span><span class="cx"> #include "BoxShape.h"
</span><del>-#include "ColumnInfo.h"
</del><span class="cx"> #include "CSSPropertyNames.h"
</span><span class="cx"> #include "Chrome.h"
</span><span class="cx"> #include "Document.h"
</span><span class="lines">@@ -164,7 +163,6 @@
</span><span class="cx"> , m_hasVisibleContent(false)
</span><span class="cx"> , m_visibleDescendantStatusDirty(false)
</span><span class="cx"> , m_hasVisibleDescendant(false)
</span><del>- , m_isPaginated(false)
</del><span class="cx"> , m_3DTransformedDescendantStatusDirty(true)
</span><span class="cx"> , m_has3DTransformedDescendant(false)
</span><span class="cx"> , m_hasCompositingDescendant(false)
</span><span class="lines">@@ -405,10 +403,8 @@
</span><span class="cx">
</span><span class="cx"> if (flags & UpdatePagination)
</span><span class="cx"> updatePagination();
</span><del>- else {
- m_isPaginated = false;
</del><ins>+ else
</ins><span class="cx"> m_enclosingPaginationLayer = 0;
</span><del>- }
</del><span class="cx">
</span><span class="cx"> if (m_hasVisibleContent) {
</span><span class="cx"> // FIXME: LayoutState does not work with RenderLayers as there is not a 1-to-1
</span><span class="lines">@@ -462,13 +458,10 @@
</span><span class="cx"> if (isComposited())
</span><span class="cx"> flags &= ~IsCompositingUpdateRoot;
</span><span class="cx">
</span><del>- if (useRegionBasedColumns() && renderer().isInFlowRenderFlowThread()) {
</del><ins>+ if (renderer().isInFlowRenderFlowThread()) {
</ins><span class="cx"> updatePagination();
</span><span class="cx"> flags |= UpdatePagination;
</span><span class="cx"> }
</span><del>-
- if (renderer().hasColumns())
- flags |= UpdatePagination;
</del><span class="cx">
</span><span class="cx"> if (transform()) {
</span><span class="cx"> flags |= SeenTransformedLayer;
</span><span class="lines">@@ -940,99 +933,47 @@
</span><span class="cx"> return 0;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static bool checkContainingBlockChainForPagination(RenderLayerModelObject* renderer, RenderBox* ancestorColumnsRenderer)
-{
- RenderLayerModelObject* prevBlock = renderer;
- RenderBlock* containingBlock;
- for (containingBlock = renderer->containingBlock();
- containingBlock && containingBlock != &renderer->view() && containingBlock != ancestorColumnsRenderer;
- containingBlock = containingBlock->containingBlock()) {
- prevBlock = containingBlock;
- }
-
- // If the columns block wasn't in our containing block chain, then we aren't paginated by it.
- if (containingBlock != ancestorColumnsRenderer)
- return false;
-
- // If the previous block is absolutely positioned, then we can't be paginated by the columns block.
- if (prevBlock->isOutOfFlowPositioned())
- return false;
-
- // Otherwise we are paginated by the columns block.
- return true;
-}
-
-bool RenderLayer::useRegionBasedColumns() const
-{
- const Settings& settings = renderer().frame().settings();
- return settings.regionBasedColumnsEnabled();
-}
-
</del><span class="cx"> void RenderLayer::updatePagination()
</span><span class="cx"> {
</span><del>- m_isPaginated = false;
</del><span class="cx"> m_enclosingPaginationLayer = 0;
</span><span class="cx">
</span><span class="cx"> if (isComposited() || !parent())
</span><span class="cx"> return; // FIXME: We will have to deal with paginated compositing layers someday.
</span><span class="cx"> // FIXME: For now the RenderView can't be paginated. Eventually printing will move to a model where it is though.
</span><span class="cx">
</span><del>- // The main difference between the paginated booleans for the old column code and the new column code
- // is that each paginated layer has to paint on its own with the new code. There is no
- // recurring into child layers. This means that the m_isPaginated bits for the new column code can't just be set on
- // "roots" that get split and paint all their descendants. Instead each layer has to be checked individually and
</del><ins>+ // Each layer that is inside a multicolumn flow thread has to be checked individually and
</ins><span class="cx"> // genuinely know if it is going to have to split itself up when painting only its contents (and not any other descendant
</span><span class="cx"> // layers). We track an enclosingPaginationLayer instead of using a simple bit, since we want to be able to get back
</span><span class="cx"> // to that layer easily.
</span><del>- bool regionBasedColumnsUsed = useRegionBasedColumns();
- if (regionBasedColumnsUsed && renderer().isInFlowRenderFlowThread()) {
</del><ins>+ if (renderer().isInFlowRenderFlowThread()) {
</ins><span class="cx"> m_enclosingPaginationLayer = this;
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if (isNormalFlowOnly()) {
</span><del>- if (regionBasedColumnsUsed) {
- // Content inside a transform is not considered to be paginated, since we simply
- // paint the transform multiple times in each column, so we don't have to use
- // fragments for the transformed content.
- m_enclosingPaginationLayer = parent()->enclosingPaginationLayer();
- if (m_enclosingPaginationLayer && m_enclosingPaginationLayer->hasTransform())
- m_enclosingPaginationLayer = 0;
- } else
- m_isPaginated = parent()->renderer().hasColumns();
</del><ins>+ // Content inside a transform is not considered to be paginated, since we simply
+ // paint the transform multiple times in each column, so we don't have to use
+ // fragments for the transformed content.
+ m_enclosingPaginationLayer = parent()->enclosingPaginationLayer();
+ if (m_enclosingPaginationLayer && m_enclosingPaginationLayer->hasTransform())
+ m_enclosingPaginationLayer = 0;
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // For the new columns code, we want to walk up our containing block chain looking for an enclosing layer. Once
</span><span class="cx"> // we find one, then we just check its pagination status.
</span><del>- if (regionBasedColumnsUsed) {
- RenderView* renderView = &renderer().view();
- RenderBlock* containingBlock;
- for (containingBlock = renderer().containingBlock();
- containingBlock && containingBlock != renderView;
- containingBlock = containingBlock->containingBlock()) {
- if (containingBlock->hasLayer()) {
- // Content inside a transform is not considered to be paginated, since we simply
- // paint the transform multiple times in each column, so we don't have to use
- // fragments for the transformed content.
- m_enclosingPaginationLayer = containingBlock->layer()->enclosingPaginationLayer();
- if (m_enclosingPaginationLayer && m_enclosingPaginationLayer->hasTransform())
- m_enclosingPaginationLayer = 0;
- return;
- }
- }
- return;
- }
-
- // If we're not normal flow, then we need to look for a multi-column object between us and our stacking container.
- RenderLayer* ancestorStackingContainer = stackingContainer();
- for (RenderLayer* curr = parent(); curr; curr = curr->parent()) {
- if (curr->renderer().hasColumns()) {
- m_isPaginated = checkContainingBlockChainForPagination(&renderer(), curr->renderBox());
</del><ins>+ RenderView* renderView = &renderer().view();
+ RenderBlock* containingBlock;
+ for (containingBlock = renderer().containingBlock(); containingBlock && containingBlock != renderView; containingBlock = containingBlock->containingBlock()) {
+ if (containingBlock->hasLayer()) {
+ // Content inside a transform is not considered to be paginated, since we simply
+ // paint the transform multiple times in each column, so we don't have to use
+ // fragments for the transformed content.
+ m_enclosingPaginationLayer = containingBlock->layer()->enclosingPaginationLayer();
+ if (m_enclosingPaginationLayer && m_enclosingPaginationLayer->hasTransform())
+ m_enclosingPaginationLayer = 0;
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (curr == ancestorStackingContainer)
- return;
</del><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -2064,10 +2005,6 @@
</span><span class="cx">
</span><span class="cx"> if (adjustForColumns == RenderLayer::AdjustForColumns) {
</span><span class="cx"> if (RenderLayer* parentLayer = layer->parent()) {
</span><del>- LayoutSize layerColumnOffset;
- parentLayer->renderer().adjustForColumns(layerColumnOffset, location);
- location += layerColumnOffset;
-
</del><span class="cx"> if (parentLayer->renderer().isRenderMultiColumnFlowThread()) {
</span><span class="cx"> RenderRegion* region = toRenderMultiColumnFlowThread(parentLayer->renderer()).physicalTranslationFromFlowToRegion(location);
</span><span class="cx"> if (region)
</span><span class="lines">@@ -4232,11 +4169,7 @@
</span><span class="cx"> RenderLayer* childLayer = list->at(i);
</span><span class="cx"> if (childLayer->isFlowThreadCollectingGraphicsLayersUnderRegions())
</span><span class="cx"> continue;
</span><del>-
- if (!childLayer->isPaginated())
- childLayer->paintLayer(context, paintingInfo, paintFlags);
- else
- paintPaginatedChildLayer(childLayer, context, paintingInfo, paintFlags);
</del><ins>+ childLayer->paintLayer(context, paintingInfo, paintFlags);
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -4596,108 +4529,6 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void RenderLayer::paintPaginatedChildLayer(RenderLayer* childLayer, GraphicsContext* context, const LayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags)
-{
- // We need to do multiple passes, breaking up our child layer into strips.
- Vector<RenderLayer*> columnLayers;
- RenderLayer* ancestorLayer = isNormalFlowOnly() ? parent() : stackingContainer();
- for (RenderLayer* curr = childLayer->parent(); curr; curr = curr->parent()) {
- if (curr->renderer().hasColumns() && checkContainingBlockChainForPagination(&childLayer->renderer(), curr->renderBox()))
- columnLayers.append(curr);
- if (curr == ancestorLayer)
- break;
- }
-
- // It is possible for paintLayer() to be called after the child layer ceases to be paginated but before
- // updateLayerPositions() is called and resets the isPaginated() flag, see <rdar://problem/10098679>.
- // If this is the case, just bail out, since the upcoming call to updateLayerPositions() will repaint the layer.
- if (!columnLayers.size())
- return;
-
- paintChildLayerIntoColumns(childLayer, context, paintingInfo, paintFlags, columnLayers, columnLayers.size() - 1);
-}
-
-void RenderLayer::paintChildLayerIntoColumns(RenderLayer* childLayer, GraphicsContext* context, const LayerPaintingInfo& paintingInfo,
- PaintLayerFlags paintFlags, const Vector<RenderLayer*>& columnLayers, size_t colIndex)
-{
- RenderBlock& columnBlock = toRenderBlock(columnLayers[colIndex]->renderer());
-
- ASSERT(columnBlock.hasColumns());
- if (!columnBlock.hasColumns())
- return;
-
- LayoutPoint layerOffset;
- // FIXME: It looks suspicious to call convertToLayerCoords here
- // as canUseConvertToLayerCoords is true for this layer.
- columnBlock.layer()->convertToLayerCoords(paintingInfo.rootLayer, layerOffset);
-
- bool isHorizontal = columnBlock.style().isHorizontalWritingMode();
-
- ColumnInfo* colInfo = columnBlock.columnInfo();
- unsigned colCount = columnBlock.columnCount(colInfo);
- LayoutUnit currLogicalTopOffset = columnBlock.initialBlockOffsetForPainting();
- LayoutUnit blockDelta = columnBlock.blockDeltaForPaintingNextColumn();
- for (unsigned i = 0; i < colCount; i++) {
- // For each rect, we clip to the rect, and then we adjust our coords.
- LayoutRect colRect = columnBlock.columnRectAt(colInfo, i);
- columnBlock.flipForWritingMode(colRect);
-
- LayoutUnit logicalLeftOffset = (isHorizontal ? colRect.x() : colRect.y()) - columnBlock.logicalLeftOffsetForContent();
- LayoutSize offset = isHorizontal ? LayoutSize(logicalLeftOffset, currLogicalTopOffset) : LayoutSize(currLogicalTopOffset, logicalLeftOffset);
- colRect.moveBy(layerOffset);
-
- LayoutRect localDirtyRect(paintingInfo.paintDirtyRect);
- localDirtyRect.intersect(colRect);
- if (!localDirtyRect.isEmpty()) {
- GraphicsContextStateSaver stateSaver(*context);
-
- // Each strip pushes a clip, since column boxes are specified as being
- // like overflow:hidden.
- context->clip(pixelSnappedIntRect(colRect));
-
- if (!colIndex) {
- // Apply a translation transform to change where the layer paints.
- TransformationMatrix oldTransform;
- bool oldHasTransform = childLayer->transform();
- if (oldHasTransform)
- oldTransform = *childLayer->transform();
- TransformationMatrix newTransform(oldTransform);
- newTransform.translateRight(roundToInt(offset.width()), roundToInt(offset.height()));
-
- childLayer->m_transform = std::make_unique<TransformationMatrix>(newTransform);
-
- LayerPaintingInfo localPaintingInfo(paintingInfo);
- localPaintingInfo.paintDirtyRect = localDirtyRect;
- childLayer->paintLayer(context, localPaintingInfo, paintFlags);
-
- if (oldHasTransform)
- childLayer->m_transform = std::make_unique<TransformationMatrix>(oldTransform);
- else
- childLayer->m_transform = nullptr;
- } else {
- // Adjust the transform such that the renderer's upper left corner will paint at (0,0) in user space.
- // This involves subtracting out the position of the layer in our current coordinate space.
- LayoutPoint childOffset;
- columnLayers[colIndex - 1]->convertToLayerCoords(paintingInfo.rootLayer, childOffset);
- TransformationMatrix transform;
- transform.translateRight(roundToInt(childOffset.x() + offset.width()), roundToInt(childOffset.y() + offset.height()));
-
- // Apply the transform.
- context->concatCTM(transform.toAffineTransform());
-
- // Now do a paint with the root layer shifted to be the next multicol block.
- LayerPaintingInfo columnPaintingInfo(paintingInfo);
- columnPaintingInfo.rootLayer = columnLayers[colIndex - 1];
- columnPaintingInfo.paintDirtyRect = transform.inverse().mapRect(localDirtyRect);
- paintChildLayerIntoColumns(childLayer, context, columnPaintingInfo, paintFlags, columnLayers, colIndex - 1);
- }
- }
-
- // Move to the next position.
- currLogicalTopOffset += blockDelta;
- }
-}
-
</del><span class="cx"> bool RenderLayer::hitTest(const HitTestRequest& request, HitTestResult& result)
</span><span class="cx"> {
</span><span class="cx"> return hitTest(request, result.hitTestLocation(), result);
</span><span class="lines">@@ -5231,10 +5062,7 @@
</span><span class="cx"> continue;
</span><span class="cx"> RenderLayer* hitLayer = 0;
</span><span class="cx"> HitTestResult tempResult(result.hitTestLocation());
</span><del>- if (childLayer->isPaginated())
- hitLayer = hitTestPaginatedChildLayer(childLayer, rootLayer, request, tempResult, hitTestRect, hitTestLocation, transformState, zOffsetForDescendants);
- else
- hitLayer = childLayer->hitTestLayer(rootLayer, this, request, tempResult, hitTestRect, hitTestLocation, false, transformState, zOffsetForDescendants);
</del><ins>+ hitLayer = childLayer->hitTestLayer(rootLayer, this, request, tempResult, hitTestRect, hitTestLocation, false, transformState, zOffsetForDescendants);
</ins><span class="cx">
</span><span class="cx"> // If it a rect-based test, we can safely append the temporary result since it might had hit
</span><span class="cx"> // nodes but not necesserily had hitLayer set.
</span><span class="lines">@@ -5253,104 +5081,6 @@
</span><span class="cx"> return resultLayer;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-RenderLayer* RenderLayer::hitTestPaginatedChildLayer(RenderLayer* childLayer, RenderLayer* rootLayer, const HitTestRequest& request, HitTestResult& result,
- const LayoutRect& hitTestRect, const HitTestLocation& hitTestLocation, const HitTestingTransformState* transformState, double* zOffset)
-{
- Vector<RenderLayer*> columnLayers;
- RenderLayer* ancestorLayer = isNormalFlowOnly() ? parent() : stackingContainer();
- for (RenderLayer* curr = childLayer->parent(); curr; curr = curr->parent()) {
- if (curr->renderer().hasColumns() && checkContainingBlockChainForPagination(&childLayer->renderer(), curr->renderBox()))
- columnLayers.append(curr);
- if (curr == ancestorLayer)
- break;
- }
-
- ASSERT(columnLayers.size());
- return hitTestChildLayerColumns(childLayer, rootLayer, request, result, hitTestRect, hitTestLocation, transformState, zOffset,
- columnLayers, columnLayers.size() - 1);
-}
-
-RenderLayer* RenderLayer::hitTestChildLayerColumns(RenderLayer* childLayer, RenderLayer* rootLayer, const HitTestRequest& request, HitTestResult& result,
- const LayoutRect& hitTestRect, const HitTestLocation& hitTestLocation, const HitTestingTransformState* transformState, double* zOffset,
- const Vector<RenderLayer*>& columnLayers, size_t columnIndex)
-{
- RenderBlock& columnBlock = toRenderBlock(columnLayers[columnIndex]->renderer());
-
- ASSERT(columnBlock.hasColumns());
- if (!columnBlock.hasColumns())
- return 0;
-
- LayoutPoint layerOffset;
- columnBlock.layer()->convertToLayerCoords(rootLayer, layerOffset);
-
- ColumnInfo* colInfo = columnBlock.columnInfo();
- int colCount = columnBlock.columnCount(colInfo);
-
- // We have to go backwards from the last column to the first.
- bool isHorizontal = columnBlock.style().isHorizontalWritingMode();
- LayoutUnit logicalLeft = columnBlock.logicalLeftOffsetForContent();
- LayoutUnit currLogicalTopOffset = columnBlock.initialBlockOffsetForPainting();
- LayoutUnit blockDelta = columnBlock.blockDeltaForPaintingNextColumn();
- currLogicalTopOffset += colCount * blockDelta;
- for (int i = colCount - 1; i >= 0; i--) {
- // For each rect, we clip to the rect, and then we adjust our coords.
- LayoutRect colRect = columnBlock.columnRectAt(colInfo, i);
- columnBlock.flipForWritingMode(colRect);
- LayoutUnit currLogicalLeftOffset = (isHorizontal ? colRect.x() : colRect.y()) - logicalLeft;
- currLogicalTopOffset -= blockDelta;
-
- LayoutSize offset = isHorizontal ? LayoutSize(currLogicalLeftOffset, currLogicalTopOffset) : LayoutSize(currLogicalTopOffset, currLogicalLeftOffset);
-
- colRect.moveBy(layerOffset);
-
- LayoutRect localClipRect(hitTestRect);
- localClipRect.intersect(colRect);
-
- if (!localClipRect.isEmpty() && hitTestLocation.intersects(localClipRect)) {
- RenderLayer* hitLayer = 0;
- if (!columnIndex) {
- // Apply a translation transform to change where the layer paints.
- TransformationMatrix oldTransform;
- bool oldHasTransform = childLayer->transform();
- if (oldHasTransform)
- oldTransform = *childLayer->transform();
- TransformationMatrix newTransform(oldTransform);
- newTransform.translateRight(offset.width(), offset.height());
-
- childLayer->m_transform = std::make_unique<TransformationMatrix>(newTransform);
- hitLayer = childLayer->hitTestLayer(rootLayer, columnLayers[0], request, result, localClipRect, hitTestLocation, false, transformState, zOffset);
- if (oldHasTransform)
- childLayer->m_transform = std::make_unique<TransformationMatrix>(oldTransform);
- else
- childLayer->m_transform = nullptr;
- } else {
- // Adjust the transform such that the renderer's upper left corner will be at (0,0) in user space.
- // This involves subtracting out the position of the layer in our current coordinate space.
- RenderLayer* nextLayer = columnLayers[columnIndex - 1];
- RefPtr<HitTestingTransformState> newTransformState = nextLayer->createLocalTransformState(rootLayer, nextLayer, localClipRect, hitTestLocation, transformState);
- newTransformState->translate(offset.width(), offset.height(), HitTestingTransformState::AccumulateTransform);
- FloatPoint localPoint = newTransformState->mappedPoint();
- FloatQuad localPointQuad = newTransformState->mappedQuad();
- LayoutRect localHitTestRect = newTransformState->mappedArea().enclosingBoundingBox();
- HitTestLocation newHitTestLocation;
- if (hitTestLocation.isRectBasedTest())
- newHitTestLocation = HitTestLocation(localPoint, localPointQuad);
- else
- newHitTestLocation = HitTestLocation(localPoint);
- newTransformState->flatten();
-
- hitLayer = hitTestChildLayerColumns(childLayer, columnLayers[columnIndex - 1], request, result, localHitTestRect, newHitTestLocation,
- newTransformState.get(), zOffset, columnLayers, columnIndex - 1);
- }
-
- if (hitLayer)
- return hitLayer;
- }
- }
-
- return 0;
-}
-
</del><span class="cx"> void RenderLayer::updateClipRects(const ClipRectsContext& clipRectsContext)
</span><span class="cx"> {
</span><span class="cx"> ClipRectsType clipRectsType = clipRectsContext.clipRectsType;
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderLayerh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderLayer.h (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderLayer.h 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/Source/WebCore/rendering/RenderLayer.h 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -515,7 +515,6 @@
</span><span class="cx">
</span><span class="cx"> void positionNewlyCreatedOverflowControls();
</span><span class="cx">
</span><del>- bool isPaginated() const { return m_isPaginated; }
</del><span class="cx"> RenderLayer* enclosingPaginationLayer() const { return m_enclosingPaginationLayer; }
</span><span class="cx">
</span><span class="cx"> void updateTransform();
</span><span class="lines">@@ -633,7 +632,7 @@
</span><span class="cx"> bool canUseConvertToLayerCoords() const
</span><span class="cx"> {
</span><span class="cx"> // These RenderObject have an impact on their layers' without them knowing about it.
</span><del>- return !renderer().hasColumns() && !renderer().hasTransform() && !renderer().isSVGRoot();
</del><ins>+ return !renderer().hasTransform() && !renderer().isSVGRoot();
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // FIXME: adjustForColumns allows us to position compositing layers in columns correctly, but eventually they need to be split across columns too.
</span><span class="lines">@@ -999,8 +998,6 @@
</span><span class="cx"> void paintLayerByApplyingTransform(GraphicsContext*, const LayerPaintingInfo&, PaintLayerFlags, const LayoutPoint& translationOffset = LayoutPoint());
</span><span class="cx"> void paintLayerContents(GraphicsContext*, const LayerPaintingInfo&, PaintLayerFlags);
</span><span class="cx"> void paintList(Vector<RenderLayer*>*, GraphicsContext*, const LayerPaintingInfo&, PaintLayerFlags);
</span><del>- void paintPaginatedChildLayer(RenderLayer* childLayer, GraphicsContext*, const LayerPaintingInfo&, PaintLayerFlags);
- void paintChildLayerIntoColumns(RenderLayer* childLayer, GraphicsContext*, const LayerPaintingInfo&, PaintLayerFlags, const Vector<RenderLayer*>& columnLayers, size_t columnIndex);
</del><span class="cx">
</span><span class="cx"> void collectFragments(LayerFragments&, const RenderLayer* rootLayer, RenderRegion*, const LayoutRect& dirtyRect,
</span><span class="cx"> ClipRectsType, OverlayScrollbarSizeRelevancy inOverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize,
</span><span class="lines">@@ -1027,13 +1024,6 @@
</span><span class="cx"> const LayoutRect& hitTestRect, const HitTestLocation&,
</span><span class="cx"> const HitTestingTransformState* transformState, double* zOffsetForDescendants, double* zOffset,
</span><span class="cx"> const HitTestingTransformState* unflattenedTransformState, bool depthSortDescendants);
</span><del>- RenderLayer* hitTestPaginatedChildLayer(RenderLayer* childLayer, RenderLayer* rootLayer, const HitTestRequest& request, HitTestResult& result,
- const LayoutRect& hitTestRect, const HitTestLocation&,
- const HitTestingTransformState* transformState, double* zOffset);
- RenderLayer* hitTestChildLayerColumns(RenderLayer* childLayer, RenderLayer* rootLayer, const HitTestRequest& request, HitTestResult& result,
- const LayoutRect& hitTestRect, const HitTestLocation&,
- const HitTestingTransformState* transformState, double* zOffset,
- const Vector<RenderLayer*>& columnLayers, size_t columnIndex);
</del><span class="cx">
</span><span class="cx"> RenderLayer* hitTestFixedLayersInNamedFlows(RenderLayer* rootLayer,
</span><span class="cx"> const HitTestRequest&, HitTestResult&,
</span><span class="lines">@@ -1160,9 +1150,6 @@
</span><span class="cx"> void drawPlatformResizerImage(GraphicsContext*, const LayoutRect& resizerCornerRect);
</span><span class="cx">
</span><span class="cx"> void updatePagination();
</span><del>-
- // FIXME: Temporary. Remove when new columns come online.
- bool useRegionBasedColumns() const;
</del><span class="cx">
</span><span class="cx"> void setHasCompositingDescendant(bool b) { m_hasCompositingDescendant = b; }
</span><span class="cx">
</span><span class="lines">@@ -1252,8 +1239,6 @@
</span><span class="cx"> bool m_visibleDescendantStatusDirty : 1;
</span><span class="cx"> bool m_hasVisibleDescendant : 1;
</span><span class="cx">
</span><del>- bool m_isPaginated : 1; // If we think this layer is split by a multi-column ancestor, then this bit will be set.
-
</del><span class="cx"> bool m_3DTransformedDescendantStatusDirty : 1;
</span><span class="cx"> bool m_has3DTransformedDescendant : 1; // Set on a stacking context layer that has 3D descendants anywhere
</span><span class="cx"> // in a preserves3D hierarchy. Hint to do 3D-aware hit testing.
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderMultiColumnFlowThreadcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderMultiColumnFlowThread.cpp (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderMultiColumnFlowThread.cpp 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/Source/WebCore/rendering/RenderMultiColumnFlowThread.cpp 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -774,4 +774,11 @@
</span><span class="cx"> return inside;
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+bool RenderMultiColumnFlowThread::shouldCheckColumnBreaks() const
+{
+ if (!parent()->isRenderView())
+ return true;
+ return view().frameView().pagination().behavesLikeColumns;
</ins><span class="cx"> }
</span><ins>+
+}
</ins></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderMultiColumnFlowThreadh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderMultiColumnFlowThread.h (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderMultiColumnFlowThread.h 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/Source/WebCore/rendering/RenderMultiColumnFlowThread.h 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -92,7 +92,7 @@
</span><span class="cx"> bool progressionIsReversed() const { return m_progressionIsReversed; }
</span><span class="cx"> void setProgressionIsReversed(bool reversed) { m_progressionIsReversed = reversed; }
</span><span class="cx">
</span><del>- virtual void computeLineGridPaginationOrigin(LayoutState&) const override;
</del><ins>+ void computeLineGridPaginationOrigin(LayoutState&) const;
</ins><span class="cx">
</span><span class="cx"> virtual RenderRegion* mapFromFlowToRegion(TransformState&) const override;
</span><span class="cx">
</span><span class="lines">@@ -111,6 +111,9 @@
</span><span class="cx"> virtual void mapAbsoluteToLocalPoint(MapCoordinatesFlags, TransformState&) const override;
</span><span class="cx"> virtual LayoutSize offsetFromContainer(RenderObject*, const LayoutPoint&, bool* offsetDependsOnPoint = nullptr) const override;
</span><span class="cx">
</span><ins>+ // FIXME: Eventually as column and region flow threads start nesting, this will end up changing.
+ virtual bool shouldCheckColumnBreaks() const override;
+
</ins><span class="cx"> private:
</span><span class="cx"> virtual const char* renderName() const override;
</span><span class="cx"> virtual void addRegionToThread(RenderRegion*) override;
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderObjectcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderObject.cpp (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderObject.cpp 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/Source/WebCore/rendering/RenderObject.cpp 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -1370,12 +1370,6 @@
</span><span class="cx"> return;
</span><span class="cx">
</span><span class="cx"> if (auto o = parent()) {
</span><del>- if (o->isRenderBlockFlow()) {
- RenderBlock* cb = toRenderBlock(o);
- if (cb->hasColumns())
- cb->adjustRectForColumns(rect);
- }
-
</del><span class="cx"> if (o->hasOverflowClip()) {
</span><span class="cx"> RenderBox* boxParent = toRenderBox(o);
</span><span class="cx"> boxParent->applyCachedClipAndScrollOffsetForRepaint(rect);
</span><span class="lines">@@ -1619,15 +1613,10 @@
</span><span class="cx"> LayoutPoint centerPoint = roundedLayoutPoint(transformState.mappedPoint());
</span><span class="cx"> if (mode & ApplyContainerFlip && o->isBox()) {
</span><span class="cx"> if (o->style().isFlippedBlocksWritingMode())
</span><del>- transformState.move(toRenderBox(o)->flipForWritingModeIncludingColumns(roundedLayoutPoint(transformState.mappedPoint())) - centerPoint);
</del><ins>+ transformState.move(toRenderBox(o)->flipForWritingMode(roundedLayoutPoint(transformState.mappedPoint())) - centerPoint);
</ins><span class="cx"> mode &= ~ApplyContainerFlip;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- LayoutSize columnOffset;
- o->adjustForColumns(columnOffset, roundedLayoutPoint(transformState.mappedPoint()));
- if (!columnOffset.isZero())
- transformState.move(columnOffset);
-
</del><span class="cx"> if (o->isBox())
</span><span class="cx"> transformState.move(-toRenderBox(o)->scrolledContentOffset());
</span><span class="cx">
</span><span class="lines">@@ -1647,7 +1636,7 @@
</span><span class="cx"> if (container->isBox())
</span><span class="cx"> offset = -toRenderBox(container)->scrolledContentOffset();
</span><span class="cx">
</span><del>- geometryMap.push(this, offset, hasColumns());
</del><ins>+ geometryMap.push(this, offset, false);
</ins><span class="cx">
</span><span class="cx"> return container;
</span><span class="cx"> }
</span><span class="lines">@@ -1720,19 +1709,16 @@
</span><span class="cx"> return transformState.lastPlanarPoint();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-LayoutSize RenderObject::offsetFromContainer(RenderObject* o, const LayoutPoint& point, bool* offsetDependsOnPoint) const
</del><ins>+LayoutSize RenderObject::offsetFromContainer(RenderObject* o, const LayoutPoint&, bool* offsetDependsOnPoint) const
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(o == container());
</span><span class="cx">
</span><span class="cx"> LayoutSize offset;
</span><del>-
- o->adjustForColumns(offset, point);
-
</del><span class="cx"> if (o->isBox())
</span><span class="cx"> offset -= toRenderBox(o)->scrolledContentOffset();
</span><span class="cx">
</span><span class="cx"> if (offsetDependsOnPoint)
</span><del>- *offsetDependsOnPoint = hasColumns() || o->isRenderFlowThread();
</del><ins>+ *offsetDependsOnPoint = o->isRenderFlowThread();
</ins><span class="cx">
</span><span class="cx"> return offset;
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderObjecth"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderObject.h (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderObject.h 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/Source/WebCore/rendering/RenderObject.h 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -389,9 +389,7 @@
</span><span class="cx">
</span><span class="cx"> bool childrenInline() const { return m_bitfields.childrenInline(); }
</span><span class="cx"> void setChildrenInline(bool b) { m_bitfields.setChildrenInline(b); }
</span><del>- bool hasColumns() const { return m_bitfields.hasColumns(); }
- void setHasColumns(bool b = true) { m_bitfields.setHasColumns(b); }
-
</del><ins>+
</ins><span class="cx"> enum FlowThreadState {
</span><span class="cx"> NotInsideFlowThread = 0,
</span><span class="cx"> InsideOutOfFlowThread = 1,
</span><span class="lines">@@ -494,8 +492,6 @@
</span><span class="cx"> #endif
</span><span class="cx"> ;
</span><span class="cx"> }
</span><del>- bool isAnonymousColumnsBlock() const { return style().specifiesColumns() && isAnonymousBlock(); }
- bool isAnonymousColumnSpanBlock() const { return style().columnSpan() && isAnonymousBlock(); }
</del><span class="cx"> bool isElementContinuation() const { return node() && node()->renderer() != this; }
</span><span class="cx"> bool isInlineElementContinuation() const { return isElementContinuation() && isInline(); }
</span><span class="cx"> bool isBlockElementContinuation() const { return isElementContinuation() && !isInline(); }
</span><span class="lines">@@ -764,16 +760,6 @@
</span><span class="cx"> virtual void computeRectForRepaint(const RenderLayerModelObject* repaintContainer, LayoutRect&, bool fixed = false) const;
</span><span class="cx"> virtual void computeFloatRectForRepaint(const RenderLayerModelObject* repaintContainer, FloatRect& repaintRect, bool fixed = false) const;
</span><span class="cx">
</span><del>- // If multiple-column layout results in applying an offset to the given point, add the same
- // offset to the given size.
- virtual void adjustForColumns(LayoutSize&, const LayoutPoint&) const { }
- LayoutSize offsetForColumns(const LayoutPoint& point) const
- {
- LayoutSize offset;
- adjustForColumns(offset, point);
- return offset;
- }
-
</del><span class="cx"> virtual unsigned int length() const { return 1; }
</span><span class="cx">
</span><span class="cx"> bool isFloatingOrOutOfFlowPositioned() const { return (isFloating() || isOutOfFlowPositioned()); }
</span><span class="lines">@@ -966,7 +952,6 @@
</span><span class="cx"> , m_hasCounterNodeMap(false)
</span><span class="cx"> , m_everHadLayout(false)
</span><span class="cx"> , m_childrenInline(false)
</span><del>- , m_hasColumns(false)
</del><span class="cx"> , m_positionedState(IsStaticallyPositioned)
</span><span class="cx"> , m_selectionState(SelectionNone)
</span><span class="cx"> , m_flowThreadState(NotInsideFlowThread)
</span><span class="lines">@@ -1002,7 +987,6 @@
</span><span class="cx">
</span><span class="cx"> // from RenderBlock
</span><span class="cx"> ADD_BOOLEAN_BITFIELD(childrenInline, ChildrenInline);
</span><del>- ADD_BOOLEAN_BITFIELD(hasColumns, HasColumns);
</del><span class="cx">
</span><span class="cx"> private:
</span><span class="cx"> unsigned m_positionedState : 2; // PositionedState
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderTextcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderText.cpp (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderText.cpp 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/Source/WebCore/rendering/RenderText.cpp 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -1277,12 +1277,8 @@
</span><span class="cx">
</span><span class="cx"> if (clipToVisibleContent)
</span><span class="cx"> computeRectForRepaint(repaintContainer, rect);
</span><del>- else {
- if (cb->hasColumns())
- cb->adjustRectForColumns(rect);
-
</del><ins>+ else
</ins><span class="cx"> rect = localToContainerQuad(FloatRect(rect), repaintContainer).enclosingBoundingBox();
</span><del>- }
</del><span class="cx">
</span><span class="cx"> return rect;
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderViewcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderView.cpp (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderView.cpp 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/Source/WebCore/rendering/RenderView.cpp 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -21,7 +21,6 @@
</span><span class="cx"> #include "config.h"
</span><span class="cx"> #include "RenderView.h"
</span><span class="cx">
</span><del>-#include "ColumnInfo.h"
</del><span class="cx"> #include "Document.h"
</span><span class="cx"> #include "Element.h"
</span><span class="cx"> #include "FloatQuad.h"
</span><span class="lines">@@ -174,9 +173,8 @@
</span><span class="cx">
</span><span class="cx"> LayoutUnit RenderView::availableLogicalHeight(AvailableLogicalHeightType) const
</span><span class="cx"> {
</span><del>- // If we have columns, then the available logical height is reduced to the column height.
- if (hasColumns())
- return columnInfo()->columnHeight();
</del><ins>+ // FIXME: Need to patch for new columns?
+
</ins><span class="cx"> #if PLATFORM(IOS)
</span><span class="cx"> // Workaround for <rdar://problem/7166808>.
</span><span class="cx"> if (document().isPluginDocument() && frameView().useFixedLayout())
</span><span class="lines">@@ -340,7 +338,7 @@
</span><span class="cx"> if (document().printing())
</span><span class="cx"> return pageLogicalHeight();
</span><span class="cx">
</span><del>- if ((hasColumns() || multiColumnFlowThread()) && !style().hasInlineColumnAxis()) {
</del><ins>+ if (multiColumnFlowThread() && !style().hasInlineColumnAxis()) {
</ins><span class="cx"> if (int pageLength = frameView().pagination().pageLength)
</span><span class="cx"> return pageLength;
</span><span class="cx"> }
</span><span class="lines">@@ -457,11 +455,6 @@
</span><span class="cx"> setComputedColumnCountAndWidth(1, columnWidth);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-ColumnInfo::PaginationUnit RenderView::paginationUnit() const
-{
- return frameView().pagination().behavesLikeColumns ? ColumnInfo::Column : ColumnInfo::Page;
-}
-
</del><span class="cx"> void RenderView::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
</span><span class="cx"> {
</span><span class="cx"> // If we ever require layout but receive a paint anyway, something has gone horribly wrong.
</span><span class="lines">@@ -1107,23 +1100,16 @@
</span><span class="cx"> return rootObject->rendererForRootBackground().hasEntirelyFixedBackground();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-LayoutRect RenderView::unextendedBackgroundRect(RenderBox* backgroundRenderer) const
</del><ins>+LayoutRect RenderView::unextendedBackgroundRect(RenderBox*) const
</ins><span class="cx"> {
</span><del>- if (!hasColumns())
- return unscaledDocumentRect();
-
- ColumnInfo* columnInfo = this->columnInfo();
- LayoutRect backgroundRect(0, 0, columnInfo->desiredColumnWidth(), columnInfo->columnHeight() * columnInfo->columnCount());
- if (!isHorizontalWritingMode())
- backgroundRect = backgroundRect.transposedRect();
- backgroundRenderer->flipForWritingMode(backgroundRect);
-
- return backgroundRect;
</del><ins>+ // FIXME: What is this? Need to patch for new columns?
+ return unscaledDocumentRect();
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> LayoutRect RenderView::backgroundRect(RenderBox* backgroundRenderer) const
</span><span class="cx"> {
</span><del>- if (!hasColumns() && frameView().hasExtendedBackgroundRectForPainting())
</del><ins>+ // FIXME: New columns care about this?
+ if (frameView().hasExtendedBackgroundRectForPainting())
</ins><span class="cx"> return frameView().extendedBackgroundRectForPainting();
</span><span class="cx">
</span><span class="cx"> return unextendedBackgroundRect(backgroundRenderer);
</span><span class="lines">@@ -1181,7 +1167,7 @@
</span><span class="cx"> {
</span><span class="cx"> RenderObject* o = renderer;
</span><span class="cx"> while (o) {
</span><del>- if (o->hasColumns() || o->hasTransform() || o->hasReflection())
</del><ins>+ if (o->hasTransform() || o->hasReflection())
</ins><span class="cx"> return true;
</span><span class="cx"> o = o->container();
</span><span class="cx"> }
</span><span class="lines">@@ -1380,13 +1366,7 @@
</span><span class="cx"> bool progressionIsInline = false;
</span><span class="cx"> bool progressionIsReversed = false;
</span><span class="cx">
</span><del>- if (hasColumns()) {
- ColumnInfo* colInfo = columnInfo();
- if (!colInfo)
- return columnNumber;
- progressionIsInline = colInfo->progressionIsInline();
- progressionIsReversed = colInfo->progressionIsReversed();
- } else if (multiColumnFlowThread()) {
</del><ins>+ if (multiColumnFlowThread()) {
</ins><span class="cx"> progressionIsInline = multiColumnFlowThread()->progressionIsInline();
</span><span class="cx"> progressionIsReversed = multiColumnFlowThread()->progressionIsReversed();
</span><span class="cx"> } else
</span><span class="lines">@@ -1408,8 +1388,6 @@
</span><span class="cx"> if (pagination.mode == Pagination::Unpaginated)
</span><span class="cx"> return 0;
</span><span class="cx">
</span><del>- if (hasColumns())
- return columnCount(columnInfo());
</del><span class="cx"> if (multiColumnFlowThread() && multiColumnFlowThread()->firstMultiColumnSet())
</span><span class="cx"> return multiColumnFlowThread()->firstMultiColumnSet()->columnCount();
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderViewh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderView.h (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderView.h 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/Source/WebCore/rendering/RenderView.h 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -256,18 +256,17 @@
</span><span class="cx"> void initializeLayoutState(LayoutState&);
</span><span class="cx">
</span><span class="cx"> virtual void computeColumnCountAndWidth() override;
</span><del>- virtual ColumnInfo::PaginationUnit paginationUnit() const override;
</del><span class="cx">
</span><span class="cx"> bool shouldRepaint(const LayoutRect&) const;
</span><span class="cx"> void flushAccumulatedRepaintRegion() const;
</span><span class="cx">
</span><span class="cx"> // These functions may only be accessed by LayoutStateMaintainer.
</span><del>- bool pushLayoutState(RenderBox& renderer, const LayoutSize& offset, LayoutUnit pageHeight = 0, bool pageHeightChanged = false, ColumnInfo* colInfo = nullptr)
</del><ins>+ bool pushLayoutState(RenderBox& renderer, const LayoutSize& offset, LayoutUnit pageHeight = 0, bool pageHeightChanged = false)
</ins><span class="cx"> {
</span><span class="cx"> // We push LayoutState even if layoutState is disabled because it stores layoutDelta too.
</span><del>- if (!doingFullRepaint() || m_layoutState->isPaginated() || renderer.hasColumns() || renderer.flowThreadContainingBlock()
</del><ins>+ if (!doingFullRepaint() || m_layoutState->isPaginated() || renderer.flowThreadContainingBlock()
</ins><span class="cx"> || m_layoutState->lineGrid() || (renderer.style().lineGrid() != RenderStyle::initialLineGrid() && renderer.isRenderBlockFlow())) {
</span><del>- m_layoutState = std::make_unique<LayoutState>(std::move(m_layoutState), &renderer, offset, pageHeight, pageHeightChanged, colInfo);
</del><ins>+ m_layoutState = std::make_unique<LayoutState>(std::move(m_layoutState), &renderer, offset, pageHeight, pageHeightChanged);
</ins><span class="cx"> pushLayoutStateForCurrentFlowThread(renderer);
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="lines">@@ -371,14 +370,14 @@
</span><span class="cx"> WTF_MAKE_NONCOPYABLE(LayoutStateMaintainer);
</span><span class="cx"> public:
</span><span class="cx"> // Constructor to push now.
</span><del>- explicit LayoutStateMaintainer(RenderView& view, RenderBox& root, LayoutSize offset, bool disableState = false, LayoutUnit pageHeight = 0, bool pageHeightChanged = false, ColumnInfo* colInfo = nullptr)
</del><ins>+ explicit LayoutStateMaintainer(RenderView& view, RenderBox& root, LayoutSize offset, bool disableState = false, LayoutUnit pageHeight = 0, bool pageHeightChanged = false)
</ins><span class="cx"> : m_view(view)
</span><span class="cx"> , m_disabled(disableState)
</span><span class="cx"> , m_didStart(false)
</span><span class="cx"> , m_didEnd(false)
</span><span class="cx"> , m_didCreateLayoutState(false)
</span><span class="cx"> {
</span><del>- push(root, offset, pageHeight, pageHeightChanged, colInfo);
</del><ins>+ push(root, offset, pageHeight, pageHeightChanged);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // Constructor to maybe push later.
</span><span class="lines">@@ -396,11 +395,11 @@
</span><span class="cx"> ASSERT(m_didStart == m_didEnd); // if this fires, it means that someone did a push(), but forgot to pop().
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void push(RenderBox& root, LayoutSize offset, LayoutUnit pageHeight = 0, bool pageHeightChanged = false, ColumnInfo* colInfo = nullptr)
</del><ins>+ void push(RenderBox& root, LayoutSize offset, LayoutUnit pageHeight = 0, bool pageHeightChanged = false)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(!m_didStart);
</span><span class="cx"> // We push state even if disabled, because we still need to store layoutDelta
</span><del>- m_didCreateLayoutState = m_view.pushLayoutState(root, offset, pageHeight, pageHeightChanged, colInfo);
</del><ins>+ m_didCreateLayoutState = m_view.pushLayoutState(root, offset, pageHeight, pageHeightChanged);
</ins><span class="cx"> if (m_disabled && m_didCreateLayoutState)
</span><span class="cx"> m_view.disableLayoutState();
</span><span class="cx"> m_didStart = true;
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingSimpleLineLayoutcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/SimpleLineLayout.cpp (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/SimpleLineLayout.cpp 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/Source/WebCore/rendering/SimpleLineLayout.cpp 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -115,9 +115,6 @@
</span><span class="cx"> // FIXME: Placeholders do something strange.
</span><span class="cx"> if (flow.parent()->isTextControl() && toRenderTextControl(*flow.parent()).textFormControlElement().placeholderElement())
</span><span class="cx"> return false;
</span><del>- // These tests only works during layout. Outside layout this function may give false positives.
- if (flow.view().layoutState() && flow.view().layoutState()->m_columnInfo)
- return false;
</del><span class="cx"> const RenderStyle& style = flow.style();
</span><span class="cx"> if (style.textDecorationsInEffect() != TextDecorationNone)
</span><span class="cx"> return false;
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingsvgRenderSVGTextcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/svg/RenderSVGText.cpp (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/svg/RenderSVGText.cpp 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/Source/WebCore/rendering/svg/RenderSVGText.cpp 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -398,7 +398,7 @@
</span><span class="cx"> ASSERT(!simplifiedLayout());
</span><span class="cx"> ASSERT(!scrollsOverflow());
</span><span class="cx"> ASSERT(!hasControlClip());
</span><del>- ASSERT(!hasColumns());
</del><ins>+ ASSERT(!multiColumnFlowThread());
</ins><span class="cx"> ASSERT(!positionedObjects());
</span><span class="cx"> ASSERT(!m_overflow);
</span><span class="cx"> ASSERT(!isAnonymousBlock());
</span></span></pre></div>
<a id="trunkSourceWebCorestyleStyleResolveForDocumentcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/style/StyleResolveForDocument.cpp (168379 => 168380)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/style/StyleResolveForDocument.cpp 2014-05-06 21:32:25 UTC (rev 168379)
+++ trunk/Source/WebCore/style/StyleResolveForDocument.cpp 2014-05-06 21:35:52 UTC (rev 168380)
</span><span class="lines">@@ -89,7 +89,7 @@
</span><span class="cx"> if (pagination.mode != Pagination::Unpaginated) {
</span><span class="cx"> documentStyle.get().setColumnStylesFromPaginationMode(pagination.mode);
</span><span class="cx"> documentStyle.get().setColumnGap(pagination.gap);
</span><del>- if (renderView.hasColumns() || renderView.multiColumnFlowThread())
</del><ins>+ if (renderView.multiColumnFlowThread())
</ins><span class="cx"> renderView.updateColumnProgressionFromStyle(&documentStyle.get());
</span><span class="cx"> }
</span><span class="cx">
</span></span></pre>
</div>
</div>
</body>
</html>