Move continuation teardown from subclasses to RenderBoxModelObject.
[WebKit-https.git] / Source / WebCore / rendering / RenderBlockFlow.cpp
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  *           (C) 2007 David Smith (catfish.man@gmail.com)
5  * Copyright (C) 2003-2013 Apple Inc. All rights reserved.
6  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public License
19  * along with this library; see the file COPYING.LIB.  If not, write to
20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21  * Boston, MA 02110-1301, USA.
22  */
23
24 #include "config.h"
25 #include "RenderBlockFlow.h"
26
27 #include "Editor.h"
28 #include "FloatingObjects.h"
29 #include "Frame.h"
30 #include "FrameSelection.h"
31 #include "HTMLElement.h"
32 #include "HitTestLocation.h"
33 #include "InlineTextBox.h"
34 #include "LayoutRepainter.h"
35 #include "RenderCombineText.h"
36 #include "RenderFlowThread.h"
37 #include "RenderInline.h"
38 #include "RenderIterator.h"
39 #include "RenderLayer.h"
40 #include "RenderListItem.h"
41 #include "RenderMarquee.h"
42 #include "RenderMultiColumnFlowThread.h"
43 #include "RenderMultiColumnSet.h"
44 #include "RenderNamedFlowFragment.h"
45 #include "RenderTableCell.h"
46 #include "RenderText.h"
47 #include "RenderView.h"
48 #include "SimpleLineLayoutFunctions.h"
49 #include "VerticalPositionCache.h"
50 #include "VisiblePosition.h"
51
52 namespace WebCore {
53
54 bool RenderBlock::s_canPropagateFloatIntoSibling = false;
55
56 struct SameSizeAsMarginInfo {
57     uint32_t bitfields : 16;
58     LayoutUnit margins[2];
59 };
60
61 COMPILE_ASSERT(sizeof(RenderBlockFlow::MarginValues) == sizeof(LayoutUnit[4]), MarginValues_should_stay_small);
62 COMPILE_ASSERT(sizeof(RenderBlockFlow::MarginInfo) == sizeof(SameSizeAsMarginInfo), MarginInfo_should_stay_small);
63
64 // Our MarginInfo state used when laying out block children.
65 RenderBlockFlow::MarginInfo::MarginInfo(RenderBlockFlow& block, LayoutUnit beforeBorderPadding, LayoutUnit afterBorderPadding)
66     : m_atBeforeSideOfBlock(true)
67     , m_atAfterSideOfBlock(false)
68     , m_hasMarginBeforeQuirk(false)
69     , m_hasMarginAfterQuirk(false)
70     , m_determinedMarginBeforeQuirk(false)
71     , m_discardMargin(false)
72 {
73     const RenderStyle& blockStyle = block.style();
74     ASSERT(block.isRenderView() || block.parent());
75     m_canCollapseWithChildren = !block.isRenderView() && !block.isRoot() && !block.isOutOfFlowPositioned()
76         && !block.isFloating() && !block.isTableCell() && !block.hasOverflowClip() && !block.isInlineBlockOrInlineTable()
77         && !block.isRenderFlowThread() && !block.isWritingModeRoot() && !block.parent()->isFlexibleBox()
78         && blockStyle.hasAutoColumnCount() && blockStyle.hasAutoColumnWidth() && !blockStyle.columnSpan();
79
80     m_canCollapseMarginBeforeWithChildren = m_canCollapseWithChildren && !beforeBorderPadding && blockStyle.marginBeforeCollapse() != MSEPARATE;
81
82     // If any height other than auto is specified in CSS, then we don't collapse our bottom
83     // margins with our children's margins. To do otherwise would be to risk odd visual
84     // effects when the children overflow out of the parent block and yet still collapse
85     // with it. We also don't collapse if we have any bottom border/padding.
86     m_canCollapseMarginAfterWithChildren = m_canCollapseWithChildren && !afterBorderPadding
87         && (blockStyle.logicalHeight().isAuto() && !blockStyle.logicalHeight().value()) && blockStyle.marginAfterCollapse() != MSEPARATE;
88     
89     m_quirkContainer = block.isTableCell() || block.isBody();
90
91     m_discardMargin = m_canCollapseMarginBeforeWithChildren && block.mustDiscardMarginBefore();
92
93     m_positiveMargin = (m_canCollapseMarginBeforeWithChildren && !block.mustDiscardMarginBefore()) ? block.maxPositiveMarginBefore() : LayoutUnit();
94     m_negativeMargin = (m_canCollapseMarginBeforeWithChildren && !block.mustDiscardMarginBefore()) ? block.maxNegativeMarginBefore() : LayoutUnit();
95 }
96
97 RenderBlockFlow::RenderBlockFlow(Element& element, PassRef<RenderStyle> style)
98     : RenderBlock(element, WTF::move(style), RenderBlockFlowFlag)
99 #if ENABLE(IOS_TEXT_AUTOSIZING)
100     , m_widthForTextAutosizing(-1)
101     , m_lineCountForTextAutosizing(NOT_SET)
102 #endif
103 {
104     setChildrenInline(true);
105 }
106
107 RenderBlockFlow::RenderBlockFlow(Document& document, PassRef<RenderStyle> style)
108     : RenderBlock(document, WTF::move(style), RenderBlockFlowFlag)
109 #if ENABLE(IOS_TEXT_AUTOSIZING)
110     , m_widthForTextAutosizing(-1)
111     , m_lineCountForTextAutosizing(NOT_SET)
112 #endif
113 {
114     setChildrenInline(true);
115 }
116
117 RenderBlockFlow::~RenderBlockFlow()
118 {
119 }
120
121 void RenderBlockFlow::createMultiColumnFlowThread()
122 {
123     RenderMultiColumnFlowThread* flowThread = new RenderMultiColumnFlowThread(document(), RenderStyle::createAnonymousStyleWithDisplay(&style(), BLOCK));
124     flowThread->initializeStyle();
125     setChildrenInline(false); // Do this to avoid wrapping inline children that are just going to move into the flow thread.
126     deleteLines();
127     RenderBlock::addChild(flowThread);
128     flowThread->populate(); // Called after the flow thread is inserted so that we are reachable by the flow thread.
129     setMultiColumnFlowThread(flowThread);
130 }
131
132 void RenderBlockFlow::destroyMultiColumnFlowThread()
133 {
134     multiColumnFlowThread()->evacuateAndDestroy();
135     ASSERT(!multiColumnFlowThread());
136 }
137
138 void RenderBlockFlow::insertedIntoTree()
139 {
140     RenderBlock::insertedIntoTree();
141     createRenderNamedFlowFragmentIfNeeded();
142 }
143
144 void RenderBlockFlow::willBeDestroyed()
145 {
146     // Mark as being destroyed to avoid trouble with merges in removeChild().
147     m_beingDestroyed = true;
148
149     if (renderNamedFlowFragment())
150         setRenderNamedFlowFragment(0);
151
152     // Make sure to destroy anonymous children first while they are still connected to the rest of the tree, so that they will
153     // properly dirty line boxes that they are removed from. Effects that do :before/:after only on hover could crash otherwise.
154     destroyLeftoverChildren();
155
156     if (!documentBeingDestroyed()) {
157         if (firstRootBox()) {
158             // We can't wait for RenderBox::destroy to clear the selection,
159             // because by then we will have nuked the line boxes.
160             if (isSelectionBorder())
161                 frame().selection().setNeedsSelectionUpdate();
162
163             // If we are an anonymous block, then our line boxes might have children
164             // that will outlast this block. In the non-anonymous block case those
165             // children will be destroyed by the time we return from this function.
166             if (isAnonymousBlock()) {
167                 for (auto box = firstRootBox(); box; box = box->nextRootBox()) {
168                     while (auto childBox = box->firstChild())
169                         childBox->removeFromParent();
170                 }
171             }
172         } else if (parent())
173             parent()->dirtyLinesFromChangedChild(*this);
174     }
175
176     m_lineBoxes.deleteLineBoxes();
177
178     removeFromUpdateScrollInfoAfterLayoutTransaction();
179
180     // NOTE: This jumps down to RenderBox, bypassing RenderBlock since it would do duplicate work.
181     RenderBox::willBeDestroyed();
182 }
183
184 void RenderBlockFlow::rebuildFloatingObjectSetFromIntrudingFloats()
185 {
186     if (m_floatingObjects)
187         m_floatingObjects->setHorizontalWritingMode(isHorizontalWritingMode());
188
189     HashSet<RenderBox*> oldIntrudingFloatSet;
190     if (!childrenInline() && m_floatingObjects) {
191         const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
192         auto end = floatingObjectSet.end();
193         for (auto it = floatingObjectSet.begin(); it != end; ++it) {
194             FloatingObject* floatingObject = it->get();
195             if (!floatingObject->isDescendant())
196                 oldIntrudingFloatSet.add(&floatingObject->renderer());
197         }
198     }
199
200     // Inline blocks are covered by the isReplaced() check in the avoidFloats method.
201     if (avoidsFloats() || isRoot() || isRenderView() || isFloatingOrOutOfFlowPositioned() || isTableCell()) {
202         if (m_floatingObjects)
203             m_floatingObjects->clear();
204         if (!oldIntrudingFloatSet.isEmpty())
205             markAllDescendantsWithFloatsForLayout();
206         return;
207     }
208
209     RendererToFloatInfoMap floatMap;
210
211     if (m_floatingObjects) {
212         if (childrenInline())
213             m_floatingObjects->moveAllToFloatInfoMap(floatMap);
214         else
215             m_floatingObjects->clear();
216     }
217
218     // We should not process floats if the parent node is not a RenderBlock. Otherwise, we will add 
219     // floats in an invalid context. This will cause a crash arising from a bad cast on the parent.
220     // See <rdar://problem/8049753>, where float property is applied on a text node in a SVG.
221     if (!is<RenderBlockFlow>(parent()))
222         return;
223
224     // Attempt to locate a previous sibling with overhanging floats. We skip any elements that are
225     // out of flow (like floating/positioned elements), and we also skip over any objects that may have shifted
226     // to avoid floats.
227     RenderBlockFlow& parentBlock = downcast<RenderBlockFlow>(*parent());
228     bool parentHasFloats = false;
229     RenderObject* prev = previousSibling();
230     while (prev && (prev->isFloatingOrOutOfFlowPositioned() || !is<RenderBox>(*prev) || !is<RenderBlockFlow>(*prev) || downcast<RenderBlockFlow>(*prev).avoidsFloats())) {
231         if (prev->isFloating())
232             parentHasFloats = true;
233         prev = prev->previousSibling();
234     }
235
236     // First add in floats from the parent. Self-collapsing blocks let their parent track any floats that intrude into
237     // them (as opposed to floats they contain themselves) so check for those here too.
238     LayoutUnit logicalTopOffset = logicalTop();
239     if (parentHasFloats || (parentBlock.lowestFloatLogicalBottom() > logicalTopOffset && prev && downcast<RenderBlockFlow>(*prev).isSelfCollapsingBlock()))
240         addIntrudingFloats(&parentBlock, parentBlock.logicalLeftOffsetForContent(), logicalTopOffset);
241     
242     LayoutUnit logicalLeftOffset = 0;
243     if (prev)
244         logicalTopOffset -= downcast<RenderBox>(*prev).logicalTop();
245     else {
246         prev = &parentBlock;
247         logicalLeftOffset += parentBlock.logicalLeftOffsetForContent();
248     }
249
250     // Add overhanging floats from the previous RenderBlock, but only if it has a float that intrudes into our space.    
251     RenderBlockFlow& block = downcast<RenderBlockFlow>(*prev);
252     if (block.m_floatingObjects && block.lowestFloatLogicalBottom() > logicalTopOffset)
253         addIntrudingFloats(&block, logicalLeftOffset, logicalTopOffset);
254
255     if (childrenInline()) {
256         LayoutUnit changeLogicalTop = LayoutUnit::max();
257         LayoutUnit changeLogicalBottom = LayoutUnit::min();
258         if (m_floatingObjects) {
259             const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
260             auto end = floatingObjectSet.end();
261             for (auto it = floatingObjectSet.begin(); it != end; ++it) {
262                 FloatingObject* floatingObject = it->get();
263                 std::unique_ptr<FloatingObject> oldFloatingObject = floatMap.take(&floatingObject->renderer());
264                 LayoutUnit logicalBottom = logicalBottomForFloat(floatingObject);
265                 if (oldFloatingObject) {
266                     LayoutUnit oldLogicalBottom = logicalBottomForFloat(oldFloatingObject.get());
267                     if (logicalWidthForFloat(floatingObject) != logicalWidthForFloat(oldFloatingObject.get()) || logicalLeftForFloat(floatingObject) != logicalLeftForFloat(oldFloatingObject.get())) {
268                         changeLogicalTop = 0;
269                         changeLogicalBottom = std::max(changeLogicalBottom, std::max(logicalBottom, oldLogicalBottom));
270                     } else {
271                         if (logicalBottom != oldLogicalBottom) {
272                             changeLogicalTop = std::min(changeLogicalTop, std::min(logicalBottom, oldLogicalBottom));
273                             changeLogicalBottom = std::max(changeLogicalBottom, std::max(logicalBottom, oldLogicalBottom));
274                         }
275                         LayoutUnit logicalTop = logicalTopForFloat(floatingObject);
276                         LayoutUnit oldLogicalTop = logicalTopForFloat(oldFloatingObject.get());
277                         if (logicalTop != oldLogicalTop) {
278                             changeLogicalTop = std::min(changeLogicalTop, std::min(logicalTop, oldLogicalTop));
279                             changeLogicalBottom = std::max(changeLogicalBottom, std::max(logicalTop, oldLogicalTop));
280                         }
281                     }
282
283                     if (oldFloatingObject->originatingLine() && !selfNeedsLayout()) {
284                         ASSERT(&oldFloatingObject->originatingLine()->renderer() == this);
285                         oldFloatingObject->originatingLine()->markDirty();
286                     }
287                 } else {
288                     changeLogicalTop = 0;
289                     changeLogicalBottom = std::max(changeLogicalBottom, logicalBottom);
290                 }
291             }
292         }
293
294         auto end = floatMap.end();
295         for (auto it = floatMap.begin(); it != end; ++it) {
296             FloatingObject* floatingObject = it->value.get();
297             if (!floatingObject->isDescendant()) {
298                 changeLogicalTop = 0;
299                 changeLogicalBottom = std::max(changeLogicalBottom, logicalBottomForFloat(floatingObject));
300             }
301         }
302
303         markLinesDirtyInBlockRange(changeLogicalTop, changeLogicalBottom);
304     } else if (!oldIntrudingFloatSet.isEmpty()) {
305         // If there are previously intruding floats that no longer intrude, then children with floats
306         // should also get layout because they might need their floating object lists cleared.
307         if (m_floatingObjects->set().size() < oldIntrudingFloatSet.size())
308             markAllDescendantsWithFloatsForLayout();
309         else {
310             const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
311             auto end = floatingObjectSet.end();
312             for (auto it = floatingObjectSet.begin(); it != end && !oldIntrudingFloatSet.isEmpty(); ++it)
313                 oldIntrudingFloatSet.remove(&(*it)->renderer());
314             if (!oldIntrudingFloatSet.isEmpty())
315                 markAllDescendantsWithFloatsForLayout();
316         }
317     }
318 }
319
320 void RenderBlockFlow::adjustIntrinsicLogicalWidthsForColumns(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
321 {
322     if (!style().hasAutoColumnCount() || !style().hasAutoColumnWidth()) {
323         // The min/max intrinsic widths calculated really tell how much space elements need when
324         // laid out inside the columns. In order to eventually end up with the desired column width,
325         // we need to convert them to values pertaining to the multicol container.
326         int columnCount = style().hasAutoColumnCount() ? 1 : style().columnCount();
327         LayoutUnit columnWidth;
328         LayoutUnit colGap = columnGap();
329         LayoutUnit gapExtra = (columnCount - 1) * colGap;
330         if (style().hasAutoColumnWidth())
331             minLogicalWidth = minLogicalWidth * columnCount + gapExtra;
332         else {
333             columnWidth = style().columnWidth();
334             minLogicalWidth = std::min(minLogicalWidth, columnWidth);
335         }
336         // FIXME: If column-count is auto here, we should resolve it to calculate the maximum
337         // intrinsic width, instead of pretending that it's 1. The only way to do that is by
338         // performing a layout pass, but this is not an appropriate time or place for layout. The
339         // good news is that if height is unconstrained and there are no explicit breaks, the
340         // resolved column-count really should be 1.
341         maxLogicalWidth = std::max(maxLogicalWidth, columnWidth) * columnCount + gapExtra;
342     }
343 }
344
345 void RenderBlockFlow::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
346 {
347     if (childrenInline())
348         computeInlinePreferredLogicalWidths(minLogicalWidth, maxLogicalWidth);
349     else
350         computeBlockPreferredLogicalWidths(minLogicalWidth, maxLogicalWidth);
351
352     maxLogicalWidth = std::max(minLogicalWidth, maxLogicalWidth);
353
354     adjustIntrinsicLogicalWidthsForColumns(minLogicalWidth, maxLogicalWidth);
355
356     if (!style().autoWrap() && childrenInline()) {
357         // A horizontal marquee with inline children has no minimum width.
358         if (layer() && layer()->marquee() && layer()->marquee()->isHorizontal())
359             minLogicalWidth = 0;
360     }
361
362     if (is<RenderTableCell>(*this)) {
363         Length tableCellWidth = downcast<RenderTableCell>(*this).styleOrColLogicalWidth();
364         if (tableCellWidth.isFixed() && tableCellWidth.value() > 0)
365             maxLogicalWidth = std::max(minLogicalWidth, adjustContentBoxLogicalWidthForBoxSizing(tableCellWidth.value()));
366     }
367
368     int scrollbarWidth = instrinsicScrollbarLogicalWidth();
369     maxLogicalWidth += scrollbarWidth;
370     minLogicalWidth += scrollbarWidth;
371 }
372
373 bool RenderBlockFlow::recomputeLogicalWidthAndColumnWidth()
374 {
375     bool changed = recomputeLogicalWidth();
376
377     LayoutUnit oldColumnWidth = computedColumnWidth();
378     computeColumnCountAndWidth();
379     
380     return changed || oldColumnWidth != computedColumnWidth();
381 }
382
383 LayoutUnit RenderBlockFlow::columnGap() const
384 {
385     if (style().hasNormalColumnGap())
386         return style().fontDescription().computedPixelSize(); // "1em" is recommended as the normal gap setting. Matches <p> margins.
387     return style().columnGap();
388 }
389
390 void RenderBlockFlow::computeColumnCountAndWidth()
391 {   
392     // Calculate our column width and column count.
393     // FIXME: Can overflow on fast/block/float/float-not-removed-from-next-sibling4.html, see https://bugs.webkit.org/show_bug.cgi?id=68744
394     unsigned desiredColumnCount = 1;
395     LayoutUnit desiredColumnWidth = contentLogicalWidth();
396     
397     // For now, we don't support multi-column layouts when printing, since we have to do a lot of work for proper pagination.
398     if (document().paginated() || (style().hasAutoColumnCount() && style().hasAutoColumnWidth()) || !style().hasInlineColumnAxis()) {
399         setComputedColumnCountAndWidth(desiredColumnCount, desiredColumnWidth);
400         return;
401     }
402         
403     LayoutUnit availWidth = desiredColumnWidth;
404     LayoutUnit colGap = columnGap();
405     LayoutUnit colWidth = std::max<LayoutUnit>(LayoutUnit::fromPixel(1), LayoutUnit(style().columnWidth()));
406     int colCount = std::max<int>(1, style().columnCount());
407
408     if (style().hasAutoColumnWidth() && !style().hasAutoColumnCount()) {
409         desiredColumnCount = colCount;
410         desiredColumnWidth = std::max<LayoutUnit>(0, (availWidth - ((desiredColumnCount - 1) * colGap)) / desiredColumnCount);
411     } else if (!style().hasAutoColumnWidth() && style().hasAutoColumnCount()) {
412         desiredColumnCount = std::max<LayoutUnit>(1, (availWidth + colGap) / (colWidth + colGap));
413         desiredColumnWidth = ((availWidth + colGap) / desiredColumnCount) - colGap;
414     } else {
415         desiredColumnCount = std::max<LayoutUnit>(std::min<LayoutUnit>(colCount, (availWidth + colGap) / (colWidth + colGap)), 1);
416         desiredColumnWidth = ((availWidth + colGap) / desiredColumnCount) - colGap;
417     }
418     setComputedColumnCountAndWidth(desiredColumnCount, desiredColumnWidth);
419 }
420
421 void RenderBlockFlow::layoutBlock(bool relayoutChildren, LayoutUnit pageLogicalHeight)
422 {
423     ASSERT(needsLayout());
424
425     if (!relayoutChildren && simplifiedLayout())
426         return;
427
428     LayoutRepainter repainter(*this, checkForRepaintDuringLayout());
429
430     if (recomputeLogicalWidthAndColumnWidth())
431         relayoutChildren = true;
432
433     rebuildFloatingObjectSetFromIntrudingFloats();
434
435     LayoutUnit previousHeight = logicalHeight();
436     // FIXME: should this start out as borderAndPaddingLogicalHeight() + scrollbarLogicalHeight(),
437     // for consistency with other render classes?
438     setLogicalHeight(0);
439
440     bool pageLogicalHeightChanged = false;
441     checkForPaginationLogicalHeightChange(relayoutChildren, pageLogicalHeight, pageLogicalHeightChanged);
442
443     const RenderStyle& styleToUse = style();
444     LayoutStateMaintainer statePusher(view(), *this, locationOffset(), hasTransform() || hasReflection() || styleToUse.isFlippedBlocksWritingMode(), pageLogicalHeight, pageLogicalHeightChanged);
445
446     preparePaginationBeforeBlockLayout(relayoutChildren);
447     if (!relayoutChildren)
448         relayoutChildren = namedFlowFragmentNeedsUpdate();
449
450     // We use four values, maxTopPos, maxTopNeg, maxBottomPos, and maxBottomNeg, to track
451     // our current maximal positive and negative margins. These values are used when we
452     // are collapsed with adjacent blocks, so for example, if you have block A and B
453     // collapsing together, then you'd take the maximal positive margin from both A and B
454     // and subtract it from the maximal negative margin from both A and B to get the
455     // true collapsed margin. This algorithm is recursive, so when we finish layout()
456     // our block knows its current maximal positive/negative values.
457     //
458     // Start out by setting our margin values to our current margins. Table cells have
459     // no margins, so we don't fill in the values for table cells.
460     bool isCell = isTableCell();
461     if (!isCell) {
462         initMaxMarginValues();
463         
464         setHasMarginBeforeQuirk(styleToUse.hasMarginBeforeQuirk());
465         setHasMarginAfterQuirk(styleToUse.hasMarginAfterQuirk());
466         setPaginationStrut(0);
467     }
468
469     LayoutUnit repaintLogicalTop = 0;
470     LayoutUnit repaintLogicalBottom = 0;
471     LayoutUnit maxFloatLogicalBottom = 0;
472     if (!firstChild() && !isAnonymousBlock())
473         setChildrenInline(true);
474     if (childrenInline())
475         layoutInlineChildren(relayoutChildren, repaintLogicalTop, repaintLogicalBottom);
476     else
477         layoutBlockChildren(relayoutChildren, maxFloatLogicalBottom);
478
479     // Expand our intrinsic height to encompass floats.
480     LayoutUnit toAdd = borderAndPaddingAfter() + scrollbarLogicalHeight();
481     if (lowestFloatLogicalBottom() > (logicalHeight() - toAdd) && expandsToEncloseOverhangingFloats())
482         setLogicalHeight(lowestFloatLogicalBottom() + toAdd);
483     
484     if (relayoutForPagination(statePusher) || relayoutToAvoidWidows(statePusher)) {
485         ASSERT(!shouldBreakAtLineToAvoidWidow());
486         return;
487     }
488
489     // Calculate our new height.
490     LayoutUnit oldHeight = logicalHeight();
491     LayoutUnit oldClientAfterEdge = clientLogicalBottom();
492
493     // Before updating the final size of the flow thread make sure a forced break is applied after the content.
494     // This ensures the size information is correctly computed for the last auto-height region receiving content.
495     if (is<RenderFlowThread>(*this))
496         downcast<RenderFlowThread>(*this).applyBreakAfterContent(oldClientAfterEdge);
497
498     updateLogicalHeight();
499     LayoutUnit newHeight = logicalHeight();
500     if (oldHeight != newHeight) {
501         if (oldHeight > newHeight && maxFloatLogicalBottom > newHeight && !childrenInline()) {
502             // One of our children's floats may have become an overhanging float for us. We need to look for it.
503             for (auto& blockFlow : childrenOfType<RenderBlockFlow>(*this)) {
504                 if (blockFlow.isFloatingOrOutOfFlowPositioned())
505                     continue;
506                 if (blockFlow.lowestFloatLogicalBottom() + blockFlow.logicalTop() > newHeight)
507                     addOverhangingFloats(blockFlow, false);
508             }
509         }
510     }
511
512     bool heightChanged = (previousHeight != newHeight);
513     if (heightChanged)
514         relayoutChildren = true;
515
516     layoutPositionedObjects(relayoutChildren || isRoot());
517
518     // Add overflow from children (unless we're multi-column, since in that case all our child overflow is clipped anyway).
519     computeOverflow(oldClientAfterEdge);
520     
521     statePusher.pop();
522
523     fitBorderToLinesIfNeeded();
524
525     if (view().layoutState()->m_pageLogicalHeight)
526         setPageLogicalOffset(view().layoutState()->pageLogicalOffset(this, logicalTop()));
527
528     updateLayerTransform();
529
530     // Update our scroll information if we're overflow:auto/scroll/hidden now that we know if
531     // we overflow or not.
532     updateScrollInfoAfterLayout();
533
534     // FIXME: This repaint logic should be moved into a separate helper function!
535     // Repaint with our new bounds if they are different from our old bounds.
536     bool didFullRepaint = repainter.repaintAfterLayout();
537     if (!didFullRepaint && repaintLogicalTop != repaintLogicalBottom && (styleToUse.visibility() == VISIBLE || enclosingLayer()->hasVisibleContent())) {
538         // FIXME: We could tighten up the left and right invalidation points if we let layoutInlineChildren fill them in based off the particular lines
539         // it had to lay out. We wouldn't need the hasOverflowClip() hack in that case either.
540         LayoutUnit repaintLogicalLeft = logicalLeftVisualOverflow();
541         LayoutUnit repaintLogicalRight = logicalRightVisualOverflow();
542         if (hasOverflowClip()) {
543             // If we have clipped overflow, we should use layout overflow as well, since visual overflow from lines didn't propagate to our block's overflow.
544             // Note the old code did this as well but even for overflow:visible. The addition of hasOverflowClip() at least tightens up the hack a bit.
545             // layoutInlineChildren should be patched to compute the entire repaint rect.
546             repaintLogicalLeft = std::min(repaintLogicalLeft, logicalLeftLayoutOverflow());
547             repaintLogicalRight = std::max(repaintLogicalRight, logicalRightLayoutOverflow());
548         }
549         
550         LayoutRect repaintRect;
551         if (isHorizontalWritingMode())
552             repaintRect = LayoutRect(repaintLogicalLeft, repaintLogicalTop, repaintLogicalRight - repaintLogicalLeft, repaintLogicalBottom - repaintLogicalTop);
553         else
554             repaintRect = LayoutRect(repaintLogicalTop, repaintLogicalLeft, repaintLogicalBottom - repaintLogicalTop, repaintLogicalRight - repaintLogicalLeft);
555
556         repaintRect.inflate(maximalOutlineSize(PaintPhaseOutline));
557         
558         if (hasOverflowClip()) {
559             // Adjust repaint rect for scroll offset
560             repaintRect.move(-scrolledContentOffset());
561
562             // Don't allow this rect to spill out of our overflow box.
563             repaintRect.intersect(LayoutRect(LayoutPoint(), size()));
564         }
565
566         // Make sure the rect is still non-empty after intersecting for overflow above
567         if (!repaintRect.isEmpty()) {
568             repaintRectangle(repaintRect); // We need to do a partial repaint of our content.
569             if (hasReflection())
570                 repaintRectangle(reflectedRect(repaintRect));
571         }
572     }
573
574     clearNeedsLayout();
575 }
576
577 void RenderBlockFlow::layoutBlockChildren(bool relayoutChildren, LayoutUnit& maxFloatLogicalBottom)
578 {
579     dirtyForLayoutFromPercentageHeightDescendants();
580
581     LayoutUnit beforeEdge = borderAndPaddingBefore();
582     LayoutUnit afterEdge = borderAndPaddingAfter() + scrollbarLogicalHeight();
583
584     setLogicalHeight(beforeEdge);
585     
586     // Lay out our hypothetical grid line as though it occurs at the top of the block.
587     if (view().layoutState()->lineGrid() == this)
588         layoutLineGridBox();
589
590     // The margin struct caches all our current margin collapsing state.
591     MarginInfo marginInfo(*this, beforeEdge, afterEdge);
592
593     // Fieldsets need to find their legend and position it inside the border of the object.
594     // The legend then gets skipped during normal layout. The same is true for ruby text.
595     // It doesn't get included in the normal layout process but is instead skipped.
596     RenderObject* childToExclude = layoutSpecialExcludedChild(relayoutChildren);
597
598     LayoutUnit previousFloatLogicalBottom = 0;
599     maxFloatLogicalBottom = 0;
600
601     RenderBox* next = firstChildBox();
602
603     while (next) {
604         RenderBox& child = *next;
605         next = child.nextSiblingBox();
606
607         if (childToExclude == &child)
608             continue; // Skip this child, since it will be positioned by the specialized subclass (fieldsets and ruby runs).
609
610         updateBlockChildDirtyBitsBeforeLayout(relayoutChildren, child);
611
612         if (child.isOutOfFlowPositioned()) {
613             child.containingBlock()->insertPositionedObject(child);
614             adjustPositionedBlock(child, marginInfo);
615             continue;
616         }
617         if (child.isFloating()) {
618             insertFloatingObject(child);
619             adjustFloatingBlock(marginInfo);
620             continue;
621         }
622
623         // Lay out the child.
624         layoutBlockChild(child, marginInfo, previousFloatLogicalBottom, maxFloatLogicalBottom);
625     }
626     
627     // Now do the handling of the bottom of the block, adding in our bottom border/padding and
628     // determining the correct collapsed bottom margin information.
629     handleAfterSideOfBlock(beforeEdge, afterEdge, marginInfo);
630 }
631
632 void RenderBlockFlow::layoutInlineChildren(bool relayoutChildren, LayoutUnit& repaintLogicalTop, LayoutUnit& repaintLogicalBottom)
633 {
634     if (m_lineLayoutPath == UndeterminedPath)
635         m_lineLayoutPath = SimpleLineLayout::canUseFor(*this) ? SimpleLinesPath : LineBoxesPath;
636
637     if (m_lineLayoutPath == SimpleLinesPath) {
638         deleteLineBoxesBeforeSimpleLineLayout();
639         layoutSimpleLines(repaintLogicalTop, repaintLogicalBottom);
640         return;
641     }
642
643     m_simpleLineLayout = nullptr;
644     layoutLineBoxes(relayoutChildren, repaintLogicalTop, repaintLogicalBottom);
645 }
646
647 void RenderBlockFlow::layoutBlockChild(RenderBox& child, MarginInfo& marginInfo, LayoutUnit& previousFloatLogicalBottom, LayoutUnit& maxFloatLogicalBottom)
648 {
649     LayoutUnit oldPosMarginBefore = maxPositiveMarginBefore();
650     LayoutUnit oldNegMarginBefore = maxNegativeMarginBefore();
651
652     // The child is a normal flow object. Compute the margins we will use for collapsing now.
653     child.computeAndSetBlockDirectionMargins(this);
654
655     // Try to guess our correct logical top position. In most cases this guess will
656     // be correct. Only if we're wrong (when we compute the real logical top position)
657     // will we have to potentially relayout.
658     LayoutUnit estimateWithoutPagination;
659     LayoutUnit logicalTopEstimate = estimateLogicalTopPosition(child, marginInfo, estimateWithoutPagination);
660
661     // Cache our old rect so that we can dirty the proper repaint rects if the child moves.
662     LayoutRect oldRect = child.frameRect();
663     LayoutUnit oldLogicalTop = logicalTopForChild(child);
664
665 #if !ASSERT_DISABLED
666     LayoutSize oldLayoutDelta = view().layoutDelta();
667 #endif
668     // Go ahead and position the child as though it didn't collapse with the top.
669     setLogicalTopForChild(child, logicalTopEstimate, ApplyLayoutDelta);
670     estimateRegionRangeForBoxChild(child);
671
672     RenderBlockFlow* childBlockFlow = is<RenderBlockFlow>(child) ? &downcast<RenderBlockFlow>(child) : nullptr;
673     bool markDescendantsWithFloats = false;
674     if (logicalTopEstimate != oldLogicalTop && !child.avoidsFloats() && childBlockFlow && childBlockFlow->containsFloats())
675         markDescendantsWithFloats = true;
676     else if (UNLIKELY(logicalTopEstimate.mightBeSaturated()))
677         // logicalTopEstimate, returned by estimateLogicalTopPosition, might be saturated for
678         // very large elements. If it does the comparison with oldLogicalTop might yield a
679         // false negative as adding and removing margins, borders etc from a saturated number
680         // might yield incorrect results. If this is the case always mark for layout.
681         markDescendantsWithFloats = true;
682     else if (!child.avoidsFloats() || child.shrinkToAvoidFloats()) {
683         // If an element might be affected by the presence of floats, then always mark it for
684         // layout.
685         LayoutUnit fb = std::max(previousFloatLogicalBottom, lowestFloatLogicalBottom());
686         if (fb > logicalTopEstimate)
687             markDescendantsWithFloats = true;
688     }
689
690     if (childBlockFlow) {
691         if (markDescendantsWithFloats)
692             childBlockFlow->markAllDescendantsWithFloatsForLayout();
693         if (!child.isWritingModeRoot())
694             previousFloatLogicalBottom = std::max(previousFloatLogicalBottom, oldLogicalTop + childBlockFlow->lowestFloatLogicalBottom());
695     }
696
697     if (!child.needsLayout())
698         child.markForPaginationRelayoutIfNeeded();
699
700     bool childHadLayout = child.everHadLayout();
701     bool childNeededLayout = child.needsLayout();
702     if (childNeededLayout)
703         child.layout();
704
705     // Cache if we are at the top of the block right now.
706     bool atBeforeSideOfBlock = marginInfo.atBeforeSideOfBlock();
707
708     // Now determine the correct ypos based off examination of collapsing margin
709     // values.
710     LayoutUnit logicalTopBeforeClear = collapseMargins(child, marginInfo);
711
712     // Now check for clear.
713     LayoutUnit logicalTopAfterClear = clearFloatsIfNeeded(child, marginInfo, oldPosMarginBefore, oldNegMarginBefore, logicalTopBeforeClear);
714     
715     bool paginated = view().layoutState()->isPaginated();
716     if (paginated)
717         logicalTopAfterClear = adjustBlockChildForPagination(logicalTopAfterClear, estimateWithoutPagination, child, atBeforeSideOfBlock && logicalTopBeforeClear == logicalTopAfterClear);
718
719     setLogicalTopForChild(child, logicalTopAfterClear, ApplyLayoutDelta);
720
721     // Now we have a final top position. See if it really does end up being different from our estimate.
722     // clearFloatsIfNeeded can also mark the child as needing a layout even though we didn't move. This happens
723     // when collapseMargins dynamically adds overhanging floats because of a child with negative margins.
724     if (logicalTopAfterClear != logicalTopEstimate || child.needsLayout() || (paginated && childBlockFlow && childBlockFlow->shouldBreakAtLineToAvoidWidow())) {
725         if (child.shrinkToAvoidFloats()) {
726             // The child's width depends on the line width.
727             // When the child shifts to clear an item, its width can
728             // change (because it has more available line width).
729             // So go ahead and mark the item as dirty.
730             child.setChildNeedsLayout(MarkOnlyThis);
731         }
732         
733         if (childBlockFlow) {
734             if (!child.avoidsFloats() && childBlockFlow->containsFloats())
735                 childBlockFlow->markAllDescendantsWithFloatsForLayout();
736             if (!child.needsLayout())
737                 child.markForPaginationRelayoutIfNeeded();
738         }
739     }
740
741     if (updateRegionRangeForBoxChild(child))
742         child.setNeedsLayout(MarkOnlyThis);
743
744     // In case our guess was wrong, relayout the child.
745     child.layoutIfNeeded();
746
747     // We are no longer at the top of the block if we encounter a non-empty child.  
748     // This has to be done after checking for clear, so that margins can be reset if a clear occurred.
749     if (marginInfo.atBeforeSideOfBlock() && !child.isSelfCollapsingBlock())
750         marginInfo.setAtBeforeSideOfBlock(false);
751
752     // Now place the child in the correct left position
753     determineLogicalLeftPositionForChild(child, ApplyLayoutDelta);
754
755     // Update our height now that the child has been placed in the correct position.
756     setLogicalHeight(logicalHeight() + logicalHeightForChildForFragmentation(child));
757     if (mustSeparateMarginAfterForChild(child)) {
758         setLogicalHeight(logicalHeight() + marginAfterForChild(child));
759         marginInfo.clearMargin();
760     }
761     // If the child has overhanging floats that intrude into following siblings (or possibly out
762     // of this block), then the parent gets notified of the floats now.
763     if (childBlockFlow && childBlockFlow->containsFloats())
764         maxFloatLogicalBottom = std::max(maxFloatLogicalBottom, addOverhangingFloats(*childBlockFlow, !childNeededLayout));
765
766     LayoutSize childOffset = child.location() - oldRect.location();
767     if (childOffset.width() || childOffset.height()) {
768         view().addLayoutDelta(childOffset);
769
770         // If the child moved, we have to repaint it as well as any floating/positioned
771         // descendants. An exception is if we need a layout. In this case, we know we're going to
772         // repaint ourselves (and the child) anyway.
773         if (childHadLayout && !selfNeedsLayout() && child.checkForRepaintDuringLayout())
774             child.repaintDuringLayoutIfMoved(oldRect);
775     }
776
777     if (!childHadLayout && child.checkForRepaintDuringLayout()) {
778         child.repaint();
779         child.repaintOverhangingFloats(true);
780     }
781
782     if (paginated) {
783         if (RenderFlowThread* flowThread = flowThreadContainingBlock())
784             flowThread->flowThreadDescendantBoxLaidOut(&child);
785         // Check for an after page/column break.
786         LayoutUnit newHeight = applyAfterBreak(child, logicalHeight(), marginInfo);
787         if (newHeight != height())
788             setLogicalHeight(newHeight);
789     }
790
791     ASSERT(view().layoutDeltaMatches(oldLayoutDelta));
792 }
793
794 void RenderBlockFlow::adjustPositionedBlock(RenderBox& child, const MarginInfo& marginInfo)
795 {
796     bool isHorizontal = isHorizontalWritingMode();
797     bool hasStaticBlockPosition = child.style().hasStaticBlockPosition(isHorizontal);
798     
799     LayoutUnit logicalTop = logicalHeight();
800     updateStaticInlinePositionForChild(child, logicalTop);
801
802     if (!marginInfo.canCollapseWithMarginBefore()) {
803         // Positioned blocks don't collapse margins, so add the margin provided by
804         // the container now. The child's own margin is added later when calculating its logical top.
805         LayoutUnit collapsedBeforePos = marginInfo.positiveMargin();
806         LayoutUnit collapsedBeforeNeg = marginInfo.negativeMargin();
807         logicalTop += collapsedBeforePos - collapsedBeforeNeg;
808     }
809     
810     RenderLayer* childLayer = child.layer();
811     if (childLayer->staticBlockPosition() != logicalTop) {
812         childLayer->setStaticBlockPosition(logicalTop);
813         if (hasStaticBlockPosition)
814             child.setChildNeedsLayout(MarkOnlyThis);
815     }
816 }
817
818 LayoutUnit RenderBlockFlow::marginOffsetForSelfCollapsingBlock()
819 {
820     ASSERT(isSelfCollapsingBlock());
821     RenderBlockFlow* parentBlock = downcast<RenderBlockFlow>(parent());
822     if (parentBlock && style().clear() && parentBlock->getClearDelta(*this, logicalHeight()))
823         return marginValuesForChild(*this).positiveMarginBefore();
824     return LayoutUnit();
825 }
826
827 void RenderBlockFlow::determineLogicalLeftPositionForChild(RenderBox& child, ApplyLayoutDeltaMode applyDelta)
828 {
829     LayoutUnit startPosition = borderStart() + paddingStart();
830     if (style().shouldPlaceBlockDirectionScrollbarOnLogicalLeft())
831         startPosition -= verticalScrollbarWidth();
832     LayoutUnit totalAvailableLogicalWidth = borderAndPaddingLogicalWidth() + availableLogicalWidth();
833
834     // Add in our start margin.
835     LayoutUnit childMarginStart = marginStartForChild(child);
836     LayoutUnit newPosition = startPosition + childMarginStart;
837         
838     // Some objects (e.g., tables, horizontal rules, overflow:auto blocks) avoid floats. They need
839     // to shift over as necessary to dodge any floats that might get in the way.
840     if (child.avoidsFloats() && containsFloats() && !flowThreadContainingBlock())
841         newPosition += computeStartPositionDeltaForChildAvoidingFloats(child, marginStartForChild(child));
842
843     setLogicalLeftForChild(child, style().isLeftToRightDirection() ? newPosition : totalAvailableLogicalWidth - newPosition - logicalWidthForChild(child), applyDelta);
844 }
845
846 void RenderBlockFlow::adjustFloatingBlock(const MarginInfo& marginInfo)
847 {
848     // The float should be positioned taking into account the bottom margin
849     // of the previous flow. We add that margin into the height, get the
850     // float positioned properly, and then subtract the margin out of the
851     // height again. In the case of self-collapsing blocks, we always just
852     // use the top margins, since the self-collapsing block collapsed its
853     // own bottom margin into its top margin.
854     //
855     // Note also that the previous flow may collapse its margin into the top of
856     // our block. If this is the case, then we do not add the margin in to our
857     // height when computing the position of the float. This condition can be tested
858     // for by simply calling canCollapseWithMarginBefore. See
859     // http://www.hixie.ch/tests/adhoc/css/box/block/margin-collapse/046.html for
860     // an example of this scenario.
861     LayoutUnit marginOffset = marginInfo.canCollapseWithMarginBefore() ? LayoutUnit() : marginInfo.margin();
862     setLogicalHeight(logicalHeight() + marginOffset);
863     positionNewFloats();
864     setLogicalHeight(logicalHeight() - marginOffset);
865 }
866
867 void RenderBlockFlow::updateStaticInlinePositionForChild(RenderBox& child, LayoutUnit logicalTop)
868 {
869     if (child.style().isOriginalDisplayInlineType())
870         setStaticInlinePositionForChild(child, logicalTop, startAlignedOffsetForLine(logicalTop, false));
871     else
872         setStaticInlinePositionForChild(child, logicalTop, startOffsetForContent(logicalTop));
873 }
874
875 void RenderBlockFlow::setStaticInlinePositionForChild(RenderBox& child, LayoutUnit blockOffset, LayoutUnit inlinePosition)
876 {
877     if (flowThreadContainingBlock()) {
878         // Shift the inline position to exclude the region offset.
879         inlinePosition += startOffsetForContent() - startOffsetForContent(blockOffset);
880     }
881     child.layer()->setStaticInlinePosition(inlinePosition);
882 }
883
884 RenderBlockFlow::MarginValues RenderBlockFlow::marginValuesForChild(RenderBox& child) const
885 {
886     LayoutUnit childBeforePositive = 0;
887     LayoutUnit childBeforeNegative = 0;
888     LayoutUnit childAfterPositive = 0;
889     LayoutUnit childAfterNegative = 0;
890
891     LayoutUnit beforeMargin = 0;
892     LayoutUnit afterMargin = 0;
893
894     RenderBlockFlow* childRenderBlock = is<RenderBlockFlow>(child) ? &downcast<RenderBlockFlow>(child) : nullptr;
895     
896     // If the child has the same directionality as we do, then we can just return its
897     // margins in the same direction.
898     if (!child.isWritingModeRoot()) {
899         if (childRenderBlock) {
900             childBeforePositive = childRenderBlock->maxPositiveMarginBefore();
901             childBeforeNegative = childRenderBlock->maxNegativeMarginBefore();
902             childAfterPositive = childRenderBlock->maxPositiveMarginAfter();
903             childAfterNegative = childRenderBlock->maxNegativeMarginAfter();
904         } else {
905             beforeMargin = child.marginBefore();
906             afterMargin = child.marginAfter();
907         }
908     } else if (child.isHorizontalWritingMode() == isHorizontalWritingMode()) {
909         // The child has a different directionality. If the child is parallel, then it's just
910         // flipped relative to us. We can use the margins for the opposite edges.
911         if (childRenderBlock) {
912             childBeforePositive = childRenderBlock->maxPositiveMarginAfter();
913             childBeforeNegative = childRenderBlock->maxNegativeMarginAfter();
914             childAfterPositive = childRenderBlock->maxPositiveMarginBefore();
915             childAfterNegative = childRenderBlock->maxNegativeMarginBefore();
916         } else {
917             beforeMargin = child.marginAfter();
918             afterMargin = child.marginBefore();
919         }
920     } else {
921         // The child is perpendicular to us, which means its margins don't collapse but are on the
922         // "logical left/right" sides of the child box. We can just return the raw margin in this case.
923         beforeMargin = marginBeforeForChild(child);
924         afterMargin = marginAfterForChild(child);
925     }
926
927     // Resolve uncollapsing margins into their positive/negative buckets.
928     if (beforeMargin) {
929         if (beforeMargin > 0)
930             childBeforePositive = beforeMargin;
931         else
932             childBeforeNegative = -beforeMargin;
933     }
934     if (afterMargin) {
935         if (afterMargin > 0)
936             childAfterPositive = afterMargin;
937         else
938             childAfterNegative = -afterMargin;
939     }
940
941     return MarginValues(childBeforePositive, childBeforeNegative, childAfterPositive, childAfterNegative);
942 }
943
944 LayoutUnit RenderBlockFlow::collapseMargins(RenderBox& child, MarginInfo& marginInfo)
945 {
946     bool childDiscardMarginBefore = mustDiscardMarginBeforeForChild(child);
947     bool childDiscardMarginAfter = mustDiscardMarginAfterForChild(child);
948     bool childIsSelfCollapsing = child.isSelfCollapsingBlock();
949
950     // The child discards the before margin when the the after margin has discard in the case of a self collapsing block.
951     childDiscardMarginBefore = childDiscardMarginBefore || (childDiscardMarginAfter && childIsSelfCollapsing);
952
953     // Get the four margin values for the child and cache them.
954     const MarginValues childMargins = marginValuesForChild(child);
955
956     // Get our max pos and neg top margins.
957     LayoutUnit posTop = childMargins.positiveMarginBefore();
958     LayoutUnit negTop = childMargins.negativeMarginBefore();
959
960     // For self-collapsing blocks, collapse our bottom margins into our
961     // top to get new posTop and negTop values.
962     if (childIsSelfCollapsing) {
963         posTop = std::max(posTop, childMargins.positiveMarginAfter());
964         negTop = std::max(negTop, childMargins.negativeMarginAfter());
965     }
966     
967     // See if the top margin is quirky. We only care if this child has
968     // margins that will collapse with us.
969     bool topQuirk = hasMarginBeforeQuirk(child);
970
971     if (marginInfo.canCollapseWithMarginBefore()) {
972         if (!childDiscardMarginBefore && !marginInfo.discardMargin()) {
973             // This child is collapsing with the top of the
974             // block. If it has larger margin values, then we need to update
975             // our own maximal values.
976             if (!document().inQuirksMode() || !marginInfo.quirkContainer() || !topQuirk)
977                 setMaxMarginBeforeValues(std::max(posTop, maxPositiveMarginBefore()), std::max(negTop, maxNegativeMarginBefore()));
978
979             // The minute any of the margins involved isn't a quirk, don't
980             // collapse it away, even if the margin is smaller (www.webreference.com
981             // has an example of this, a <dt> with 0.8em author-specified inside
982             // a <dl> inside a <td>.
983             if (!marginInfo.determinedMarginBeforeQuirk() && !topQuirk && (posTop - negTop)) {
984                 setHasMarginBeforeQuirk(false);
985                 marginInfo.setDeterminedMarginBeforeQuirk(true);
986             }
987
988             if (!marginInfo.determinedMarginBeforeQuirk() && topQuirk && !marginBefore())
989                 // We have no top margin and our top child has a quirky margin.
990                 // We will pick up this quirky margin and pass it through.
991                 // This deals with the <td><div><p> case.
992                 // Don't do this for a block that split two inlines though. You do
993                 // still apply margins in this case.
994                 setHasMarginBeforeQuirk(true);
995         } else
996             // The before margin of the container will also discard all the margins it is collapsing with.
997             setMustDiscardMarginBefore();
998     }
999
1000     // Once we find a child with discardMarginBefore all the margins collapsing with us must also discard. 
1001     if (childDiscardMarginBefore) {
1002         marginInfo.setDiscardMargin(true);
1003         marginInfo.clearMargin();
1004     }
1005
1006     if (marginInfo.quirkContainer() && marginInfo.atBeforeSideOfBlock() && (posTop - negTop))
1007         marginInfo.setHasMarginBeforeQuirk(topQuirk);
1008
1009     LayoutUnit beforeCollapseLogicalTop = logicalHeight();
1010     LayoutUnit logicalTop = beforeCollapseLogicalTop;
1011
1012     LayoutUnit clearanceForSelfCollapsingBlock;
1013     RenderObject* prev = child.previousSibling();
1014     // If the child's previous sibling is a self-collapsing block that cleared a float then its top border edge has been set at the bottom border edge
1015     // of the float. Since we want to collapse the child's top margin with the self-collapsing block's top and bottom margins we need to adjust our parent's height to match the 
1016     // margin top of the self-collapsing block. If the resulting collapsed margin leaves the child still intruding into the float then we will want to clear it.
1017     if (!marginInfo.canCollapseWithMarginBefore() && is<RenderBlockFlow>(prev) && downcast<RenderBlockFlow>(*prev).isSelfCollapsingBlock()) {
1018         clearanceForSelfCollapsingBlock = downcast<RenderBlockFlow>(*prev).marginOffsetForSelfCollapsingBlock();
1019         setLogicalHeight(logicalHeight() - clearanceForSelfCollapsingBlock);
1020     }
1021
1022     if (childIsSelfCollapsing) {
1023         // For a self collapsing block both the before and after margins get discarded. The block doesn't contribute anything to the height of the block.
1024         // Also, the child's top position equals the logical height of the container.
1025         if (!childDiscardMarginBefore && !marginInfo.discardMargin()) {
1026             // This child has no height. We need to compute our
1027             // position before we collapse the child's margins together,
1028             // so that we can get an accurate position for the zero-height block.
1029             LayoutUnit collapsedBeforePos = std::max(marginInfo.positiveMargin(), childMargins.positiveMarginBefore());
1030             LayoutUnit collapsedBeforeNeg = std::max(marginInfo.negativeMargin(), childMargins.negativeMarginBefore());
1031             marginInfo.setMargin(collapsedBeforePos, collapsedBeforeNeg);
1032             
1033             // Now collapse the child's margins together, which means examining our
1034             // bottom margin values as well. 
1035             marginInfo.setPositiveMarginIfLarger(childMargins.positiveMarginAfter());
1036             marginInfo.setNegativeMarginIfLarger(childMargins.negativeMarginAfter());
1037
1038             if (!marginInfo.canCollapseWithMarginBefore())
1039                 // We need to make sure that the position of the self-collapsing block
1040                 // is correct, since it could have overflowing content
1041                 // that needs to be positioned correctly (e.g., a block that
1042                 // had a specified height of 0 but that actually had subcontent).
1043                 logicalTop = logicalHeight() + collapsedBeforePos - collapsedBeforeNeg;
1044         }
1045     } else {
1046         if (mustSeparateMarginBeforeForChild(child)) {
1047             ASSERT(!marginInfo.discardMargin() || (marginInfo.discardMargin() && !marginInfo.margin()));
1048             // If we are at the before side of the block and we collapse, ignore the computed margin
1049             // and just add the child margin to the container height. This will correctly position
1050             // the child inside the container.
1051             LayoutUnit separateMargin = !marginInfo.canCollapseWithMarginBefore() ? marginInfo.margin() : LayoutUnit::fromPixel(0);
1052             setLogicalHeight(logicalHeight() + separateMargin + marginBeforeForChild(child));
1053             logicalTop = logicalHeight();
1054         } else if (!marginInfo.discardMargin() && (!marginInfo.atBeforeSideOfBlock()
1055             || (!marginInfo.canCollapseMarginBeforeWithChildren()
1056             && (!document().inQuirksMode() || !marginInfo.quirkContainer() || !marginInfo.hasMarginBeforeQuirk())))) {
1057             // We're collapsing with a previous sibling's margins and not
1058             // with the top of the block.
1059             setLogicalHeight(logicalHeight() + std::max(marginInfo.positiveMargin(), posTop) - std::max(marginInfo.negativeMargin(), negTop));
1060             logicalTop = logicalHeight();
1061         }
1062
1063         marginInfo.setDiscardMargin(childDiscardMarginAfter);
1064         
1065         if (!marginInfo.discardMargin()) {
1066             marginInfo.setPositiveMargin(childMargins.positiveMarginAfter());
1067             marginInfo.setNegativeMargin(childMargins.negativeMarginAfter());
1068         } else
1069             marginInfo.clearMargin();
1070
1071         if (marginInfo.margin())
1072             marginInfo.setHasMarginAfterQuirk(hasMarginAfterQuirk(child));
1073     }
1074     
1075     // If margins would pull us past the top of the next page, then we need to pull back and pretend like the margins
1076     // collapsed into the page edge.
1077     LayoutState* layoutState = view().layoutState();
1078     if (layoutState->isPaginated() && layoutState->pageLogicalHeight() && logicalTop > beforeCollapseLogicalTop
1079         && hasNextPage(beforeCollapseLogicalTop)) {
1080         LayoutUnit oldLogicalTop = logicalTop;
1081         logicalTop = std::min(logicalTop, nextPageLogicalTop(beforeCollapseLogicalTop));
1082         setLogicalHeight(logicalHeight() + (logicalTop - oldLogicalTop));
1083     }
1084
1085     if (is<RenderBlockFlow>(prev) && !prev->isFloatingOrOutOfFlowPositioned()) {
1086         // If |child| is a self-collapsing block it may have collapsed into a previous sibling and although it hasn't reduced the height of the parent yet
1087         // any floats from the parent will now overhang.
1088         RenderBlockFlow& block = downcast<RenderBlockFlow>(*prev);
1089         LayoutUnit oldLogicalHeight = logicalHeight();
1090         setLogicalHeight(logicalTop);
1091         if (block.containsFloats() && !block.avoidsFloats() && (block.logicalTop() + block.lowestFloatLogicalBottom()) > logicalTop)
1092             addOverhangingFloats(block, false);
1093         setLogicalHeight(oldLogicalHeight);
1094
1095         // If |child|'s previous sibling is a self-collapsing block that cleared a float and margin collapsing resulted in |child| moving up
1096         // into the margin area of the self-collapsing block then the float it clears is now intruding into |child|. Layout again so that we can look for
1097         // floats in the parent that overhang |child|'s new logical top.
1098         bool logicalTopIntrudesIntoFloat = clearanceForSelfCollapsingBlock > 0 && logicalTop < beforeCollapseLogicalTop;
1099         if (logicalTopIntrudesIntoFloat && containsFloats() && !child.avoidsFloats() && lowestFloatLogicalBottom() > logicalTop)
1100             child.setNeedsLayout();
1101     }
1102
1103     return logicalTop;
1104 }
1105
1106 LayoutUnit RenderBlockFlow::clearFloatsIfNeeded(RenderBox& child, MarginInfo& marginInfo, LayoutUnit oldTopPosMargin, LayoutUnit oldTopNegMargin, LayoutUnit yPos)
1107 {
1108     LayoutUnit heightIncrease = getClearDelta(child, yPos);
1109     if (!heightIncrease)
1110         return yPos;
1111
1112     if (child.isSelfCollapsingBlock()) {
1113         bool childDiscardMargin = mustDiscardMarginBeforeForChild(child) || mustDiscardMarginAfterForChild(child);
1114
1115         // For self-collapsing blocks that clear, they can still collapse their
1116         // margins with following siblings. Reset the current margins to represent
1117         // the self-collapsing block's margins only.
1118         // If DISCARD is specified for -webkit-margin-collapse, reset the margin values.
1119         MarginValues childMargins = marginValuesForChild(child);
1120         if (!childDiscardMargin) {
1121             marginInfo.setPositiveMargin(std::max(childMargins.positiveMarginBefore(), childMargins.positiveMarginAfter()));
1122             marginInfo.setNegativeMargin(std::max(childMargins.negativeMarginBefore(), childMargins.negativeMarginAfter()));
1123         } else
1124             marginInfo.clearMargin();
1125         marginInfo.setDiscardMargin(childDiscardMargin);
1126
1127         // CSS2.1 states:
1128         // "If the top and bottom margins of an element with clearance are adjoining, its margins collapse with 
1129         // the adjoining margins of following siblings but that resulting margin does not collapse with the bottom margin of the parent block."
1130         // So the parent's bottom margin cannot collapse through this block or any subsequent self-collapsing blocks. Check subsequent siblings
1131         // for a block with height - if none is found then don't allow the margins to collapse with the parent.
1132         bool wouldCollapseMarginsWithParent = marginInfo.canCollapseMarginAfterWithChildren();
1133         for (RenderBox* curr = child.nextSiblingBox(); curr && wouldCollapseMarginsWithParent; curr = curr->nextSiblingBox()) {
1134             if (!curr->isFloatingOrOutOfFlowPositioned() && !curr->isSelfCollapsingBlock())
1135                 wouldCollapseMarginsWithParent = false;
1136         }
1137         if (wouldCollapseMarginsWithParent)
1138             marginInfo.setCanCollapseMarginAfterWithChildren(false);
1139
1140         // For now set the border-top of |child| flush with the bottom border-edge of the float so it can layout any floating or positioned children of
1141         // its own at the correct vertical position. If subsequent siblings attempt to collapse with |child|'s margins in |collapseMargins| we will
1142         // adjust the height of the parent to |child|'s margin top (which if it is positive sits up 'inside' the float it's clearing) so that all three 
1143         // margins can collapse at the correct vertical position.
1144         // Per CSS2.1 we need to ensure that any negative margin-top clears |child| beyond the bottom border-edge of the float so that the top border edge of the child
1145         // (i.e. its clearance)  is at a position that satisfies the equation: "the amount of clearance is set so that clearance + margin-top = [height of float],
1146         // i.e., clearance = [height of float] - margin-top".
1147         setLogicalHeight(child.logicalTop() + childMargins.negativeMarginBefore());
1148     } else
1149         // Increase our height by the amount we had to clear.
1150         setLogicalHeight(logicalHeight() + heightIncrease);
1151     
1152     if (marginInfo.canCollapseWithMarginBefore()) {
1153         // We can no longer collapse with the top of the block since a clear
1154         // occurred. The empty blocks collapse into the cleared block.
1155         // FIXME: This isn't quite correct. Need clarification for what to do
1156         // if the height the cleared block is offset by is smaller than the
1157         // margins involved.
1158         setMaxMarginBeforeValues(oldTopPosMargin, oldTopNegMargin);
1159         marginInfo.setAtBeforeSideOfBlock(false);
1160
1161         // In case the child discarded the before margin of the block we need to reset the mustDiscardMarginBefore flag to the initial value.
1162         setMustDiscardMarginBefore(style().marginBeforeCollapse() == MDISCARD);
1163     }
1164
1165     return yPos + heightIncrease;
1166 }
1167
1168 void RenderBlockFlow::marginBeforeEstimateForChild(RenderBox& child, LayoutUnit& positiveMarginBefore, LayoutUnit& negativeMarginBefore, bool& discardMarginBefore) const
1169 {
1170     // Give up if in quirks mode and we're a body/table cell and the top margin of the child box is quirky.
1171     // Give up if the child specified -webkit-margin-collapse: separate that prevents collapsing.
1172     // FIXME: Use writing mode independent accessor for marginBeforeCollapse.
1173     if ((document().inQuirksMode() && hasMarginAfterQuirk(child) && (isTableCell() || isBody())) || child.style().marginBeforeCollapse() == MSEPARATE)
1174         return;
1175
1176     // The margins are discarded by a child that specified -webkit-margin-collapse: discard.
1177     // FIXME: Use writing mode independent accessor for marginBeforeCollapse.
1178     if (child.style().marginBeforeCollapse() == MDISCARD) {
1179         positiveMarginBefore = 0;
1180         negativeMarginBefore = 0;
1181         discardMarginBefore = true;
1182         return;
1183     }
1184
1185     LayoutUnit beforeChildMargin = marginBeforeForChild(child);
1186     positiveMarginBefore = std::max(positiveMarginBefore, beforeChildMargin);
1187     negativeMarginBefore = std::max(negativeMarginBefore, -beforeChildMargin);
1188
1189     if (!is<RenderBlockFlow>(child))
1190         return;
1191     
1192     RenderBlockFlow& childBlock = downcast<RenderBlockFlow>(child);
1193     if (childBlock.childrenInline() || childBlock.isWritingModeRoot())
1194         return;
1195
1196     MarginInfo childMarginInfo(childBlock, childBlock.borderAndPaddingBefore(), childBlock.borderAndPaddingAfter());
1197     if (!childMarginInfo.canCollapseMarginBeforeWithChildren())
1198         return;
1199
1200     RenderBox* grandchildBox = childBlock.firstChildBox();
1201     for (; grandchildBox; grandchildBox = grandchildBox->nextSiblingBox()) {
1202         if (!grandchildBox->isFloatingOrOutOfFlowPositioned())
1203             break;
1204     }
1205     
1206     // Give up if there is clearance on the box, since it probably won't collapse into us.
1207     if (!grandchildBox || grandchildBox->style().clear() != CNONE)
1208         return;
1209
1210     // Make sure to update the block margins now for the grandchild box so that we're looking at current values.
1211     if (grandchildBox->needsLayout()) {
1212         grandchildBox->computeAndSetBlockDirectionMargins(this);
1213         if (is<RenderBlock>(*grandchildBox)) {
1214             RenderBlock& grandchildBlock = downcast<RenderBlock>(*grandchildBox);
1215             grandchildBlock.setHasMarginBeforeQuirk(grandchildBox->style().hasMarginBeforeQuirk());
1216             grandchildBlock.setHasMarginAfterQuirk(grandchildBox->style().hasMarginAfterQuirk());
1217         }
1218     }
1219
1220     // Collapse the margin of the grandchild box with our own to produce an estimate.
1221     childBlock.marginBeforeEstimateForChild(*grandchildBox, positiveMarginBefore, negativeMarginBefore, discardMarginBefore);
1222 }
1223
1224 LayoutUnit RenderBlockFlow::estimateLogicalTopPosition(RenderBox& child, const MarginInfo& marginInfo, LayoutUnit& estimateWithoutPagination)
1225 {
1226     // FIXME: We need to eliminate the estimation of vertical position, because when it's wrong we sometimes trigger a pathological
1227     // relayout if there are intruding floats.
1228     LayoutUnit logicalTopEstimate = logicalHeight();
1229     if (!marginInfo.canCollapseWithMarginBefore()) {
1230         LayoutUnit positiveMarginBefore = 0;
1231         LayoutUnit negativeMarginBefore = 0;
1232         bool discardMarginBefore = false;
1233         if (child.selfNeedsLayout()) {
1234             // Try to do a basic estimation of how the collapse is going to go.
1235             marginBeforeEstimateForChild(child, positiveMarginBefore, negativeMarginBefore, discardMarginBefore);
1236         } else {
1237             // Use the cached collapsed margin values from a previous layout. Most of the time they
1238             // will be right.
1239             MarginValues marginValues = marginValuesForChild(child);
1240             positiveMarginBefore = std::max(positiveMarginBefore, marginValues.positiveMarginBefore());
1241             negativeMarginBefore = std::max(negativeMarginBefore, marginValues.negativeMarginBefore());
1242             discardMarginBefore = mustDiscardMarginBeforeForChild(child);
1243         }
1244
1245         // Collapse the result with our current margins.
1246         if (!discardMarginBefore)
1247             logicalTopEstimate += std::max(marginInfo.positiveMargin(), positiveMarginBefore) - std::max(marginInfo.negativeMargin(), negativeMarginBefore);
1248     }
1249
1250     // Adjust logicalTopEstimate down to the next page if the margins are so large that we don't fit on the current
1251     // page.
1252     LayoutState* layoutState = view().layoutState();
1253     if (layoutState->isPaginated() && layoutState->pageLogicalHeight() && logicalTopEstimate > logicalHeight()
1254         && hasNextPage(logicalHeight()))
1255         logicalTopEstimate = std::min(logicalTopEstimate, nextPageLogicalTop(logicalHeight()));
1256
1257     logicalTopEstimate += getClearDelta(child, logicalTopEstimate);
1258     
1259     estimateWithoutPagination = logicalTopEstimate;
1260
1261     if (layoutState->isPaginated()) {
1262         // If the object has a page or column break value of "before", then we should shift to the top of the next page.
1263         logicalTopEstimate = applyBeforeBreak(child, logicalTopEstimate);
1264     
1265         // For replaced elements and scrolled elements, we want to shift them to the next page if they don't fit on the current one.
1266         logicalTopEstimate = adjustForUnsplittableChild(child, logicalTopEstimate);
1267         
1268         if (!child.selfNeedsLayout() && is<RenderBlock>(child))
1269             logicalTopEstimate += downcast<RenderBlock>(child).paginationStrut();
1270     }
1271
1272     return logicalTopEstimate;
1273 }
1274
1275 void RenderBlockFlow::setCollapsedBottomMargin(const MarginInfo& marginInfo)
1276 {
1277     if (marginInfo.canCollapseWithMarginAfter() && !marginInfo.canCollapseWithMarginBefore()) {
1278         // Update the after side margin of the container to discard if the after margin of the last child also discards and we collapse with it.
1279         // Don't update the max margin values because we won't need them anyway.
1280         if (marginInfo.discardMargin()) {
1281             setMustDiscardMarginAfter();
1282             return;
1283         }
1284
1285         // Update our max pos/neg bottom margins, since we collapsed our bottom margins
1286         // with our children.
1287         setMaxMarginAfterValues(std::max(maxPositiveMarginAfter(), marginInfo.positiveMargin()), std::max(maxNegativeMarginAfter(), marginInfo.negativeMargin()));
1288
1289         if (!marginInfo.hasMarginAfterQuirk())
1290             setHasMarginAfterQuirk(false);
1291
1292         if (marginInfo.hasMarginAfterQuirk() && !marginAfter())
1293             // We have no bottom margin and our last child has a quirky margin.
1294             // We will pick up this quirky margin and pass it through.
1295             // This deals with the <td><div><p> case.
1296             setHasMarginAfterQuirk(true);
1297     }
1298 }
1299
1300 void RenderBlockFlow::handleAfterSideOfBlock(LayoutUnit beforeSide, LayoutUnit afterSide, MarginInfo& marginInfo)
1301 {
1302     marginInfo.setAtAfterSideOfBlock(true);
1303
1304     // If our last child was a self-collapsing block with clearance then our logical height is flush with the
1305     // bottom edge of the float that the child clears. The correct vertical position for the margin-collapsing we want
1306     // to perform now is at the child's margin-top - so adjust our height to that position.
1307     RenderObject* lastBlock = lastChild();
1308     if (is<RenderBlockFlow>(lastBlock) && downcast<RenderBlockFlow>(*lastBlock).isSelfCollapsingBlock())
1309         setLogicalHeight(logicalHeight() - downcast<RenderBlockFlow>(*lastBlock).marginOffsetForSelfCollapsingBlock());
1310
1311     // If we can't collapse with children then go ahead and add in the bottom margin.
1312     if (!marginInfo.discardMargin() && (!marginInfo.canCollapseWithMarginAfter() && !marginInfo.canCollapseWithMarginBefore()
1313         && (!document().inQuirksMode() || !marginInfo.quirkContainer() || !marginInfo.hasMarginAfterQuirk())))
1314         setLogicalHeight(logicalHeight() + marginInfo.margin());
1315         
1316     // Now add in our bottom border/padding.
1317     setLogicalHeight(logicalHeight() + afterSide);
1318
1319     // Negative margins can cause our height to shrink below our minimal height (border/padding).
1320     // If this happens, ensure that the computed height is increased to the minimal height.
1321     setLogicalHeight(std::max(logicalHeight(), beforeSide + afterSide));
1322
1323     // Update our bottom collapsed margin info.
1324     setCollapsedBottomMargin(marginInfo);
1325 }
1326
1327 void RenderBlockFlow::setMaxMarginBeforeValues(LayoutUnit pos, LayoutUnit neg)
1328 {
1329     if (!hasRareBlockFlowData()) {
1330         if (pos == RenderBlockFlowRareData::positiveMarginBeforeDefault(*this) && neg == RenderBlockFlowRareData::negativeMarginBeforeDefault(*this))
1331             return;
1332         materializeRareBlockFlowData();
1333     }
1334
1335     rareBlockFlowData()->m_margins.setPositiveMarginBefore(pos);
1336     rareBlockFlowData()->m_margins.setNegativeMarginBefore(neg);
1337 }
1338
1339 void RenderBlockFlow::setMaxMarginAfterValues(LayoutUnit pos, LayoutUnit neg)
1340 {
1341     if (!hasRareBlockFlowData()) {
1342         if (pos == RenderBlockFlowRareData::positiveMarginAfterDefault(*this) && neg == RenderBlockFlowRareData::negativeMarginAfterDefault(*this))
1343             return;
1344         materializeRareBlockFlowData();
1345     }
1346
1347     rareBlockFlowData()->m_margins.setPositiveMarginAfter(pos);
1348     rareBlockFlowData()->m_margins.setNegativeMarginAfter(neg);
1349 }
1350
1351 void RenderBlockFlow::setMustDiscardMarginBefore(bool value)
1352 {
1353     if (style().marginBeforeCollapse() == MDISCARD) {
1354         ASSERT(value);
1355         return;
1356     }
1357
1358     if (!hasRareBlockFlowData()) {
1359         if (!value)
1360             return;
1361         materializeRareBlockFlowData();
1362     }
1363
1364     rareBlockFlowData()->m_discardMarginBefore = value;
1365 }
1366
1367 void RenderBlockFlow::setMustDiscardMarginAfter(bool value)
1368 {
1369     if (style().marginAfterCollapse() == MDISCARD) {
1370         ASSERT(value);
1371         return;
1372     }
1373
1374     if (!hasRareBlockFlowData()) {
1375         if (!value)
1376             return;
1377         materializeRareBlockFlowData();
1378     }
1379
1380     rareBlockFlowData()->m_discardMarginAfter = value;
1381 }
1382
1383 bool RenderBlockFlow::mustDiscardMarginBefore() const
1384 {
1385     return style().marginBeforeCollapse() == MDISCARD || (hasRareBlockFlowData() && rareBlockFlowData()->m_discardMarginBefore);
1386 }
1387
1388 bool RenderBlockFlow::mustDiscardMarginAfter() const
1389 {
1390     return style().marginAfterCollapse() == MDISCARD || (hasRareBlockFlowData() && rareBlockFlowData()->m_discardMarginAfter);
1391 }
1392
1393 bool RenderBlockFlow::mustDiscardMarginBeforeForChild(const RenderBox& child) const
1394 {
1395     ASSERT(!child.selfNeedsLayout());
1396     if (!child.isWritingModeRoot())
1397         return is<RenderBlockFlow>(child) ? downcast<RenderBlockFlow>(child).mustDiscardMarginBefore() : (child.style().marginBeforeCollapse() == MDISCARD);
1398     if (child.isHorizontalWritingMode() == isHorizontalWritingMode())
1399         return is<RenderBlockFlow>(child) ? downcast<RenderBlockFlow>(child).mustDiscardMarginAfter() : (child.style().marginAfterCollapse() == MDISCARD);
1400
1401     // FIXME: We return false here because the implementation is not geometrically complete. We have values only for before/after, not start/end.
1402     // In case the boxes are perpendicular we assume the property is not specified.
1403     return false;
1404 }
1405
1406 bool RenderBlockFlow::mustDiscardMarginAfterForChild(const RenderBox& child) const
1407 {
1408     ASSERT(!child.selfNeedsLayout());
1409     if (!child.isWritingModeRoot())
1410         return is<RenderBlockFlow>(child) ? downcast<RenderBlockFlow>(child).mustDiscardMarginAfter() : (child.style().marginAfterCollapse() == MDISCARD);
1411     if (child.isHorizontalWritingMode() == isHorizontalWritingMode())
1412         return is<RenderBlockFlow>(child) ? downcast<RenderBlockFlow>(child).mustDiscardMarginBefore() : (child.style().marginBeforeCollapse() == MDISCARD);
1413
1414     // FIXME: See |mustDiscardMarginBeforeForChild| above.
1415     return false;
1416 }
1417
1418 bool RenderBlockFlow::mustSeparateMarginBeforeForChild(const RenderBox& child) const
1419 {
1420     ASSERT(!child.selfNeedsLayout());
1421     const RenderStyle& childStyle = child.style();
1422     if (!child.isWritingModeRoot())
1423         return childStyle.marginBeforeCollapse() == MSEPARATE;
1424     if (child.isHorizontalWritingMode() == isHorizontalWritingMode())
1425         return childStyle.marginAfterCollapse() == MSEPARATE;
1426
1427     // FIXME: See |mustDiscardMarginBeforeForChild| above.
1428     return false;
1429 }
1430
1431 bool RenderBlockFlow::mustSeparateMarginAfterForChild(const RenderBox& child) const
1432 {
1433     ASSERT(!child.selfNeedsLayout());
1434     const RenderStyle& childStyle = child.style();
1435     if (!child.isWritingModeRoot())
1436         return childStyle.marginAfterCollapse() == MSEPARATE;
1437     if (child.isHorizontalWritingMode() == isHorizontalWritingMode())
1438         return childStyle.marginBeforeCollapse() == MSEPARATE;
1439
1440     // FIXME: See |mustDiscardMarginBeforeForChild| above.
1441     return false;
1442 }
1443
1444 static bool inNormalFlow(RenderBox& child)
1445 {
1446     RenderBlock* curr = child.containingBlock();
1447     while (curr && curr != &child.view()) {
1448         if (curr->isRenderFlowThread())
1449             return true;
1450         if (curr->isFloatingOrOutOfFlowPositioned())
1451             return false;
1452         curr = curr->containingBlock();
1453     }
1454     return true;
1455 }
1456
1457 LayoutUnit RenderBlockFlow::applyBeforeBreak(RenderBox& child, LayoutUnit logicalOffset)
1458 {
1459     // FIXME: Add page break checking here when we support printing.
1460     RenderFlowThread* flowThread = flowThreadContainingBlock();
1461     bool isInsideMulticolFlowThread = flowThread && !flowThread->isRenderNamedFlowThread();
1462     bool checkColumnBreaks = flowThread && flowThread->shouldCheckColumnBreaks();
1463     bool checkPageBreaks = !checkColumnBreaks && view().layoutState()->m_pageLogicalHeight; // FIXME: Once columns can print we have to check this.
1464     bool checkRegionBreaks = flowThread && flowThread->isRenderNamedFlowThread();
1465     bool checkBeforeAlways = (checkColumnBreaks && child.style().columnBreakBefore() == PBALWAYS)
1466         || (checkPageBreaks && child.style().pageBreakBefore() == PBALWAYS)
1467         || (checkRegionBreaks && child.style().regionBreakBefore() == PBALWAYS);
1468     if (checkBeforeAlways && inNormalFlow(child) && hasNextPage(logicalOffset, IncludePageBoundary)) {
1469         if (checkColumnBreaks) {
1470             if (isInsideMulticolFlowThread)
1471                 checkRegionBreaks = true;
1472         }
1473         if (checkRegionBreaks) {
1474             LayoutUnit offsetBreakAdjustment = 0;
1475             if (flowThread->addForcedRegionBreak(this, offsetFromLogicalTopOfFirstPage() + logicalOffset, &child, true, &offsetBreakAdjustment))
1476                 return logicalOffset + offsetBreakAdjustment;
1477         }
1478         return nextPageLogicalTop(logicalOffset, IncludePageBoundary);
1479     }
1480     return logicalOffset;
1481 }
1482
1483 LayoutUnit RenderBlockFlow::applyAfterBreak(RenderBox& child, LayoutUnit logicalOffset, MarginInfo& marginInfo)
1484 {
1485     // FIXME: Add page break checking here when we support printing.
1486     RenderFlowThread* flowThread = flowThreadContainingBlock();
1487     bool isInsideMulticolFlowThread = flowThread && !flowThread->isRenderNamedFlowThread();
1488     bool checkColumnBreaks = flowThread && flowThread->shouldCheckColumnBreaks();
1489     bool checkPageBreaks = !checkColumnBreaks && view().layoutState()->m_pageLogicalHeight; // FIXME: Once columns can print we have to check this.
1490     bool checkRegionBreaks = flowThread && flowThread->isRenderNamedFlowThread();
1491     bool checkAfterAlways = (checkColumnBreaks && child.style().columnBreakAfter() == PBALWAYS)
1492         || (checkPageBreaks && child.style().pageBreakAfter() == PBALWAYS)
1493         || (checkRegionBreaks && child.style().regionBreakAfter() == PBALWAYS);
1494     if (checkAfterAlways && inNormalFlow(child) && hasNextPage(logicalOffset, IncludePageBoundary)) {
1495         LayoutUnit marginOffset = marginInfo.canCollapseWithMarginBefore() ? LayoutUnit() : marginInfo.margin();
1496
1497         // So our margin doesn't participate in the next collapsing steps.
1498         marginInfo.clearMargin();
1499
1500         if (checkColumnBreaks) {
1501             if (isInsideMulticolFlowThread)
1502                 checkRegionBreaks = true;
1503         }
1504         if (checkRegionBreaks) {
1505             LayoutUnit offsetBreakAdjustment = 0;
1506             if (flowThread->addForcedRegionBreak(this, offsetFromLogicalTopOfFirstPage() + logicalOffset + marginOffset, &child, false, &offsetBreakAdjustment))
1507                 return logicalOffset + marginOffset + offsetBreakAdjustment;
1508         }
1509         return nextPageLogicalTop(logicalOffset, IncludePageBoundary);
1510     }
1511     return logicalOffset;
1512 }
1513
1514 LayoutUnit RenderBlockFlow::adjustBlockChildForPagination(LayoutUnit logicalTopAfterClear, LayoutUnit estimateWithoutPagination, RenderBox& child, bool atBeforeSideOfBlock)
1515 {
1516     RenderBlock* childRenderBlock = is<RenderBlock>(child) ? &downcast<RenderBlock>(child) : nullptr;
1517
1518     if (estimateWithoutPagination != logicalTopAfterClear) {
1519         // Our guess prior to pagination movement was wrong. Before we attempt to paginate, let's try again at the new
1520         // position.
1521         setLogicalHeight(logicalTopAfterClear);
1522         setLogicalTopForChild(child, logicalTopAfterClear, ApplyLayoutDelta);
1523
1524         if (child.shrinkToAvoidFloats()) {
1525             // The child's width depends on the line width.
1526             // When the child shifts to clear an item, its width can
1527             // change (because it has more available line width).
1528             // So go ahead and mark the item as dirty.
1529             child.setChildNeedsLayout(MarkOnlyThis);
1530         }
1531         
1532         if (childRenderBlock) {
1533             if (!child.avoidsFloats() && childRenderBlock->containsFloats())
1534                 downcast<RenderBlockFlow>(*childRenderBlock).markAllDescendantsWithFloatsForLayout();
1535             if (!child.needsLayout())
1536                 child.markForPaginationRelayoutIfNeeded();
1537         }
1538
1539         // Our guess was wrong. Make the child lay itself out again.
1540         child.layoutIfNeeded();
1541     }
1542
1543     LayoutUnit oldTop = logicalTopAfterClear;
1544
1545     // If the object has a page or column break value of "before", then we should shift to the top of the next page.
1546     LayoutUnit result = applyBeforeBreak(child, logicalTopAfterClear);
1547
1548     if (pageLogicalHeightForOffset(result)) {
1549         LayoutUnit remainingLogicalHeight = pageRemainingLogicalHeightForOffset(result, ExcludePageBoundary);
1550         LayoutUnit spaceShortage = child.logicalHeight() - remainingLogicalHeight;
1551         if (spaceShortage > 0) {
1552             // If the child crosses a column boundary, report a break, in case nothing inside it has already
1553             // done so. The column balancer needs to know how much it has to stretch the columns to make more
1554             // content fit. If no breaks are reported (but do occur), the balancer will have no clue. FIXME:
1555             // This should be improved, though, because here we just pretend that the child is
1556             // unsplittable. A splittable child, on the other hand, has break opportunities at every position
1557             // where there's no child content, border or padding. In other words, we risk stretching more
1558             // than necessary.
1559             setPageBreak(result, spaceShortage);
1560         }
1561     }
1562
1563     // For replaced elements and scrolled elements, we want to shift them to the next page if they don't fit on the current one.
1564     LayoutUnit logicalTopBeforeUnsplittableAdjustment = result;
1565     LayoutUnit logicalTopAfterUnsplittableAdjustment = adjustForUnsplittableChild(child, result);
1566     
1567     LayoutUnit paginationStrut = 0;
1568     LayoutUnit unsplittableAdjustmentDelta = logicalTopAfterUnsplittableAdjustment - logicalTopBeforeUnsplittableAdjustment;
1569     if (unsplittableAdjustmentDelta)
1570         paginationStrut = unsplittableAdjustmentDelta;
1571     else if (childRenderBlock && childRenderBlock->paginationStrut())
1572         paginationStrut = childRenderBlock->paginationStrut();
1573
1574     if (paginationStrut) {
1575         // We are willing to propagate out to our parent block as long as we were at the top of the block prior
1576         // to collapsing our margins, and as long as we didn't clear or move as a result of other pagination.
1577         if (atBeforeSideOfBlock && oldTop == result && !isOutOfFlowPositioned() && !isTableCell()) {
1578             // FIXME: Should really check if we're exceeding the page height before propagating the strut, but we don't
1579             // have all the information to do so (the strut only has the remaining amount to push). Gecko gets this wrong too
1580             // and pushes to the next page anyway, so not too concerned about it.
1581             setPaginationStrut(result + paginationStrut);
1582             if (childRenderBlock)
1583                 childRenderBlock->setPaginationStrut(0);
1584         } else
1585             result += paginationStrut;
1586     }
1587
1588     // Similar to how we apply clearance. Go ahead and boost height() to be the place where we're going to position the child.
1589     setLogicalHeight(logicalHeight() + (result - oldTop));
1590     
1591     // Return the final adjusted logical top.
1592     return result;
1593 }
1594
1595 static inline LayoutUnit calculateMinimumPageHeight(RenderStyle* renderStyle, RootInlineBox* lastLine, LayoutUnit lineTop, LayoutUnit lineBottom)
1596 {
1597     // We may require a certain minimum number of lines per page in order to satisfy
1598     // orphans and widows, and that may affect the minimum page height.
1599     unsigned lineCount = std::max<unsigned>(renderStyle->hasAutoOrphans() ? 1 : renderStyle->orphans(), renderStyle->hasAutoWidows() ? 1 : renderStyle->widows());
1600     if (lineCount > 1) {
1601         RootInlineBox* line = lastLine;
1602         for (unsigned i = 1; i < lineCount && line->prevRootBox(); i++)
1603             line = line->prevRootBox();
1604
1605         // FIXME: Paginating using line overflow isn't all fine. See FIXME in
1606         // adjustLinePositionForPagination() for more details.
1607         LayoutRect overflow = line->logicalVisualOverflowRect(line->lineTop(), line->lineBottom());
1608         lineTop = std::min(line->lineTopWithLeading(), overflow.y());
1609     }
1610     return lineBottom - lineTop;
1611 }
1612
1613 void RenderBlockFlow::adjustLinePositionForPagination(RootInlineBox* lineBox, LayoutUnit& delta, bool& overflowsRegion, RenderFlowThread* flowThread)
1614 {
1615     // FIXME: For now we paginate using line overflow. This ensures that lines don't overlap at all when we
1616     // put a strut between them for pagination purposes. However, this really isn't the desired rendering, since
1617     // the line on the top of the next page will appear too far down relative to the same kind of line at the top
1618     // of the first column.
1619     //
1620     // The rendering we would like to see is one where the lineTopWithLeading is at the top of the column, and any line overflow
1621     // simply spills out above the top of the column. This effect would match what happens at the top of the first column.
1622     // We can't achieve this rendering, however, until we stop columns from clipping to the column bounds (thus allowing
1623     // for overflow to occur), and then cache visible overflow for each column rect.
1624     //
1625     // Furthermore, the paint we have to do when a column has overflow has to be special. We need to exclude
1626     // content that paints in a previous column (and content that paints in the following column).
1627     //
1628     // For now we'll at least honor the lineTopWithLeading when paginating if it is above the logical top overflow. This will
1629     // at least make positive leading work in typical cases.
1630     //
1631     // FIXME: Another problem with simply moving lines is that the available line width may change (because of floats).
1632     // Technically if the location we move the line to has a different line width than our old position, then we need to dirty the
1633     // line and all following lines.
1634     overflowsRegion = false;
1635     LayoutRect logicalVisualOverflow = lineBox->logicalVisualOverflowRect(lineBox->lineTop(), lineBox->lineBottom());
1636     LayoutUnit logicalOffset = std::min(lineBox->lineTopWithLeading(), logicalVisualOverflow.y());
1637     LayoutUnit logicalBottom = std::max(lineBox->lineBottomWithLeading(), logicalVisualOverflow.maxY());
1638     LayoutUnit lineHeight = logicalBottom - logicalOffset;
1639     updateMinimumPageHeight(logicalOffset, calculateMinimumPageHeight(&style(), lineBox, logicalOffset, logicalBottom));
1640     logicalOffset += delta;
1641     lineBox->setPaginationStrut(0);
1642     lineBox->setIsFirstAfterPageBreak(false);
1643     LayoutUnit pageLogicalHeight = pageLogicalHeightForOffset(logicalOffset);
1644     bool hasUniformPageLogicalHeight = !flowThread || flowThread->regionsHaveUniformLogicalHeight();
1645     // If lineHeight is greater than pageLogicalHeight, but logicalVisualOverflow.height() still fits, we are
1646     // still going to add a strut, so that the visible overflow fits on a single page.
1647     if (!pageLogicalHeight || (hasUniformPageLogicalHeight && logicalVisualOverflow.height() > pageLogicalHeight)
1648         || !hasNextPage(logicalOffset))
1649         // FIXME: In case the line aligns with the top of the page (or it's slightly shifted downwards) it will not be marked as the first line in the page.
1650         // From here, the fix is not straightforward because it's not easy to always determine when the current line is the first in the page.
1651         return;
1652     LayoutUnit remainingLogicalHeight = pageRemainingLogicalHeightForOffset(logicalOffset, ExcludePageBoundary);
1653     overflowsRegion = (lineHeight > remainingLogicalHeight);
1654
1655     int lineIndex = lineCount(lineBox);
1656     if (remainingLogicalHeight < lineHeight || (shouldBreakAtLineToAvoidWidow() && lineBreakToAvoidWidow() == lineIndex)) {
1657         if (shouldBreakAtLineToAvoidWidow() && lineBreakToAvoidWidow() == lineIndex) {
1658             clearShouldBreakAtLineToAvoidWidow();
1659             setDidBreakAtLineToAvoidWidow();
1660         }
1661         // If we have a non-uniform page height, then we have to shift further possibly.
1662         if (!hasUniformPageLogicalHeight && !pushToNextPageWithMinimumLogicalHeight(remainingLogicalHeight, logicalOffset, lineHeight))
1663             return;
1664         if (lineHeight > pageLogicalHeight) {
1665             // Split the top margin in order to avoid splitting the visible part of the line.
1666             remainingLogicalHeight -= std::min(lineHeight - pageLogicalHeight, std::max<LayoutUnit>(0, logicalVisualOverflow.y() - lineBox->lineTopWithLeading()));
1667         }
1668         LayoutUnit remainingLogicalHeightAtNewOffset = pageRemainingLogicalHeightForOffset(logicalOffset + remainingLogicalHeight, ExcludePageBoundary);
1669         overflowsRegion = (lineHeight > remainingLogicalHeightAtNewOffset);
1670         LayoutUnit totalLogicalHeight = lineHeight + std::max<LayoutUnit>(0, logicalOffset);
1671         LayoutUnit pageLogicalHeightAtNewOffset = hasUniformPageLogicalHeight ? pageLogicalHeight : pageLogicalHeightForOffset(logicalOffset + remainingLogicalHeight);
1672         setPageBreak(logicalOffset, lineHeight - remainingLogicalHeight);
1673         if (((lineBox == firstRootBox() && totalLogicalHeight < pageLogicalHeightAtNewOffset) || (!style().hasAutoOrphans() && style().orphans() >= lineIndex))
1674             && !isOutOfFlowPositioned() && !isTableCell())
1675             setPaginationStrut(remainingLogicalHeight + std::max<LayoutUnit>(0, logicalOffset));
1676         else {
1677             delta += remainingLogicalHeight;
1678             lineBox->setPaginationStrut(remainingLogicalHeight);
1679             lineBox->setIsFirstAfterPageBreak(true);
1680         }
1681     } else if (remainingLogicalHeight == pageLogicalHeight) {
1682         // We're at the very top of a page or column.
1683         if (lineBox != firstRootBox())
1684             lineBox->setIsFirstAfterPageBreak(true);
1685         if (lineBox != firstRootBox() || offsetFromLogicalTopOfFirstPage())
1686             setPageBreak(logicalOffset, lineHeight);
1687     }
1688 }
1689
1690 void RenderBlockFlow::setBreakAtLineToAvoidWidow(int lineToBreak)
1691 {
1692     ASSERT(lineToBreak >= 0);
1693     ASSERT(!ensureRareBlockFlowData().m_didBreakAtLineToAvoidWidow);
1694     ensureRareBlockFlowData().m_lineBreakToAvoidWidow = lineToBreak;
1695 }
1696
1697 void RenderBlockFlow::setDidBreakAtLineToAvoidWidow()
1698 {
1699     ASSERT(!shouldBreakAtLineToAvoidWidow());
1700     if (!hasRareBlockFlowData())
1701         return;
1702
1703     rareBlockFlowData()->m_didBreakAtLineToAvoidWidow = true;
1704 }
1705
1706 void RenderBlockFlow::clearDidBreakAtLineToAvoidWidow()
1707 {
1708     if (!hasRareBlockFlowData())
1709         return;
1710
1711     rareBlockFlowData()->m_didBreakAtLineToAvoidWidow = false;
1712 }
1713
1714 void RenderBlockFlow::clearShouldBreakAtLineToAvoidWidow() const
1715 {
1716     ASSERT(shouldBreakAtLineToAvoidWidow());
1717     if (!hasRareBlockFlowData())
1718         return;
1719
1720     rareBlockFlowData()->m_lineBreakToAvoidWidow = -1;
1721 }
1722
1723 bool RenderBlockFlow::relayoutToAvoidWidows(LayoutStateMaintainer& statePusher)
1724 {
1725     if (!shouldBreakAtLineToAvoidWidow())
1726         return false;
1727
1728     statePusher.pop();
1729     setEverHadLayout(true);
1730     layoutBlock(false);
1731     return true;
1732 }
1733
1734 bool RenderBlockFlow::hasNextPage(LayoutUnit logicalOffset, PageBoundaryRule pageBoundaryRule) const
1735 {
1736     ASSERT(view().layoutState() && view().layoutState()->isPaginated());
1737
1738     RenderFlowThread* flowThread = flowThreadContainingBlock();
1739     if (!flowThread)
1740         return true; // Printing and multi-column both make new pages to accommodate content.
1741
1742     // See if we're in the last region.
1743     LayoutUnit pageOffset = offsetFromLogicalTopOfFirstPage() + logicalOffset;
1744     RenderRegion* region = flowThread->regionAtBlockOffset(this, pageOffset, true);
1745     if (!region)
1746         return false;
1747
1748     if (region->isLastRegion())
1749         return region->isRenderRegionSet() || region->style().regionFragment() == BreakRegionFragment
1750             || (pageBoundaryRule == IncludePageBoundary && pageOffset == region->logicalTopForFlowThreadContent());
1751
1752     RenderRegion* startRegion = nullptr;
1753     RenderRegion* endRegion = nullptr;
1754     flowThread->getRegionRangeForBox(this, startRegion, endRegion);
1755     return (endRegion && region != endRegion);
1756 }
1757
1758 LayoutUnit RenderBlockFlow::adjustForUnsplittableChild(RenderBox& child, LayoutUnit logicalOffset, bool includeMargins)
1759 {
1760     if (!childBoxIsUnsplittableForFragmentation(child))
1761         return logicalOffset;
1762
1763     RenderFlowThread* flowThread = flowThreadContainingBlock();
1764     LayoutUnit childLogicalHeight = logicalHeightForChild(child) + (includeMargins ? marginBeforeForChild(child) + marginAfterForChild(child) : LayoutUnit());
1765     LayoutUnit pageLogicalHeight = pageLogicalHeightForOffset(logicalOffset);
1766     bool hasUniformPageLogicalHeight = !flowThread || flowThread->regionsHaveUniformLogicalHeight();
1767     updateMinimumPageHeight(logicalOffset, childLogicalHeight);
1768     if (!pageLogicalHeight || (hasUniformPageLogicalHeight && childLogicalHeight > pageLogicalHeight)
1769         || !hasNextPage(logicalOffset))
1770         return logicalOffset;
1771     LayoutUnit remainingLogicalHeight = pageRemainingLogicalHeightForOffset(logicalOffset, ExcludePageBoundary);
1772     if (remainingLogicalHeight < childLogicalHeight) {
1773         if (!hasUniformPageLogicalHeight && !pushToNextPageWithMinimumLogicalHeight(remainingLogicalHeight, logicalOffset, childLogicalHeight))
1774             return logicalOffset;
1775         return logicalOffset + remainingLogicalHeight;
1776     }
1777     return logicalOffset;
1778 }
1779
1780 bool RenderBlockFlow::pushToNextPageWithMinimumLogicalHeight(LayoutUnit& adjustment, LayoutUnit logicalOffset, LayoutUnit minimumLogicalHeight) const
1781 {
1782     bool checkRegion = false;
1783     for (LayoutUnit pageLogicalHeight = pageLogicalHeightForOffset(logicalOffset + adjustment); pageLogicalHeight;
1784         pageLogicalHeight = pageLogicalHeightForOffset(logicalOffset + adjustment)) {
1785         if (minimumLogicalHeight <= pageLogicalHeight)
1786             return true;
1787         if (!hasNextPage(logicalOffset + adjustment))
1788             return false;
1789         adjustment += pageLogicalHeight;
1790         checkRegion = true;
1791     }
1792     return !checkRegion;
1793 }
1794
1795 void RenderBlockFlow::setPageBreak(LayoutUnit offset, LayoutUnit spaceShortage)
1796 {
1797     if (RenderFlowThread* flowThread = flowThreadContainingBlock())
1798         flowThread->setPageBreak(this, offsetFromLogicalTopOfFirstPage() + offset, spaceShortage);
1799 }
1800
1801 void RenderBlockFlow::updateMinimumPageHeight(LayoutUnit offset, LayoutUnit minHeight)
1802 {
1803     if (RenderFlowThread* flowThread = flowThreadContainingBlock())
1804         flowThread->updateMinimumPageHeight(this, offsetFromLogicalTopOfFirstPage() + offset, minHeight);
1805 }
1806
1807 LayoutUnit RenderBlockFlow::nextPageLogicalTop(LayoutUnit logicalOffset, PageBoundaryRule pageBoundaryRule) const
1808 {
1809     LayoutUnit pageLogicalHeight = pageLogicalHeightForOffset(logicalOffset);
1810     if (!pageLogicalHeight)
1811         return logicalOffset;
1812     
1813     // The logicalOffset is in our coordinate space.  We can add in our pushed offset.
1814     LayoutUnit remainingLogicalHeight = pageRemainingLogicalHeightForOffset(logicalOffset);
1815     if (pageBoundaryRule == ExcludePageBoundary)
1816         return logicalOffset + (remainingLogicalHeight ? remainingLogicalHeight : pageLogicalHeight);
1817     return logicalOffset + remainingLogicalHeight;
1818 }
1819
1820 LayoutUnit RenderBlockFlow::pageLogicalTopForOffset(LayoutUnit offset) const
1821 {
1822     LayoutUnit firstPageLogicalTop = isHorizontalWritingMode() ? view().layoutState()->m_pageOffset.height() : view().layoutState()->m_pageOffset.width();
1823     LayoutUnit blockLogicalTop = isHorizontalWritingMode() ? view().layoutState()->m_layoutOffset.height() : view().layoutState()->m_layoutOffset.width();
1824
1825     LayoutUnit cumulativeOffset = offset + blockLogicalTop;
1826     RenderFlowThread* flowThread = flowThreadContainingBlock();
1827     if (!flowThread) {
1828         LayoutUnit pageLogicalHeight = view().layoutState()->pageLogicalHeight();
1829         if (!pageLogicalHeight)
1830             return 0;
1831         return cumulativeOffset - roundToInt(cumulativeOffset - firstPageLogicalTop) % roundToInt(pageLogicalHeight);
1832     }
1833     return firstPageLogicalTop + flowThread->pageLogicalTopForOffset(cumulativeOffset - firstPageLogicalTop);
1834 }
1835
1836 LayoutUnit RenderBlockFlow::pageLogicalHeightForOffset(LayoutUnit offset) const
1837 {
1838     RenderFlowThread* flowThread = flowThreadContainingBlock();
1839     if (!flowThread)
1840         return view().layoutState()->m_pageLogicalHeight;
1841     return flowThread->pageLogicalHeightForOffset(offset + offsetFromLogicalTopOfFirstPage());
1842 }
1843
1844 LayoutUnit RenderBlockFlow::pageRemainingLogicalHeightForOffset(LayoutUnit offset, PageBoundaryRule pageBoundaryRule) const
1845 {
1846     offset += offsetFromLogicalTopOfFirstPage();
1847     
1848     RenderFlowThread* flowThread = flowThreadContainingBlock();
1849     if (!flowThread) {
1850         LayoutUnit pageLogicalHeight = view().layoutState()->m_pageLogicalHeight;
1851         LayoutUnit remainingHeight = pageLogicalHeight - intMod(offset, pageLogicalHeight);
1852         if (pageBoundaryRule == IncludePageBoundary) {
1853             // If includeBoundaryPoint is true the line exactly on the top edge of a
1854             // column will act as being part of the previous column.
1855             remainingHeight = intMod(remainingHeight, pageLogicalHeight);
1856         }
1857         return remainingHeight;
1858     }
1859     
1860     return flowThread->pageRemainingLogicalHeightForOffset(offset, pageBoundaryRule);
1861 }
1862
1863 LayoutUnit RenderBlockFlow::logicalHeightForChildForFragmentation(const RenderBox& child) const
1864 {
1865     // This method is required because regions do not fragment monolithic elements but instead
1866     // they let them overflow the region they flow in. This behaviour is different from the 
1867     // multicol/printing implementations, which have not yet been updated to correctly handle
1868     // monolithic elements.
1869     // As a result, for the moment, this method will only be used for regions, the multicol and
1870     // printing implementations will stick to the existing behaviour until their fragmentation
1871     // implementation is updated to match the regions implementation.
1872     if (!flowThreadContainingBlock() || !flowThreadContainingBlock()->isRenderNamedFlowThread())
1873         return logicalHeightForChild(child);
1874
1875     // For unsplittable elements, this method will just return the height of the element that
1876     // fits into the current region, without the height of the part that overflows the region.
1877     // This is done for all regions, except the last one because in that case, the logical
1878     // height of the flow thread needs to also
1879     if (!childBoxIsUnsplittableForFragmentation(child) || !pageLogicalHeightForOffset(logicalTopForChild(child)))
1880         return logicalHeightForChild(child);
1881
1882     // If we're on the last page this block fragments to, the logical height of the flow thread must include
1883     // the entire unsplittable child because any following children will not be moved to the next page
1884     // so they will need to be laid out below the current unsplittable child.
1885     LayoutUnit childLogicalTop = logicalTopForChild(child);
1886     if (!hasNextPage(childLogicalTop))
1887         return logicalHeightForChild(child);
1888     
1889     LayoutUnit remainingLogicalHeight = pageRemainingLogicalHeightForOffset(childLogicalTop, ExcludePageBoundary);
1890     return std::min(child.logicalHeight(), remainingLogicalHeight);
1891 }
1892
1893 void RenderBlockFlow::layoutLineGridBox()
1894 {
1895     if (style().lineGrid() == RenderStyle::initialLineGrid()) {
1896         setLineGridBox(0);
1897         return;
1898     }
1899     
1900     setLineGridBox(0);
1901
1902     auto lineGridBox = std::make_unique<RootInlineBox>(*this);
1903     lineGridBox->setHasTextChildren(); // Needed to make the line ascent/descent actually be honored in quirks mode.
1904     lineGridBox->setConstructed();
1905     GlyphOverflowAndFallbackFontsMap textBoxDataMap;
1906     VerticalPositionCache verticalPositionCache;
1907     lineGridBox->alignBoxesInBlockDirection(logicalHeight(), textBoxDataMap, verticalPositionCache);
1908     
1909     setLineGridBox(WTF::move(lineGridBox));
1910
1911     // FIXME: If any of the characteristics of the box change compared to the old one, then we need to do a deep dirtying
1912     // (similar to what happens when the page height changes). Ideally, though, we only do this if someone is actually snapping
1913     // to this grid.
1914 }
1915
1916 bool RenderBlockFlow::containsFloat(RenderBox& renderer) const
1917 {
1918     return m_floatingObjects && m_floatingObjects->set().contains<RenderBox&, FloatingObjectHashTranslator>(renderer);
1919 }
1920
1921 void RenderBlockFlow::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
1922 {
1923     RenderBlock::styleDidChange(diff, oldStyle);
1924     
1925     // After our style changed, if we lose our ability to propagate floats into next sibling
1926     // blocks, then we need to find the top most parent containing that overhanging float and
1927     // then mark its descendants with floats for layout and clear all floats from its next
1928     // sibling blocks that exist in our floating objects list. See bug 56299 and 62875.
1929     bool canPropagateFloatIntoSibling = !isFloatingOrOutOfFlowPositioned() && !avoidsFloats();
1930     if (diff == StyleDifferenceLayout && s_canPropagateFloatIntoSibling && !canPropagateFloatIntoSibling && hasOverhangingFloats()) {
1931         RenderBlockFlow* parentBlock = this;
1932         const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
1933
1934         for (auto& ancestor : ancestorsOfType<RenderBlockFlow>(*this)) {
1935             if (ancestor.isRenderView())
1936                 break;
1937             if (ancestor.hasOverhangingFloats()) {
1938                 for (auto it = floatingObjectSet.begin(), end = floatingObjectSet.end(); it != end; ++it) {
1939                     RenderBox& renderer = (*it)->renderer();
1940                     if (ancestor.hasOverhangingFloat(renderer)) {
1941                         parentBlock = &ancestor;
1942                         break;
1943                     }
1944                 }
1945             }
1946         }
1947
1948         parentBlock->markAllDescendantsWithFloatsForLayout();
1949         parentBlock->markSiblingsWithFloatsForLayout();
1950     }
1951
1952     if (auto fragment = renderNamedFlowFragment())
1953         fragment->setStyle(RenderNamedFlowFragment::createStyle(style()));
1954
1955     if (diff >= StyleDifferenceRepaint) {
1956         // FIXME: This could use a cheaper style-only test instead of SimpleLineLayout::canUseFor.
1957         if (selfNeedsLayout() || !m_simpleLineLayout || !SimpleLineLayout::canUseFor(*this))
1958             invalidateLineLayoutPath();
1959     }
1960
1961     if (multiColumnFlowThread())
1962         updateStylesForColumnChildren();
1963 }
1964
1965 void RenderBlockFlow::updateStylesForColumnChildren()
1966 {
1967     for (auto child = firstChildBox(); child && (child->isInFlowRenderFlowThread() || child->isRenderMultiColumnSet()); child = child->nextSiblingBox())
1968         child->setStyle(RenderStyle::createAnonymousStyleWithDisplay(&style(), BLOCK));
1969 }
1970
1971 void RenderBlockFlow::styleWillChange(StyleDifference diff, const RenderStyle& newStyle)
1972 {
1973     const RenderStyle* oldStyle = hasInitializedStyle() ? &style() : nullptr;
1974     s_canPropagateFloatIntoSibling = oldStyle ? !isFloatingOrOutOfFlowPositioned() && !avoidsFloats() : false;
1975
1976     if (oldStyle) {
1977         EPosition oldPosition = oldStyle->position();
1978         EPosition newPosition = newStyle.position();
1979
1980         if (parent() && diff == StyleDifferenceLayout && oldPosition != newPosition) {
1981             if (containsFloats() && !isFloating() && !isOutOfFlowPositioned() && newStyle.hasOutOfFlowPosition())
1982                 markAllDescendantsWithFloatsForLayout();
1983         }
1984     }
1985
1986     RenderBlock::styleWillChange(diff, newStyle);
1987 }
1988
1989 void RenderBlockFlow::deleteLines()
1990 {
1991     if (containsFloats())
1992         m_floatingObjects->clearLineBoxTreePointers();
1993
1994     if (m_simpleLineLayout) {
1995         ASSERT(!m_lineBoxes.firstLineBox());
1996         m_simpleLineLayout = nullptr;
1997     } else
1998         m_lineBoxes.deleteLineBoxTree();
1999
2000     RenderBlock::deleteLines();
2001 }
2002
2003 void RenderBlockFlow::moveFloatsTo(RenderBlockFlow* toBlockFlow)
2004 {
2005     // When a portion of the render tree is being detached, anonymous blocks
2006     // will be combined as their children are deleted. In this process, the
2007     // anonymous block later in the tree is merged into the one preceeding it.
2008     // It can happen that the later block (this) contains floats that the
2009     // previous block (toBlockFlow) did not contain, and thus are not in the
2010     // floating objects list for toBlockFlow. This can result in toBlockFlow
2011     // containing floats that are not in it's floating objects list, but are in
2012     // the floating objects lists of siblings and parents. This can cause
2013     // problems when the float itself is deleted, since the deletion code
2014     // assumes that if a float is not in it's containing block's floating
2015     // objects list, it isn't in any floating objects list. In order to
2016     // preserve this condition (removing it has serious performance
2017     // implications), we need to copy the floating objects from the old block
2018     // (this) to the new block (toBlockFlow). The float's metrics will likely
2019     // all be wrong, but since toBlockFlow is already marked for layout, this
2020     // will get fixed before anything gets displayed.
2021     // See bug https://bugs.webkit.org/show_bug.cgi?id=115566
2022     if (m_floatingObjects) {
2023         if (!toBlockFlow->m_floatingObjects)
2024             toBlockFlow->createFloatingObjects();
2025
2026         const FloatingObjectSet& fromFloatingObjectSet = m_floatingObjects->set();
2027         auto end = fromFloatingObjectSet.end();
2028
2029         for (auto it = fromFloatingObjectSet.begin(); it != end; ++it) {
2030             FloatingObject* floatingObject = it->get();
2031
2032             // Don't insert the object again if it's already in the list
2033             if (toBlockFlow->containsFloat(floatingObject->renderer()))
2034                 continue;
2035
2036             toBlockFlow->m_floatingObjects->add(floatingObject->unsafeClone());
2037         }
2038     }
2039 }
2040
2041 void RenderBlockFlow::moveAllChildrenIncludingFloatsTo(RenderBlock& toBlock, bool fullRemoveInsert)
2042 {
2043     RenderBlockFlow& toBlockFlow = downcast<RenderBlockFlow>(toBlock);
2044     moveAllChildrenTo(&toBlockFlow, fullRemoveInsert);
2045     moveFloatsTo(&toBlockFlow);
2046 }
2047
2048 void RenderBlockFlow::addOverflowFromFloats()
2049 {
2050     if (!m_floatingObjects)
2051         return;
2052
2053     const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
2054     auto end = floatingObjectSet.end();
2055     for (auto it = floatingObjectSet.begin(); it != end; ++it) {
2056         FloatingObject* r = it->get();
2057         if (r->isDescendant())
2058             addOverflowFromChild(&r->renderer(), IntSize(xPositionForFloatIncludingMargin(r), yPositionForFloatIncludingMargin(r)));
2059     }
2060 }
2061
2062 void RenderBlockFlow::computeOverflow(LayoutUnit oldClientAfterEdge, bool recomputeFloats)
2063 {
2064     RenderBlock::computeOverflow(oldClientAfterEdge, recomputeFloats);
2065
2066     if (!multiColumnFlowThread() && (recomputeFloats || isRoot() || expandsToEncloseOverhangingFloats() || hasSelfPaintingLayer()))
2067         addOverflowFromFloats();
2068 }
2069
2070 void RenderBlockFlow::repaintOverhangingFloats(bool paintAllDescendants)
2071 {
2072     // Repaint any overhanging floats (if we know we're the one to paint them).
2073     // Otherwise, bail out.
2074     if (!hasOverhangingFloats())
2075         return;
2076
2077     // FIXME: Avoid disabling LayoutState. At the very least, don't disable it for floats originating
2078     // in this block. Better yet would be to push extra state for the containers of other floats.
2079     LayoutStateDisabler layoutStateDisabler(&view());
2080     const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
2081     auto end = floatingObjectSet.end();
2082     for (auto it = floatingObjectSet.begin(); it != end; ++it) {
2083         FloatingObject* floatingObject = it->get();
2084         // Only repaint the object if it is overhanging, is not in its own layer, and
2085         // is our responsibility to paint (m_shouldPaint is set). When paintAllDescendants is true, the latter
2086         // condition is replaced with being a descendant of us.
2087         if (logicalBottomForFloat(floatingObject) > logicalHeight()
2088             && !floatingObject->renderer().hasSelfPaintingLayer()
2089             && (floatingObject->shouldPaint() || (paintAllDescendants && floatingObject->renderer().isDescendantOf(this)))) {
2090             floatingObject->renderer().repaint();
2091             floatingObject->renderer().repaintOverhangingFloats(false);
2092         }
2093     }
2094 }
2095
2096 void RenderBlockFlow::paintColumnRules(PaintInfo& paintInfo, const LayoutPoint& point)
2097 {
2098     RenderBlock::paintColumnRules(paintInfo, point);
2099     
2100     if (!multiColumnFlowThread() || paintInfo.context->paintingDisabled())
2101         return;
2102
2103     // Iterate over our children and paint the column rules as needed.
2104     for (auto& columnSet : childrenOfType<RenderMultiColumnSet>(*this)) {
2105         LayoutPoint childPoint = columnSet.location() + flipForWritingModeForChild(&columnSet, point);
2106         columnSet.paintColumnRules(paintInfo, childPoint);
2107     }
2108 }
2109
2110 void RenderBlockFlow::paintFloats(PaintInfo& paintInfo, const LayoutPoint& paintOffset, bool preservePhase)
2111 {
2112     if (!m_floatingObjects)
2113         return;
2114
2115     const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
2116     auto end = floatingObjectSet.end();
2117     for (auto it = floatingObjectSet.begin(); it != end; ++it) {
2118         FloatingObject* r = it->get();
2119         // Only paint the object if our m_shouldPaint flag is set.
2120         if (r->shouldPaint() && !r->renderer().hasSelfPaintingLayer()) {
2121             PaintInfo currentPaintInfo(paintInfo);
2122             currentPaintInfo.phase = preservePhase ? paintInfo.phase : PaintPhaseBlockBackground;
2123             // FIXME: LayoutPoint version of xPositionForFloatIncludingMargin would make this much cleaner.
2124             LayoutPoint childPoint = flipFloatForWritingModeForChild(r, LayoutPoint(paintOffset.x() + xPositionForFloatIncludingMargin(r) - r->renderer().x(), paintOffset.y() + yPositionForFloatIncludingMargin(r) - r->renderer().y()));
2125             r->renderer().paint(currentPaintInfo, childPoint);
2126             if (!preservePhase) {
2127                 currentPaintInfo.phase = PaintPhaseChildBlockBackgrounds;
2128                 r->renderer().paint(currentPaintInfo, childPoint);
2129                 currentPaintInfo.phase = PaintPhaseFloat;
2130                 r->renderer().paint(currentPaintInfo, childPoint);
2131                 currentPaintInfo.phase = PaintPhaseForeground;
2132                 r->renderer().paint(currentPaintInfo, childPoint);
2133                 currentPaintInfo.phase = PaintPhaseOutline;
2134                 r->renderer().paint(currentPaintInfo, childPoint);
2135             }
2136         }
2137     }
2138 }
2139
2140 void RenderBlockFlow::clipOutFloatingObjects(RenderBlock& rootBlock, const PaintInfo* paintInfo, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock)
2141 {
2142     if (m_floatingObjects) {
2143         const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
2144         auto end = floatingObjectSet.end();
2145         for (auto it = floatingObjectSet.begin(); it != end; ++it) {
2146             FloatingObject* floatingObject = it->get();
2147             LayoutRect floatBox(offsetFromRootBlock.width() + xPositionForFloatIncludingMargin(floatingObject),
2148                 offsetFromRootBlock.height() + yPositionForFloatIncludingMargin(floatingObject),
2149                 floatingObject->renderer().width(), floatingObject->renderer().height());
2150             rootBlock.flipForWritingMode(floatBox);
2151             floatBox.move(rootBlockPhysicalPosition.x(), rootBlockPhysicalPosition.y());
2152             paintInfo->context->clipOut(snappedIntRect(floatBox));
2153         }
2154     }
2155 }
2156
2157 void RenderBlockFlow::createFloatingObjects()
2158 {
2159     m_floatingObjects = std::make_unique<FloatingObjects>(*this);
2160 }
2161
2162 void RenderBlockFlow::removeFloatingObjects()
2163 {
2164     if (!m_floatingObjects)
2165         return;
2166
2167     markSiblingsWithFloatsForLayout();
2168
2169     m_floatingObjects->clear();
2170 }
2171
2172 FloatingObject* RenderBlockFlow::insertFloatingObject(RenderBox& floatBox)
2173 {
2174     ASSERT(floatBox.isFloating());
2175
2176     // Create the list of special objects if we don't aleady have one
2177     if (!m_floatingObjects)
2178         createFloatingObjects();
2179     else {
2180         // Don't insert the floatingObject again if it's already in the list
2181         const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
2182         auto it = floatingObjectSet.find<RenderBox&, FloatingObjectHashTranslator>(floatBox);
2183         if (it != floatingObjectSet.end())
2184             return it->get();
2185     }
2186
2187     // Create the special floatingObject entry & append it to the list
2188
2189     std::unique_ptr<FloatingObject> floatingObject = FloatingObject::create(floatBox);
2190     
2191     // Our location is irrelevant if we're unsplittable or no pagination is in effect.
2192     // Just go ahead and lay out the float.
2193     bool isChildRenderBlock = floatBox.isRenderBlock();
2194     if (isChildRenderBlock && !floatBox.needsLayout() && view().layoutState()->pageLogicalHeightChanged())
2195         floatBox.setChildNeedsLayout(MarkOnlyThis);
2196             
2197     bool needsBlockDirectionLocationSetBeforeLayout = isChildRenderBlock && view().layoutState()->needsBlockDirectionLocationSetBeforeLayout();
2198     if (!needsBlockDirectionLocationSetBeforeLayout || isWritingModeRoot()) // We are unsplittable if we're a block flow root.
2199         floatBox.layoutIfNeeded();
2200     else {
2201         floatBox.updateLogicalWidth();
2202         floatBox.computeAndSetBlockDirectionMargins(this);
2203     }
2204
2205     setLogicalWidthForFloat(floatingObject.get(), logicalWidthForChild(floatBox) + marginStartForChild(floatBox) + marginEndForChild(floatBox));
2206
2207     return m_floatingObjects->add(WTF::move(floatingObject));
2208 }
2209
2210 void RenderBlockFlow::removeFloatingObject(RenderBox& floatBox)
2211 {
2212     if (m_floatingObjects) {
2213         const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
2214         auto it = floatingObjectSet.find<RenderBox&, FloatingObjectHashTranslator>(floatBox);
2215         if (it != floatingObjectSet.end()) {
2216             FloatingObject* floatingObject = it->get();
2217             if (childrenInline()) {
2218                 LayoutUnit logicalTop = logicalTopForFloat(floatingObject);
2219                 LayoutUnit logicalBottom = logicalBottomForFloat(floatingObject);
2220
2221                 // Fix for https://bugs.webkit.org/show_bug.cgi?id=54995.
2222                 if (logicalBottom < 0 || logicalBottom < logicalTop || logicalTop == LayoutUnit::max())
2223                     logicalBottom = LayoutUnit::max();
2224                 else {
2225                     // Special-case zero- and less-than-zero-height floats: those don't touch
2226                     // the line that they're on, but it still needs to be dirtied. This is
2227                     // accomplished by pretending they have a height of 1.
2228                     logicalBottom = std::max(logicalBottom, logicalTop + 1);
2229                 }
2230                 if (floatingObject->originatingLine()) {
2231                     if (!selfNeedsLayout()) {
2232                         ASSERT(&floatingObject->originatingLine()->renderer() == this);
2233                         floatingObject->originatingLine()->markDirty();
2234                     }
2235 #if !ASSERT_DISABLED
2236                     floatingObject->setOriginatingLine(0);
2237 #endif
2238                 }
2239                 markLinesDirtyInBlockRange(0, logicalBottom);
2240             }
2241             m_floatingObjects->remove(floatingObject);
2242         }
2243     }
2244 }
2245
2246 void RenderBlockFlow::removeFloatingObjectsBelow(FloatingObject* lastFloat, int logicalOffset)
2247 {
2248     if (!containsFloats())
2249         return;
2250     
2251     const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
2252     FloatingObject* curr = floatingObjectSet.last().get();
2253     while (curr != lastFloat && (!curr->isPlaced() || logicalTopForFloat(curr) >= logicalOffset)) {
2254         m_floatingObjects->remove(curr);
2255         if (floatingObjectSet.isEmpty())
2256             break;
2257         curr = floatingObjectSet.last().get();
2258     }
2259 }
2260
2261 LayoutUnit RenderBlockFlow::logicalLeftOffsetForPositioningFloat(LayoutUnit logicalTop, LayoutUnit fixedOffset, bool applyTextIndent, LayoutUnit* heightRemaining) const
2262 {
2263     LayoutUnit offset = fixedOffset;
2264     if (m_floatingObjects && m_floatingObjects->hasLeftObjects())
2265         offset = m_floatingObjects->logicalLeftOffsetForPositioningFloat(fixedOffset, logicalTop, heightRemaining);
2266     return adjustLogicalLeftOffsetForLine(offset, applyTextIndent);
2267 }
2268
2269 LayoutUnit RenderBlockFlow::logicalRightOffsetForPositioningFloat(LayoutUnit logicalTop, LayoutUnit fixedOffset, bool applyTextIndent, LayoutUnit* heightRemaining) const
2270 {
2271     LayoutUnit offset = fixedOffset;
2272     if (m_floatingObjects && m_floatingObjects->hasRightObjects())
2273         offset = m_floatingObjects->logicalRightOffsetForPositioningFloat(fixedOffset, logicalTop, heightRemaining);
2274     return adjustLogicalRightOffsetForLine(offset, applyTextIndent);
2275 }
2276
2277 LayoutPoint RenderBlockFlow::computeLogicalLocationForFloat(const FloatingObject* floatingObject, LayoutUnit logicalTopOffset)
2278 {
2279     RenderBox& childBox = floatingObject->renderer();
2280     LayoutUnit logicalLeftOffset = logicalLeftOffsetForContent(logicalTopOffset); // Constant part of left offset.
2281     LayoutUnit logicalRightOffset = logicalRightOffsetForContent(logicalTopOffset); // Constant part of right offset.
2282
2283     LayoutUnit floatLogicalWidth = std::min(logicalWidthForFloat(floatingObject), logicalRightOffset - logicalLeftOffset); // The width we look for.
2284
2285     LayoutUnit floatLogicalLeft;
2286
2287     bool insideFlowThread = flowThreadContainingBlock();
2288     bool isInitialLetter = childBox.style().styleType() == FIRST_LETTER && childBox.style().initialLetterDrop() > 0;
2289     
2290     if (isInitialLetter) {
2291         int letterClearance = lowestInitialLetterLogicalBottom() - logicalTopOffset;
2292         if (letterClearance > 0) {
2293             logicalTopOffset += letterClearance;
2294             setLogicalHeight(logicalHeight() + letterClearance);
2295         }
2296     }
2297     
2298     if (childBox.style().floating() == LeftFloat) {
2299         LayoutUnit heightRemainingLeft = 1;
2300         LayoutUnit heightRemainingRight = 1;
2301         floatLogicalLeft = logicalLeftOffsetForPositioningFloat(logicalTopOffset, logicalLeftOffset, false, &heightRemainingLeft);
2302         while (logicalRightOffsetForPositioningFloat(logicalTopOffset, logicalRightOffset, false, &heightRemainingRight) - floatLogicalLeft < floatLogicalWidth) {
2303             logicalTopOffset += std::min(heightRemainingLeft, heightRemainingRight);
2304             floatLogicalLeft = logicalLeftOffsetForPositioningFloat(logicalTopOffset, logicalLeftOffset, false, &heightRemainingLeft);
2305             if (insideFlowThread) {
2306                 // Have to re-evaluate all of our offsets, since they may have changed.
2307                 logicalRightOffset = logicalRightOffsetForContent(logicalTopOffset); // Constant part of right offset.
2308                 logicalLeftOffset = logicalLeftOffsetForContent(logicalTopOffset); // Constant part of left offset.
2309                 floatLogicalWidth = std::min(logicalWidthForFloat(floatingObject), logicalRightOffset - logicalLeftOffset);
2310             }
2311         }
2312         floatLogicalLeft = std::max(logicalLeftOffset - borderAndPaddingLogicalLeft(), floatLogicalLeft);
2313     } else {
2314         LayoutUnit heightRemainingLeft = 1;
2315         LayoutUnit heightRemainingRight = 1;
2316         floatLogicalLeft = logicalRightOffsetForPositioningFloat(logicalTopOffset, logicalRightOffset, false, &heightRemainingRight);
2317         while (floatLogicalLeft - logicalLeftOffsetForPositioningFloat(logicalTopOffset, logicalLeftOffset, false, &heightRemainingLeft) < floatLogicalWidth) {
2318             logicalTopOffset += std::min(heightRemainingLeft, heightRemainingRight);
2319             floatLogicalLeft = logicalRightOffsetForPositioningFloat(logicalTopOffset, logicalRightOffset, false, &heightRemainingRight);
2320             if (insideFlowThread) {
2321                 // Have to re-evaluate all of our offsets, since they may have changed.
2322                 logicalRightOffset = logicalRightOffsetForContent(logicalTopOffset); // Constant part of right offset.
2323                 logicalLeftOffset = logicalLeftOffsetForContent(logicalTopOffset); // Constant part of left offset.
2324                 floatLogicalWidth = std::min(logicalWidthForFloat(floatingObject), logicalRightOffset - logicalLeftOffset);
2325             }
2326         }
2327         // Use the original width of the float here, since the local variable
2328         // |floatLogicalWidth| was capped to the available line width. See
2329         // fast/block/float/clamped-right-float.html.
2330         floatLogicalLeft -= logicalWidthForFloat(floatingObject);
2331     }
2332     
2333     if (isInitialLetter) {
2334         const RenderStyle& style = firstLineStyle();
2335         const FontMetrics& fontMetrics = style.fontMetrics();
2336         if (fontMetrics.hasCapHeight()) {
2337             LayoutUnit heightOfLine = lineHeight(true, isHorizontalWritingMode() ? HorizontalLine : VerticalLine, PositionOfInteriorLineBoxes);
2338             LayoutUnit beforeMarginBorderPadding = childBox.borderAndPaddingBefore() + childBox.marginBefore();
2339             
2340             // Make an adjustment to align with the cap height of a theoretical block line.
2341             LayoutUnit adjustment = fontMetrics.ascent() + (heightOfLine - fontMetrics.height()) / 2 - fontMetrics.capHeight() - beforeMarginBorderPadding;
2342             logicalTopOffset += adjustment;
2343            
2344             // For sunken and raised caps, we have to make some adjustments. Test if we're sunken or raised (dropHeightDelta will be
2345             // positive for raised and negative for sunken).
2346             int dropHeightDelta = childBox.style().initialLetterHeight() - childBox.style().initialLetterDrop();
2347             
2348             // If we're sunken, the float needs to shift down but lines still need to avoid it. In order to do that we increase the float's margin.
2349             if (dropHeightDelta < 0) {
2350                 LayoutUnit marginTopIncrease = -dropHeightDelta * heightOfLine;
2351                 childBox.setMarginBefore(childBox.marginTop() + marginTopIncrease);
2352             }
2353             
2354             // If we're raised, then we actually have to grow the height of the block, since the lines have to be pushed down as though we're placing
2355             // empty lines beside the first letter.
2356             if (dropHeightDelta > 0)
2357                 setLogicalHeight(logicalHeight() + dropHeightDelta * heightOfLine);
2358         }
2359     }
2360     
2361     return LayoutPoint(floatLogicalLeft, logicalTopOffset);
2362 }
2363
2364 bool RenderBlockFlow::positionNewFloats()
2365 {
2366     if (!m_floatingObjects)
2367         return false;
2368
2369     const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
2370     if (floatingObjectSet.isEmpty())
2371         return false;
2372
2373     // If all floats have already been positioned, then we have no work to do.
2374     if (floatingObjectSet.last()->isPlaced())
2375         return false;
2376
2377     // Move backwards through our floating object list until we find a float that has
2378     // already been positioned. Then we'll be able to move forward, positioning all of
2379     // the new floats that need it.
2380     auto it = floatingObjectSet.end();
2381     --it; // Go to last item.
2382     auto begin = floatingObjectSet.begin();
2383     FloatingObject* lastPlacedFloatingObject = 0;
2384     while (it != begin) {
2385         --it;
2386         if ((*it)->isPlaced()) {
2387             lastPlacedFloatingObject = it->get();
2388             ++it;
2389             break;
2390         }
2391     }
2392
2393     LayoutUnit logicalTop = logicalHeight();
2394     
2395     // The float cannot start above the top position of the last positioned float.
2396     if (lastPlacedFloatingObject)
2397         logicalTop = std::max(logicalTopForFloat(lastPlacedFloatingObject), logicalTop);
2398
2399     auto end = floatingObjectSet.end();
2400     // Now walk through the set of unpositioned floats and place them.
2401     for (; it != end; ++it) {
2402         FloatingObject* floatingObject = it->get();
2403         // The containing block is responsible for positioning floats, so if we have floats in our
2404         // list that come from somewhere else, do not attempt to position them.
2405         if (floatingObject->renderer().containingBlock() != this)
2406             continue;
2407
2408         RenderBox& childBox = floatingObject->renderer();
2409
2410         LayoutUnit childLogicalLeftMargin = style().isLeftToRightDirection() ? marginStartForChild(childBox) : marginEndForChild(childBox);
2411
2412         LayoutRect oldRect = childBox.frameRect();
2413
2414         if (childBox.style().clear() & CLEFT)
2415             logicalTop = std::max(lowestFloatLogicalBottom(FloatingObject::FloatLeft), logicalTop);
2416         if (childBox.style().clear() & CRIGHT)
2417             logicalTop = std::max(lowestFloatLogicalBottom(FloatingObject::FloatRight), logicalTop);
2418
2419         LayoutPoint floatLogicalLocation = computeLogicalLocationForFloat(floatingObject, logicalTop);
2420
2421         setLogicalLeftForFloat(floatingObject, floatLogicalLocation.x());
2422
2423         setLogicalLeftForChild(childBox, floatLogicalLocation.x() + childLogicalLeftMargin);
2424         setLogicalTopForChild(childBox, floatLogicalLocation.y() + marginBeforeForChild(childBox));
2425
2426         estimateRegionRangeForBoxChild(childBox);
2427
2428         LayoutState* layoutState = view().layoutState();
2429         bool isPaginated = layoutState->isPaginated();
2430         if (isPaginated && !childBox.needsLayout())
2431             childBox.markForPaginationRelayoutIfNeeded();
2432         
2433         childBox.layoutIfNeeded();
2434
2435         if (isPaginated) {
2436             // If we are unsplittable and don't fit, then we need to move down.
2437             // We include our margins as part of the unsplittable area.
2438             LayoutUnit newLogicalTop = adjustForUnsplittableChild(childBox, floatLogicalLocation.y(), true);
2439             
2440             // See if we have a pagination strut that is making us move down further.
2441             // Note that an unsplittable child can't also have a pagination strut, so this is
2442             // exclusive with the case above.
2443             RenderBlock* childBlock = is<RenderBlock>(childBox) ? &downcast<RenderBlock>(childBox) : nullptr;
2444             if (childBlock && childBlock->paginationStrut()) {
2445                 newLogicalTop += childBlock->paginationStrut();
2446                 childBlock->setPaginationStrut(0);
2447             }
2448             
2449             if (newLogicalTop != floatLogicalLocation.y()) {
2450                 floatingObject->setPaginationStrut(newLogicalTop - floatLogicalLocation.y());
2451
2452                 floatLogicalLocation = computeLogicalLocationForFloat(floatingObject, newLogicalTop);
2453                 setLogicalLeftForFloat(floatingObject, floatLogicalLocation.x());
2454
2455                 setLogicalLeftForChild(childBox, floatLogicalLocation.x() + childLogicalLeftMargin);
2456                 setLogicalTopForChild(childBox, floatLogicalLocation.y() + marginBeforeForChild(childBox));
2457         
2458                 if (childBlock)
2459                     childBlock->setChildNeedsLayout(MarkOnlyThis);
2460                 childBox.layoutIfNeeded();
2461             }
2462
2463             if (updateRegionRangeForBoxChild(childBox)) {
2464                 childBox.setNeedsLayout(MarkOnlyThis);
2465                 childBox.layoutIfNeeded();
2466             }
2467         }
2468
2469         setLogicalTopForFloat(floatingObject, floatLogicalLocation.y());
2470
2471         setLogicalHeightForFloat(floatingObject, logicalHeightForChildForFragmentation(childBox) + marginBeforeForChild(childBox) + marginAfterForChild(childBox));
2472
2473         m_floatingObjects->addPlacedObject(floatingObject);
2474
2475 #if ENABLE(CSS_SHAPES)
2476         if (ShapeOutsideInfo* shapeOutside = childBox.shapeOutsideInfo())
2477             shapeOutside->setReferenceBoxLogicalSize(logicalSizeForChild(childBox));
2478 #endif
2479         // If the child moved, we have to repaint it.
2480         if (childBox.checkForRepaintDuringLayout())
2481             childBox.repaintDuringLayoutIfMoved(oldRect);
2482     }
2483     return true;
2484 }
2485
2486 void RenderBlockFlow::clearFloats(EClear clear)
2487 {
2488     positionNewFloats();
2489     // set y position
2490     LayoutUnit newY = 0;
2491     switch (clear) {
2492     case CLEFT:
2493         newY = lowestFloatLogicalBottom(FloatingObject::FloatLeft);
2494         break;
2495     case CRIGHT:
2496         newY = lowestFloatLogicalBottom(FloatingObject::FloatRight);
2497         break;
2498     case CBOTH:
2499         newY = lowestFloatLogicalBottom();
2500         break;
2501     default:
2502         break;
2503     }
2504     if (height() < newY)
2505         setLogicalHeight(newY);
2506 }
2507
2508 LayoutUnit RenderBlockFlow::logicalLeftFloatOffsetForLine(LayoutUnit logicalTop, LayoutUnit fixedOffset, LayoutUnit logicalHeight) const
2509 {
2510     if (m_floatingObjects && m_floatingObjects->hasLeftObjects())
2511         return m_floatingObjects->logicalLeftOffset(fixedOffset, logicalTop, logicalHeight);
2512
2513     return fixedOffset;
2514 }
2515
2516 LayoutUnit RenderBlockFlow::logicalRightFloatOffsetForLine(LayoutUnit logicalTop, LayoutUnit fixedOffset, LayoutUnit logicalHeight) const
2517 {
2518     if (m_floatingObjects && m_floatingObjects->hasRightObjects())
2519         return m_floatingObjects->logicalRightOffset(fixedOffset, logicalTop, logicalHeight);
2520
2521     return fixedOffset;
2522 }
2523
2524 LayoutUnit RenderBlockFlow::nextFloatLogicalBottomBelow(LayoutUnit logicalHeight) const
2525 {
2526     if (!m_floatingObjects)
2527         return logicalHeight;
2528
2529     return m_floatingObjects->findNextFloatLogicalBottomBelow(logicalHeight);
2530 }
2531
2532 LayoutUnit RenderBlockFlow::nextFloatLogicalBottomBelowForBlock(LayoutUnit logicalHeight) const
2533 {
2534     if (!m_floatingObjects)
2535         return logicalHeight;
2536
2537     return m_floatingObjects->findNextFloatLogicalBottomBelowForBlock(logicalHeight);
2538 }
2539
2540 LayoutUnit RenderBlockFlow::lowestFloatLogicalBottom(FloatingObject::Type floatType) const
2541 {
2542     if (!m_floatingObjects)
2543         return 0;
2544     LayoutUnit lowestFloatBottom = 0;
2545     const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
2546     auto end = floatingObjectSet.end();
2547     for (auto it = floatingObjectSet.begin(); it != end; ++it) {
2548         FloatingObject* floatingObject = it->get();
2549         if (floatingObject->isPlaced() && floatingObject->type() & floatType)
2550             lowestFloatBottom = std::max(lowestFloatBottom, logicalBottomForFloat(floatingObject));
2551     }
2552     return lowestFloatBottom;
2553 }
2554
2555 LayoutUnit RenderBlockFlow::lowestInitialLetterLogicalBottom() const
2556 {
2557     if (!m_floatingObjects)
2558         return 0;
2559     LayoutUnit lowestFloatBottom = 0;
2560     const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
2561     auto end = floatingObjectSet.end();
2562     for (auto it = floatingObjectSet.begin(); it != end; ++it) {
2563         FloatingObject* floatingObject = it->get();
2564         if (floatingObject->isPlaced() && floatingObject->renderer().style().styleType() == FIRST_LETTER && floatingObject->renderer().style().initialLetterDrop() > 0)
2565             lowestFloatBottom = std::max(lowestFloatBottom, logicalBottomForFloat(floatingObject));
2566     }
2567     return lowestFloatBottom;
2568 }
2569
2570 LayoutUnit RenderBlockFlow::addOverhangingFloats(RenderBlockFlow& child, bool makeChildPaintOtherFloats)
2571 {
2572     // Prevent floats from being added to the canvas by the root element, e.g., <html>.
2573     if (child.hasOverflowClip() || !child.containsFloats() || child.isRoot() || child.isWritingModeRoot() || child.isRenderFlowThread() || child.isRenderRegion())
2574         return 0;
2575
2576     LayoutUnit childLogicalTop = child.logicalTop();
2577     LayoutUnit childLogicalLeft = child.logicalLeft();
2578     LayoutUnit lowestFloatLogicalBottom = 0;
2579
2580     // Floats that will remain the child's responsibility to paint should factor into its
2581     // overflow.
2582     auto childEnd = child.m_floatingObjects->set().end();
2583     for (auto childIt = child.m_floatingObjects->set().begin(); childIt != childEnd; ++childIt) {
2584         FloatingObject* floatingObject = childIt->get();
2585         LayoutUnit floatLogicalBottom = std::min(logicalBottomForFloat(floatingObject), LayoutUnit::max() - childLogicalTop);
2586         LayoutUnit logicalBottom = childLogicalTop + floatLogicalBottom;
2587         lowestFloatLogicalBottom = std::max(lowestFloatLogicalBottom, logicalBottom);
2588
2589         if (logicalBottom > logicalHeight()) {
2590             // If the object is not in the list, we add it now.
2591             if (!containsFloat(floatingObject->renderer())) {
2592                 LayoutSize offset = isHorizontalWritingMode() ? LayoutSize(-childLogicalLeft, -childLogicalTop) : LayoutSize(-childLogicalTop, -childLogicalLeft);
2593                 bool shouldPaint = false;
2594
2595                 // The nearest enclosing layer always paints the float (so that zindex and stacking
2596                 // behaves properly). We always want to propagate the desire to paint the float as
2597                 // far out as we can, to the outermost block that overlaps the float, stopping only
2598                 // if we hit a self-painting layer boundary.
2599                 if (floatingObject->renderer().enclosingFloatPaintingLayer() == enclosingFloatPaintingLayer()) {
2600                     floatingObject->setShouldPaint(false);
2601                     shouldPaint = true;
2602                 }
2603                 // We create the floating object list lazily.
2604                 if (!m_floatingObjects)
2605                     createFloatingObjects();
2606
2607                 m_floatingObjects->add(floatingObject->copyToNewContainer(offset, shouldPaint, true));
2608             }
2609         } else {
2610             if (makeChildPaintOtherFloats && !floatingObject->shouldPaint() && !floatingObject->renderer().hasSelfPaintingLayer()
2611                 && floatingObject->renderer().isDescendantOf(&child) && floatingObject->renderer().enclosingFloatPaintingLayer() == child.enclosingFloatPaintingLayer()) {
2612                 // The float is not overhanging from this block, so if it is a descendant of the child, the child should
2613                 // paint it (the other case is that it is intruding into the child), unless it has its own layer or enclosing
2614                 // layer.
2615                 // If makeChildPaintOtherFloats is false, it means that the child must already know about all the floats
2616                 // it should paint.
2617                 floatingObject->setShouldPaint(true);
2618             }
2619             
2620             // Since the float doesn't overhang, it didn't get put into our list. We need to go ahead and add its overflow in to the
2621             // child now.
2622             if (floatingObject->isDescendant())
2623                 child.addOverflowFromChild(&floatingObject->renderer(), LayoutSize(xPositionForFloatIncludingMargin(floatingObject), yPositionForFloatIncludingMargin(floatingObject)));
2624         }
2625     }
2626     return lowestFloatLogicalBottom;
2627 }
2628
2629 bool RenderBlockFlow::hasOverhangingFloat(RenderBox& renderer)
2630 {
2631     if (!m_floatingObjects || !parent())
2632         return false;
2633
2634     const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
2635     auto it = floatingObjectSet.find<RenderBox&, FloatingObjectHashTranslator>(renderer);
2636     if (it == floatingObjectSet.end())
2637         return false;
2638
2639     return logicalBottomForFloat(it->get()) > logicalHeight();
2640 }
2641
2642 void RenderBlockFlow::addIntrudingFloats(RenderBlockFlow* prev, LayoutUnit logicalLeftOffset, LayoutUnit logicalTopOffset)
2643 {
2644     ASSERT(!avoidsFloats());
2645
2646     // If the parent or previous sibling doesn't have any floats to add, don't bother.
2647     if (!prev->m_floatingObjects)
2648         return;
2649
2650     logicalLeftOffset += marginLogicalLeft();
2651
2652     const FloatingObjectSet& prevSet = prev->m_floatingObjects->set();
2653     auto prevEnd = prevSet.end();
2654     for (auto prevIt = prevSet.begin(); prevIt != prevEnd; ++prevIt) {
2655         FloatingObject* floatingObject = prevIt->get();
2656         if (logicalBottomForFloat(floatingObject) > logicalTopOffset) {
2657             if (!m_floatingObjects || !m_floatingObjects->set().contains<FloatingObject&, FloatingObjectHashTranslator>(*floatingObject)) {
2658                 // We create the floating object list lazily.
2659                 if (!m_floatingObjects)
2660                     createFloatingObjects();
2661
2662                 // Applying the child's margin makes no sense in the case where the child was passed in.
2663                 // since this margin was added already through the modification of the |logicalLeftOffset| variable
2664                 // above. |logicalLeftOffset| will equal the margin in this case, so it's already been taken
2665                 // into account. Only apply this code if prev is the parent, since otherwise the left margin
2666                 // will get applied twice.
2667                 LayoutSize offset = isHorizontalWritingMode()
2668                     ? LayoutSize(logicalLeftOffset - (prev != parent() ? prev->marginLeft() : LayoutUnit()), logicalTopOffset)
2669                     : LayoutSize(logicalTopOffset, logicalLeftOffset - (prev != parent() ? prev->marginTop() : LayoutUnit()));
2670
2671                 m_floatingObjects->add(floatingObject->copyToNewContainer(offset));
2672             }
2673         }
2674     }
2675 }
2676
2677 void RenderBlockFlow::markAllDescendantsWithFloatsForLayout(RenderBox* floatToRemove, bool inLayout)
2678 {
2679     if (!everHadLayout() && !containsFloats())
2680         return;
2681
2682     MarkingBehavior markParents = inLayout ? MarkOnlyThis : MarkContainingBlockChain;
2683     setChildNeedsLayout(markParents);
2684
2685     if (floatToRemove)
2686         removeFloatingObject(*floatToRemove);
2687
2688     if (childrenInline())
2689         return;
2690
2691     // Iterate over our children and mark them as needed.
2692     for (auto& block : childrenOfType<RenderBlock>(*this)) {
2693         if (!floatToRemove && block.isFloatingOrOutOfFlowPositioned())
2694             continue;
2695         if (!is<RenderBlockFlow>(block)) {
2696             if (block.shrinkToAvoidFloats() && block.everHadLayout())
2697                 block.setChildNeedsLayout(markParents);
2698             continue;
2699         }
2700         auto& blockFlow = downcast<RenderBlockFlow>(block);
2701         if ((floatToRemove ? blockFlow.containsFloat(*floatToRemove) : blockFlow.containsFloats()) || blockFlow.shrinkToAvoidFloats())
2702             blockFlow.markAllDescendantsWithFloatsForLayout(floatToRemove, inLayout);
2703     }
2704 }
2705
2706 void RenderBlockFlow::markSiblingsWithFloatsForLayout(RenderBox* floatToRemove)
2707 {
2708     if (!m_floatingObjects)
2709         return;
2710
2711     const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
2712     auto end = floatingObjectSet.end();
2713
2714     for (RenderObject* next = nextSibling(); next; next = next->nextSibling()) {
2715         if (!is<RenderBlockFlow>(*next) || next->isFloatingOrOutOfFlowPositioned() || downcast<RenderBlockFlow>(*next).avoidsFloats())
2716             continue;
2717
2718         RenderBlockFlow& nextBlock = downcast<RenderBlockFlow>(*next);
2719         for (auto it = floatingObjectSet.begin(); it != end; ++it) {
2720             RenderBox& floatingBox = (*it)->renderer();
2721             if (floatToRemove && &floatingBox != floatToRemove)
2722                 continue;
2723             if (nextBlock.containsFloat(floatingBox))
2724                 nextBlock.markAllDescendantsWithFloatsForLayout(&floatingBox);
2725         }
2726     }
2727 }
2728
2729 LayoutPoint RenderBlockFlow::flipFloatForWritingModeForChild(const FloatingObject* child, const LayoutPoint& point) const
2730 {
2731     if (!style().isFlippedBlocksWritingMode())
2732         return point;
2733     
2734     // This is similar to RenderBox::flipForWritingModeForChild. We have to subtract out our left/top offsets twice, since
2735     // it's going to get added back in. We hide this complication here so that the calling code looks normal for the unflipped
2736     // case.
2737     if (isHorizontalWritingMode())
2738         return LayoutPoint(point.x(), point.y() + height() - child->renderer().height() - 2 * yPositionForFloatIncludingMargin(child));
2739     return LayoutPoint(point.x() + width() - child->renderer().width() - 2 * xPositionForFloatIncludingMargin(child), point.y());
2740 }
2741
2742 LayoutUnit RenderBlockFlow::getClearDelta(RenderBox& child, LayoutUnit logicalTop)
2743 {
2744     // There is no need to compute clearance if we have no floats.
2745     if (!containsFloats())
2746         return 0;
2747     
2748     // At least one float is present. We need to perform the clearance computation.
2749     bool clearSet = child.style().clear() != CNONE;
2750     LayoutUnit logicalBottom = 0;
2751     switch (child.style().clear()) {
2752     case CNONE:
2753         break;
2754     case CLEFT:
2755         logicalBottom = lowestFloatLogicalBottom(FloatingObject::FloatLeft);
2756         break;
2757     case CRIGHT:
2758         logicalBottom = lowestFloatLogicalBottom(FloatingObject::FloatRight);
2759         break;
2760     case CBOTH:
2761         logicalBottom = lowestFloatLogicalBottom();
2762         break;
2763     }
2764
2765     // We also clear floats if we are too big to sit on the same line as a float (and wish to avoid floats by default).
2766     LayoutUnit result = clearSet ? std::max<LayoutUnit>(0, logicalBottom - logicalTop) : LayoutUnit();
2767     if (!result && child.avoidsFloats()) {
2768         LayoutUnit newLogicalTop = logicalTop;
2769         while (true) {
2770             LayoutUnit availableLogicalWidthAtNewLogicalTopOffset = availableLogicalWidthForLine(newLogicalTop, false, logicalHeightForChild(child));
2771             if (availableLogicalWidthAtNewLogicalTopOffset == availableLogicalWidthForContent(newLogicalTop))
2772                 return newLogicalTop - logicalTop;
2773
2774             RenderRegion* region = regionAtBlockOffset(logicalTopForChild(child));
2775             LayoutRect borderBox = child.borderBoxRectInRegion(region, DoNotCacheRenderBoxRegionInfo);
2776             LayoutUnit childLogicalWidthAtOldLogicalTopOffset = isHorizontalWritingMode() ? borderBox.width() : borderBox.height();
2777
2778             // FIXME: None of this is right for perpendicular writing-mode children.
2779             LayoutUnit childOldLogicalWidth = child.logicalWidth();
2780             LayoutUnit childOldMarginLeft = child.marginLeft();
2781             LayoutUnit childOldMarginRight = child.marginRight();
2782             LayoutUnit childOldLogicalTop = child.logicalTop();
2783
2784             child.setLogicalTop(newLogicalTop);
2785             child.updateLogicalWidth();
2786             region = regionAtBlockOffset(logicalTopForChild(child));
2787             borderBox = child.borderBoxRectInRegion(region, DoNotCacheRenderBoxRegionInfo);
2788             LayoutUnit childLogicalWidthAtNewLogicalTopOffset = isHorizontalWritingMode() ? borderBox.width() : borderBox.height();
2789
2790             child.setLogicalTop(childOldLogicalTop);
2791             child.setLogicalWidth(childOldLogicalWidth);
2792             child.setMarginLeft(childOldMarginLeft);
2793             child.setMarginRight(childOldMarginRight);
2794             
2795             if (childLogicalWidthAtNewLogicalTopOffset <= availableLogicalWidthAtNewLogicalTopOffset) {
2796                 // Even though we may not be moving, if the logical width did shrink because of the presence of new floats, then
2797                 // we need to force a relayout as though we shifted. This happens because of the dynamic addition of overhanging floats
2798                 // from previous siblings when negative margins exist on a child (see the addOverhangingFloats call at the end of collapseMargins).
2799                 if (childLogicalWidthAtOldLogicalTopOffset != childLogicalWidthAtNewLogicalTopOffset)
2800                     child.setChildNeedsLayout(MarkOnlyThis);
2801                 return newLogicalTop - logicalTop;
2802             }
2803
2804             newLogicalTop = nextFloatLogicalBottomBelowForBlock(newLogicalTop);
2805             ASSERT(newLogicalTop >= logicalTop);
2806             if (newLogicalTop < logicalTop)
2807                 break;
2808         }
2809         ASSERT_NOT_REACHED();
2810     }
2811     return result;
2812 }
2813
2814 bool RenderBlockFlow::hitTestFloats(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset)
2815 {
2816     if (!m_floatingObjects)
2817         return false;
2818
2819     LayoutPoint adjustedLocation = accumulatedOffset;
2820     if (is<RenderView>(*this))
2821         adjustedLocation += toLayoutSize(downcast<RenderView>(*this).frameView().scrollPosition());
2822
2823     const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
2824     auto begin = floatingObjectSet.begin();
2825     for (auto it = floatingObjectSet.end(); it != begin;) {
2826         --it;
2827         FloatingObject* floatingObject = it->get();
2828         if (floatingObject->shouldPaint() && !floatingObject->renderer().hasSelfPaintingLayer()) {
2829             LayoutUnit xOffset = xPositionForFloatIncludingMargin(floatingObject) - floatingObject->renderer().x();
2830             LayoutUnit yOffset = yPositionForFloatIncludingMargin(floatingObject) - floatingObject->renderer().y();
2831             LayoutPoint childPoint = flipFloatForWritingModeForChild(floatingObject, adjustedLocation + LayoutSize(xOffset, yOffset));
2832             if (floatingObject->renderer().hitTest(request, result, locationInContainer, childPoint)) {
2833                 updateHitTestResult(result, locationInContainer.point() - toLayoutSize(childPoint));
2834                 return true;
2835             }
2836         }
2837     }
2838
2839     return false;
2840 }
2841
2842 bool RenderBlockFlow::hitTestInlineChildren(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction hitTestAction)
2843 {
2844     ASSERT(childrenInline());
2845
2846     if (auto simpleLineLayout = this->simpleLineLayout())
2847         return SimpleLineLayout::hitTestFlow(*this, *simpleLineLayout, request, result, locationInContainer, accumulatedOffset, hitTestAction);
2848
2849     return m_lineBoxes.hitTest(this, request, result, locationInContainer, accumulatedOffset, hitTestAction);
2850 }
2851
2852 void RenderBlockFlow::adjustForBorderFit(LayoutUnit x, LayoutUnit& left, LayoutUnit& right) const
2853 {
2854     if (style().visibility() != VISIBLE)
2855         return;
2856
2857     // We don't deal with relative positioning.  Our assumption is that you shrink to fit the lines without accounting
2858     // for either overflow or translations via relative positioning.
2859     if (childrenInline()) {
2860         const_cast<RenderBlockFlow&>(*this).ensureLineBoxes();
2861
2862         for (auto box = firstRootBox(); box; box = box->nextRootBox()) {
2863             if (box->firstChild())
2864                 left = std::min(left, x + LayoutUnit(box->firstChild()->x()));
2865             if (box->lastChild())
2866                 right = std::max(right, x + LayoutUnit(ceilf(box->lastChild()->logicalRight())));
2867         }
2868     } else {
2869         for (RenderBox* obj = firstChildBox(); obj; obj = obj->nextSiblingBox()) {
2870             if (!obj->isFloatingOrOutOfFlowPositioned()) {
2871                 if (is<RenderBlockFlow>(*obj) && !obj->hasOverflowClip())
2872                     downcast<RenderBlockFlow>(*obj).adjustForBorderFit(x + obj->x(), left, right);
2873                 else if (obj->style().visibility() == VISIBLE) {
2874                     // We are a replaced element or some kind of non-block-flow object.
2875                     left = std::min(left, x + obj->x());
2876                     right = std::max(right, x + obj->x() + obj->width());
2877                 }
2878             }
2879         }
2880     }
2881
2882     if (m_floatingObjects) {
2883         const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
2884         auto end = floatingObjectSet.end();
2885         for (auto it = floatingObjectSet.begin(); it != end; ++it) {
2886             FloatingObject* r = it->get();
2887             // Only examine the object if our m_shouldPaint flag is set.
2888             if (r->shouldPaint()) {
2889                 LayoutUnit floatLeft = xPositionForFloatIncludingMargin(r) - r->renderer().x();
2890                 LayoutUnit floatRight = floatLeft + r->renderer().width();
2891                 left = std::min(left, floatLeft);
2892                 right = std::max(right, floatRight);
2893             }
2894         }
2895     }
2896 }
2897
2898 void RenderBlockFlow::fitBorderToLinesIfNeeded()
2899 {
2900     if (style().borderFit() == BorderFitBorder || hasOverrideWidth())
2901         return;
2902
2903     // Walk any normal flow lines to snugly fit.
2904     LayoutUnit left = LayoutUnit::max();
2905     LayoutUnit right = LayoutUnit::min();
2906     LayoutUnit oldWidth = contentWidth();
2907     adjustForBorderFit(0, left, right);
2908     
2909     // Clamp to our existing edges. We can never grow. We only shrink.
2910     LayoutUnit leftEdge = borderLeft() + paddingLeft();
2911     LayoutUnit rightEdge = leftEdge + oldWidth;
2912     left = std::min(rightEdge, std::max(leftEdge, left));
2913     right = std::max(leftEdge, std::min(rightEdge, right));
2914     
2915     LayoutUnit newContentWidth = right - left;
2916     if (newContentWidth == oldWidth)
2917         return;
2918     
2919     setOverrideLogicalContentWidth(newContentWidth);
2920     layoutBlock(false);
2921     clearOverrideLogicalContentWidth();
2922 }
2923
2924 void RenderBlockFlow::markLinesDirtyInBlockRange(LayoutUnit logicalTop, LayoutUnit logicalBottom, RootInlineBox* highest)
2925 {
2926     if (logicalTop >= logicalBottom)
2927         return;
2928
2929     // Floats currently affect the choice whether to use simple line layout path.
2930     if (m_simpleLineLayout) {
2931         invalidateLineLayoutPath();
2932         return;
2933     }
2934
2935     RootInlineBox* lowestDirtyLine = lastRootBox();
2936     RootInlineBox* afterLowest = lowestDirtyLine;
2937     while (lowestDirtyLine && lowestDirtyLine->lineBottomWithLeading() >= logicalBottom && logicalBottom < LayoutUnit::max()) {
2938         afterLowest = lowestDirtyLine;
2939         lowestDirtyLine = lowestDirtyLine->prevRootBox();
2940     }
2941
2942     while (afterLowest && afterLowest != highest && (afterLowest->lineBottomWithLeading() >= logicalTop || afterLowest->lineBottomWithLeading() < 0)) {
2943         afterLowest->markDirty();
2944         afterLowest = afterLowest->prevRootBox();
2945     }
2946 }
2947
2948 int RenderBlockFlow::firstLineBaseline() const
2949 {
2950     if (isWritingModeRoot() && !isRubyRun())
2951         return -1;
2952
2953     if (!childrenInline())
2954         return RenderBlock::firstLineBaseline();
2955
2956     if (!hasLines())
2957         return -1;
2958
2959     if (auto simpleLineLayout = this->simpleLineLayout())
2960         return SimpleLineLayout::computeFlowFirstLineBaseline(*this, *simpleLineLayout);
2961
2962     ASSERT(firstRootBox());
2963     return firstRootBox()->logicalTop() + firstLineStyle().fontMetrics().ascent(firstRootBox()->baselineType());
2964 }
2965
2966 int RenderBlockFlow::inlineBlockBaseline(LineDirectionMode lineDirection) const
2967 {
2968     if (isWritingModeRoot() && !isRubyRun())
2969         return -1;
2970
2971     if (!childrenInline())
2972         return RenderBlock::inlineBlockBaseline(lineDirection);
2973
2974     if (!hasLines()) {
2975         if (!hasLineIfEmpty())
2976             return -1;
2977         const FontMetrics& fontMetrics = firstLineStyle().fontMetrics();
2978         return fontMetrics.ascent()
2979              + (lineHeight(true, lineDirection, PositionOfInteriorLineBoxes) - fontMetrics.height()) / 2
2980              + (lineDirection == HorizontalLine ? borderTop() + paddingTop() : borderRight() + paddingRight());
2981     }
2982
2983     if (auto simpleLineLayout = this->simpleLineLayout())
2984         return SimpleLineLayout::computeFlowLastLineBaseline(*this, *simpleLineLayout);
2985
2986     bool isFirstLine = lastRootBox() == firstRootBox();
2987     const RenderStyle& style = isFirstLine ? firstLineStyle() : this->style();
2988     return lastRootBox()->logicalTop() + style.fontMetrics().ascent(lastRootBox()->baselineType());
2989 }
2990
2991 GapRects RenderBlockFlow::inlineSelectionGaps(RenderBlock& rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
2992     LayoutUnit& lastLogicalTop, LayoutUnit& lastLogicalLeft, LayoutUnit& lastLogicalRight, const LogicalSelectionOffsetCaches& cache, const PaintInfo* paintInfo)
2993 {
2994     ASSERT(!m_simpleLineLayout);
2995
2996     GapRects result;
2997
2998     bool containsStart = selectionState() == SelectionStart || selectionState() == SelectionBoth;
2999
3000     if (!hasLines()) {
3001         if (containsStart) {
3002             // Go ahead and update our lastLogicalTop to be the bottom of the block.  <hr>s or empty blocks with height can trip this
3003             // case.
3004             lastLogicalTop = blockDirectionOffset(rootBlock, offsetFromRootBlock) + logicalHeight();
3005             lastLogicalLeft = logicalLeftSelectionOffset(rootBlock, logicalHeight(), cache);
3006             lastLogicalRight = logicalRightSelectionOffset(rootBlock, logicalHeight(), cache);
3007         }
3008         return result;
3009     }
3010
3011     RootInlineBox* lastSelectedLine = 0;
3012     RootInlineBox* curr;
3013     for (curr = firstRootBox(); curr && !curr->hasSelectedChildren(); curr = curr->nextRootBox()) { }
3014
3015     // Now paint the gaps for the lines.
3016     for (; curr && curr->hasSelectedChildren(); curr = curr->nextRootBox()) {
3017         LayoutUnit selTop =  curr->selectionTopAdjustedForPrecedingBlock();
3018         LayoutUnit selHeight = curr->selectionHeightAdjustedForPrecedingBlock();
3019
3020         if (!containsStart && !lastSelectedLine &&
3021             selectionState() != SelectionStart && selectionState() != SelectionBoth)
3022             result.uniteCenter(blockSelectionGap(rootBlock, rootBlockPhysicalPosition, offsetFromRootBlock, lastLogicalTop, lastLogicalLeft, lastLogicalRight, selTop, cache, paintInfo));
3023         
3024         LayoutRect logicalRect(curr->logicalLeft(), selTop, curr->logicalWidth(), selTop + selHeight);
3025         logicalRect.move(isHorizontalWritingMode() ? offsetFromRootBlock : offsetFromRootBlock.transposedSize());
3026         LayoutRect physicalRect = rootBlock.logicalRectToPhysicalRect(rootBlockPhysicalPosition, logicalRect);
3027         if (!paintInfo || (isHorizontalWritingMode() && physicalRect.y() < paintInfo->rect.maxY() && physicalRect.maxY() > paintInfo->rect.y())
3028             || (!isHorizontalWritingMode() && physicalRect.x() < paintInfo->rect.maxX() && physicalRect.maxX() > paintInfo->rect.x()))
3029             result.unite(curr->lineSelectionGap(rootBlock, rootBlockPhysicalPosition, offsetFromRootBlock, selTop, selHeight, cache, paintInfo));
3030
3031         lastSelectedLine = curr;
3032     }
3033
3034     if (containsStart && !lastSelectedLine)
3035         // VisibleSelection must start just after our last line.
3036         lastSelectedLine = lastRootBox();
3037
3038     if (lastSelectedLine && selectionState() != SelectionEnd && selectionState() != SelectionBoth) {
3039         // Go ahead and update our lastY to be the bottom of the last selected line.
3040         lastLogicalTop = blockDirectionOffset(rootBlock, offsetFromRootBlock) + lastSelectedLine->selectionBottom();
3041         lastLogicalLeft = logicalLeftSelectionOffset(rootBlock, lastSelectedLine->selectionBottom(), cache);
3042         lastLogicalRight = logicalRightSelectionOffset(rootBlock, lastSelectedLine->selectionBottom(), cache);
3043     }
3044     return result;
3045 }
3046
3047 void RenderBlockFlow::createRenderNamedFlowFragmentIfNeeded()
3048 {
3049     if (!document().cssRegionsEnabled() || renderNamedFlowFragment() || isRenderNamedFlowFragment())
3050         return;
3051
3052     // FIXME: Multicolumn regions not yet supported (http://dev.w3.org/csswg/css-regions/#multi-column-regions)
3053     if (style().isDisplayRegionType() && style().hasFlowFrom() && !style().specifiesColumns()) {
3054         RenderNamedFlowFragment* flowFragment = new RenderNamedFlowFragment(document(), RenderNamedFlowFragment::createStyle(style()));
3055         flowFragment->initializeStyle();
3056         setRenderNamedFlowFragment(flowFragment);
3057         addChild(renderNamedFlowFragment());
3058     }
3059 }
3060
3061 bool RenderBlockFlow::needsLayoutAfterRegionRangeChange() const
3062 {
3063     // A block without floats or that expands to enclose them won't need a relayout
3064     // after a region range change. There is no overflow content needing relayout
3065     // in the region chain because the region range can only shrink after the estimation.
3066     if (!containsFloats() || expandsToEncloseOverhangingFloats())
3067         return false;
3068
3069     return true;
3070 }
3071
3072 bool RenderBlockFlow::canHaveChildren() const
3073 {
3074     return !renderNamedFlowFragment() ? RenderBlock::canHaveChildren() : renderNamedFlowFragment()->canHaveChildren();
3075 }
3076
3077 bool RenderBlockFlow::canHaveGeneratedChildren() const
3078 {
3079     return !renderNamedFlowFragment() ? RenderBlock::canHaveGeneratedChildren() : renderNamedFlowFragment()->canHaveGeneratedChildren();
3080 }
3081
3082 bool RenderBlockFlow::namedFlowFragmentNeedsUpdate() const
3083 {
3084     if (!isRenderNamedFlowFragmentContainer())
3085         return false;
3086
3087     return hasRelativeLogicalHeight() && !isRenderView();
3088 }
3089
3090 void RenderBlockFlow::updateLogicalHeight()
3091 {
3092     RenderBlock::updateLogicalHeight();
3093
3094     if (renderNamedFlowFragment()) {
3095         renderNamedFlowFragment()->setLogicalHeight(std::max<LayoutUnit>(0, logicalHeight() - borderAndPaddingLogicalHeight()));
3096         renderNamedFlowFragment()->invalidateRegionIfNeeded();
3097     }
3098 }
3099
3100 void RenderBlockFlow::setRenderNamedFlowFragment(RenderNamedFlowFragment* flowFragment)
3101 {
3102     RenderBlockFlowRareData& rareData = ensureRareBlockFlowData();
3103     if (rareData.m_renderNamedFlowFragment)
3104         rareData.m_renderNamedFlowFragment->destroy();
3105     rareData.m_renderNamedFlowFragment = flowFragment;
3106 }
3107
3108 void RenderBlockFlow::setMultiColumnFlowThread(RenderMultiColumnFlowThread* flowThread)
3109 {
3110     if (flowThread || hasRareBlockFlowData()) {
3111         RenderBlockFlowRareData& rareData = ensureRareBlockFlowData();
3112         rareData.m_multiColumnFlowThread = flowThread;
3113     }
3114 }
3115
3116 static bool shouldCheckLines(const RenderBlockFlow& blockFlow)
3117 {
3118     return !blockFlow.isFloatingOrOutOfFlowPositioned() && blockFlow.style().height().isAuto();
3119 }
3120
3121 RootInlineBox* RenderBlockFlow::lineAtIndex(int i) const
3122 {
3123     ASSERT(i >= 0);
3124
3125     if (style().visibility() != VISIBLE)
3126         return nullptr;
3127
3128     if (childrenInline()) {
3129         for (auto box = firstRootBox(); box; box = box->nextRootBox()) {
3130             if (!i--)
3131                 return box;
3132         }
3133         return nullptr;
3134     }
3135
3136     for (auto& blockFlow : childrenOfType<RenderBlockFlow>(*this)) {
3137         if (!shouldCheckLines(blockFlow))
3138             continue;
3139         if (RootInlineBox* box = blockFlow.lineAtIndex(i))
3140             return box;
3141     }
3142
3143     return nullptr;
3144 }
3145
3146 int RenderBlockFlow::lineCount(const RootInlineBox* stopRootInlineBox, bool* found) const
3147 {
3148     if (style().visibility() != VISIBLE)
3149         return 0;
3150
3151     int count = 0;
3152
3153     if (childrenInline()) {
3154         if (auto simpleLineLayout = this->simpleLineLayout()) {
3155             ASSERT(!stopRootInlineBox);
3156             return simpleLineLayout->lineCount();
3157         }
3158         for (auto box = firstRootBox(); box; box = box->nextRootBox()) {
3159             count++;
3160             if (box == stopRootInlineBox) {
3161                 if (found)
3162                     *found = true;