Crash in WebCore::RenderElement::containingBlockForObjectInFlow
[WebKit-https.git] / Source / WebCore / rendering / RenderFlowThread.cpp
1 /*
2  * Copyright (C) 2011 Adobe Systems Incorporated. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1. Redistributions of source code must retain the above
9  *    copyright notice, this list of conditions and the following
10  *    disclaimer.
11  * 2. Redistributions in binary form must reproduce the above
12  *    copyright notice, this list of conditions and the following
13  *    disclaimer in the documentation and/or other materials
14  *    provided with the distribution.
15  * 
16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER "AS IS" AND ANY
17  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
21  * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
22  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
23  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
25  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
26  * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  */
29
30 #include "config.h"
31 #include "RenderFlowThread.h"
32
33 #include "FlowThreadController.h"
34 #include "HitTestRequest.h"
35 #include "HitTestResult.h"
36 #include "InlineElementBox.h"
37 #include "Node.h"
38 #include "PODIntervalTree.h"
39 #include "PaintInfo.h"
40 #include "RenderBoxRegionInfo.h"
41 #include "RenderInline.h"
42 #include "RenderLayer.h"
43 #include "RenderLayerCompositor.h"
44 #include "RenderNamedFlowFragment.h"
45 #include "RenderNamedFlowThread.h"
46 #include "RenderRegion.h"
47 #include "RenderTheme.h"
48 #include "RenderView.h"
49 #include "TransformState.h"
50 #include "WebKitNamedFlow.h"
51 #include <wtf/StackStats.h>
52
53 namespace WebCore {
54
55 RenderFlowThread::RenderFlowThread(Document& document, Ref<RenderStyle>&& style)
56     : RenderBlockFlow(document, WTFMove(style))
57     , m_previousRegionCount(0)
58     , m_autoLogicalHeightRegionsCount(0)
59     , m_currentRegionMaintainer(nullptr)
60     , m_regionsInvalidated(false)
61     , m_regionsHaveUniformLogicalWidth(true)
62     , m_regionsHaveUniformLogicalHeight(true)
63     , m_pageLogicalSizeChanged(false)
64     , m_layoutPhase(LayoutPhaseMeasureContent)
65     , m_needsTwoPhasesLayout(false)
66     , m_layersToRegionMappingsDirty(true)
67 {
68     setIsRenderFlowThread(true);
69     setFlowThreadState(InsideOutOfFlowThread);
70 }
71
72 Ref<RenderStyle> RenderFlowThread::createFlowThreadStyle(RenderStyle* parentStyle)
73 {
74     auto newStyle = RenderStyle::create();
75     newStyle.get().inheritFrom(parentStyle);
76     newStyle.get().setDisplay(BLOCK);
77     newStyle.get().setPosition(AbsolutePosition);
78     newStyle.get().setZIndex(0);
79     newStyle.get().setLeft(Length(0, Fixed));
80     newStyle.get().setTop(Length(0, Fixed));
81     newStyle.get().setWidth(Length(100, Percent));
82     newStyle.get().setHeight(Length(100, Percent));
83     newStyle.get().fontCascade().update(nullptr);
84     return newStyle;
85 }
86
87 void RenderFlowThread::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
88 {
89     RenderBlockFlow::styleDidChange(diff, oldStyle);
90
91     if (oldStyle && oldStyle->writingMode() != style().writingMode())
92         invalidateRegions();
93 }
94
95 void RenderFlowThread::removeFlowChildInfo(RenderObject* child)
96 {
97     if (is<RenderBlockFlow>(*child))
98         removeLineRegionInfo(downcast<RenderBlockFlow>(child));
99     if (is<RenderBox>(*child))
100         removeRenderBoxRegionInfo(downcast<RenderBox>(child));
101 }
102
103 void RenderFlowThread::removeRegionFromThread(RenderRegion* renderRegion)
104 {
105     ASSERT(renderRegion);
106     m_regionList.remove(renderRegion);
107 }
108
109 void RenderFlowThread::invalidateRegions(MarkingBehavior markingParents)
110 {
111     ASSERT(!inFinalLayoutPhase());
112
113     if (m_regionsInvalidated) {
114         ASSERT(selfNeedsLayout());
115         return;
116     }
117
118     m_regionRangeMap.clear();
119     m_breakBeforeToRegionMap.clear();
120     m_breakAfterToRegionMap.clear();
121     if (m_layerToRegionMap)
122         m_layerToRegionMap->clear();
123     if (m_regionToLayerListMap)
124         m_regionToLayerListMap->clear();
125     if (m_lineToRegionMap)
126         m_lineToRegionMap->clear();
127     m_layersToRegionMappingsDirty = true;
128     setNeedsLayout(markingParents);
129
130     m_regionsInvalidated = true;
131 }
132
133 void RenderFlowThread::validateRegions()
134 {
135     if (m_regionsInvalidated) {
136         m_regionsInvalidated = false;
137         m_regionsHaveUniformLogicalWidth = true;
138         m_regionsHaveUniformLogicalHeight = true;
139
140         if (hasRegions()) {
141             LayoutUnit previousRegionLogicalWidth = 0;
142             LayoutUnit previousRegionLogicalHeight = 0;
143             bool firstRegionVisited = false;
144             
145             for (auto& region : m_regionList) {
146                 ASSERT(!region->needsLayout() || region->isRenderRegionSet());
147
148                 region->deleteAllRenderBoxRegionInfo();
149
150                 // In the measure content layout phase we need to initialize the computedAutoHeight for auto-height regions.
151                 // See initializeRegionsComputedAutoHeight for the explanation.
152                 // Also, if we have auto-height regions we can't assume m_regionsHaveUniformLogicalHeight to be true in the first phase
153                 // because the auto-height regions don't have their height computed yet.
154                 if (inMeasureContentLayoutPhase() && region->hasAutoLogicalHeight()) {
155                     auto& namedFlowFragment = downcast<RenderNamedFlowFragment>(*region);
156                     namedFlowFragment.setComputedAutoHeight(namedFlowFragment.maxPageLogicalHeight());
157                     m_regionsHaveUniformLogicalHeight = false;
158                 }
159
160                 LayoutUnit regionLogicalWidth = region->pageLogicalWidth();
161                 LayoutUnit regionLogicalHeight = region->pageLogicalHeight();
162
163                 if (!firstRegionVisited)
164                     firstRegionVisited = true;
165                 else {
166                     if (m_regionsHaveUniformLogicalWidth && previousRegionLogicalWidth != regionLogicalWidth)
167                         m_regionsHaveUniformLogicalWidth = false;
168                     if (m_regionsHaveUniformLogicalHeight && previousRegionLogicalHeight != regionLogicalHeight)
169                         m_regionsHaveUniformLogicalHeight = false;
170                 }
171
172                 previousRegionLogicalWidth = regionLogicalWidth;
173             }
174
175             setRegionRangeForBox(this, m_regionList.first(), m_regionList.last());
176         }
177     }
178
179     updateLogicalWidth(); // Called to get the maximum logical width for the region.
180     updateRegionsFlowThreadPortionRect();
181 }
182
183 void RenderFlowThread::layout()
184 {
185     StackStats::LayoutCheckPoint layoutCheckPoint;
186
187     m_pageLogicalSizeChanged = m_regionsInvalidated && everHadLayout();
188
189     // In case this is the second pass of the measure content phase we need to update the auto-height regions to their initial value.
190     // If the region chain was invalidated this will happen anyway.
191     if (!m_regionsInvalidated && inMeasureContentLayoutPhase())
192         initializeRegionsComputedAutoHeight();
193
194     // This is the first phase of the layout and because we have auto-height regions we'll need a second
195     // pass to update the flow with the computed auto-height regions.
196     // It's also possible to need a secondary layout if the overflow computation invalidated the region chain (e.g. overflow: auto scrollbars
197     // shrunk some regions) so repropagation is required.
198     m_needsTwoPhasesLayout = (inMeasureContentLayoutPhase() && hasAutoLogicalHeightRegions()) || (inOverflowLayoutPhase() && m_regionsInvalidated);
199
200     validateRegions();
201
202     RenderBlockFlow::layout();
203
204     m_pageLogicalSizeChanged = false;
205
206     // If there are children layers in the RenderFlowThread then we need to make sure that the
207     // composited children layers will land in the right RenderRegions. Also, the parent RenderRegions
208     // will get RenderLayers and become composited as needed.
209     // Note that there's no need to do so for the inline multi-column as we are not moving layers into different
210     // containers, but just adjusting the position of the RenderLayerBacking.
211     if (!m_needsTwoPhasesLayout) {
212         // If we have layers that moved from one region to another, we trigger
213         // a composited layers rebuild in here to make sure that the regions will collect the right layers.
214         if (updateAllLayerToRegionMappings())
215             layer()->compositor().setCompositingLayersNeedRebuild();
216     }
217 }
218
219 bool RenderFlowThread::hasCompositingRegionDescendant() const
220 {
221     for (auto& region : m_regionList) {
222         if (downcast<RenderNamedFlowFragment>(*region).layerOwner().layer()->hasCompositingDescendant())
223             return true;
224     }
225
226     return false;
227 }
228
229 const RenderLayerList* RenderFlowThread::getLayerListForRegion(RenderNamedFlowFragment* region) const
230 {
231     ASSERT(m_regionToLayerListMap);
232     auto iterator = m_regionToLayerListMap->find(region);
233     return iterator == m_regionToLayerListMap->end() ? nullptr : &iterator->value;
234 }
235
236 RenderNamedFlowFragment* RenderFlowThread::regionForCompositedLayer(RenderLayer& childLayer) const
237 {
238     if (childLayer.renderer().fixedPositionedWithNamedFlowContainingBlock())
239         return nullptr;
240
241     if (childLayer.renderBox()) {
242         RenderRegion* startRegion = nullptr;
243         RenderRegion* endRegion = nullptr;
244         if (getRegionRangeForBox(childLayer.renderBox(), startRegion, endRegion))
245             return downcast<RenderNamedFlowFragment>(startRegion);
246     }
247
248     // FIXME: remove this when we'll have region ranges for inlines as well.
249     LayoutPoint flowThreadOffset = flooredLayoutPoint(childLayer.renderer().localToContainerPoint(LayoutPoint(), this, ApplyContainerFlip));
250     return downcast<RenderNamedFlowFragment>(regionAtBlockOffset(0, flipForWritingMode(isHorizontalWritingMode() ? flowThreadOffset.y() : flowThreadOffset.x()), true));
251 }
252
253 RenderNamedFlowFragment* RenderFlowThread::cachedRegionForCompositedLayer(RenderLayer& childLayer) const
254 {
255     if (!m_layerToRegionMap) {
256         ASSERT(needsLayout());
257         ASSERT(m_layersToRegionMappingsDirty);
258         return nullptr;
259     }
260
261     RenderNamedFlowFragment* namedFlowFragment = m_layerToRegionMap->get(&childLayer);
262     ASSERT(!namedFlowFragment || m_regionList.contains(namedFlowFragment));
263     return namedFlowFragment;
264 }
265
266 void RenderFlowThread::updateLayerToRegionMappings(RenderLayer& layer, LayerToRegionMap& layerToRegionMap, RegionToLayerListMap& regionToLayerListMap, bool& needsLayerUpdate)
267 {
268     RenderNamedFlowFragment* region = regionForCompositedLayer(layer);
269     if (!needsLayerUpdate) {
270         // Figure out if we moved this layer from a region to the other.
271         RenderNamedFlowFragment* previousRegion = cachedRegionForCompositedLayer(layer);
272         if (previousRegion != region)
273             needsLayerUpdate = true;
274     }
275
276     if (!region)
277         return;
278
279     layerToRegionMap.set(&layer, region);
280
281     auto iterator = regionToLayerListMap.find(region);
282     RenderLayerList& list = iterator == regionToLayerListMap.end() ? regionToLayerListMap.set(region, RenderLayerList()).iterator->value : iterator->value;
283     ASSERT(!list.contains(&layer));
284     list.append(&layer);
285 }
286
287 bool RenderFlowThread::updateAllLayerToRegionMappings()
288 {
289     if (!collectsGraphicsLayersUnderRegions())
290         return false;
291
292     // If the RenderFlowThread had a z-index layer update, then we need to update the composited layers too.
293     bool needsLayerUpdate = layer()->isDirtyRenderFlowThread() || m_layersToRegionMappingsDirty || !m_layerToRegionMap.get();
294     layer()->updateLayerListsIfNeeded();
295
296     LayerToRegionMap layerToRegionMap;
297     RegionToLayerListMap regionToLayerListMap;
298
299     RenderLayerList* lists[] = { layer()->negZOrderList(), layer()->normalFlowList(), layer()->posZOrderList() };
300     for (size_t listIndex = 0; listIndex < sizeof(lists) / sizeof(lists[0]); ++listIndex) {
301         if (RenderLayerList* list = lists[listIndex]) {
302             for (size_t i = 0, listSize = list->size(); i < listSize; ++i)
303                 updateLayerToRegionMappings(*list->at(i), layerToRegionMap, regionToLayerListMap, needsLayerUpdate);
304         }
305     }
306
307     if (needsLayerUpdate) {
308         if (!m_layerToRegionMap)
309             m_layerToRegionMap = std::make_unique<LayerToRegionMap>();
310         m_layerToRegionMap->swap(layerToRegionMap);
311
312         if (!m_regionToLayerListMap)
313             m_regionToLayerListMap = std::make_unique<RegionToLayerListMap>();
314         m_regionToLayerListMap->swap(regionToLayerListMap);
315     }
316
317     m_layersToRegionMappingsDirty = false;
318
319     return needsLayerUpdate;
320 }
321
322 bool RenderFlowThread::collectsGraphicsLayersUnderRegions() const
323 {
324     // We only need to map layers to regions for named flow threads.
325     // Multi-column threads are displayed on top of the regions and do not require
326     // distributing the layers.
327
328     return false;
329 }
330
331 void RenderFlowThread::updateLogicalWidth()
332 {
333     LayoutUnit logicalWidth = initialLogicalWidth();
334     for (auto& region : m_regionList) {
335         ASSERT(!region->needsLayout() || region->isRenderRegionSet());
336         logicalWidth = std::max(region->pageLogicalWidth(), logicalWidth);
337     }
338     setLogicalWidth(logicalWidth);
339
340     // If the regions have non-uniform logical widths, then insert inset information for the RenderFlowThread.
341     for (auto& region : m_regionList) {
342         LayoutUnit regionLogicalWidth = region->pageLogicalWidth();
343         LayoutUnit logicalLeft = style().direction() == LTR ? LayoutUnit() : logicalWidth - regionLogicalWidth;
344         region->setRenderBoxRegionInfo(this, logicalLeft, regionLogicalWidth, false);
345     }
346 }
347
348 void RenderFlowThread::computeLogicalHeight(LayoutUnit, LayoutUnit logicalTop, LogicalExtentComputedValues& computedValues) const
349 {
350     computedValues.m_position = logicalTop;
351     computedValues.m_extent = 0;
352
353     const LayoutUnit maxFlowSize = RenderFlowThread::maxLogicalHeight();
354     for (auto& region : m_regionList) {
355         ASSERT(!region->needsLayout() || region->isRenderRegionSet());
356
357         LayoutUnit distanceToMaxSize = maxFlowSize - computedValues.m_extent;
358         computedValues.m_extent += std::min(distanceToMaxSize, region->logicalHeightOfAllFlowThreadContent());
359
360         // If we reached the maximum size there's no point in going further.
361         if (computedValues.m_extent == maxFlowSize)
362             return;
363     }
364 }
365
366 bool RenderFlowThread::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction hitTestAction)
367 {
368     if (hitTestAction == HitTestBlockBackground)
369         return false;
370     return RenderBlockFlow::nodeAtPoint(request, result, locationInContainer, accumulatedOffset, hitTestAction);
371 }
372
373 bool RenderFlowThread::shouldRepaint(const LayoutRect& r) const
374 {
375     if (view().printing() || r.isEmpty())
376         return false;
377
378     return true;
379 }
380
381 void RenderFlowThread::repaintRectangleInRegions(const LayoutRect& repaintRect) const
382 {
383     if (!shouldRepaint(repaintRect) || !hasValidRegionInfo())
384         return;
385
386     LayoutStateDisabler layoutStateDisabler(view()); // We can't use layout state to repaint, since the regions are somewhere else.
387
388     for (auto& region : m_regionList)
389         region->repaintFlowThreadContent(repaintRect);
390 }
391
392 RenderRegion* RenderFlowThread::regionAtBlockOffset(const RenderBox* clampBox, LayoutUnit offset, bool extendLastRegion) const
393 {
394     ASSERT(!m_regionsInvalidated);
395
396     if (m_regionList.isEmpty())
397         return nullptr;
398
399     if (m_regionList.size() == 1 && extendLastRegion)
400         return m_regionList.first();
401
402     if (offset <= 0)
403         return clampBox ? clampBox->clampToStartAndEndRegions(m_regionList.first()) : m_regionList.first();
404
405     RegionSearchAdapter adapter(offset);
406     m_regionIntervalTree.allOverlapsWithAdapter<RegionSearchAdapter>(adapter);
407
408     // If no region was found, the offset is in the flow thread overflow.
409     // The last region will contain the offset if extendLastRegion is set or if the last region is a set.
410     if (!adapter.result() && (extendLastRegion || m_regionList.last()->isRenderRegionSet()))
411         return clampBox ? clampBox->clampToStartAndEndRegions(m_regionList.last()) : m_regionList.last();
412
413     RenderRegion* region = adapter.result();
414     if (!clampBox)
415         return region;
416     return region ? clampBox->clampToStartAndEndRegions(region) : nullptr;
417 }
418
419 LayoutPoint RenderFlowThread::adjustedPositionRelativeToOffsetParent(const RenderBoxModelObject& boxModelObject, const LayoutPoint& startPoint) const
420 {
421     LayoutPoint referencePoint = startPoint;
422     
423     const RenderBlock* objContainingBlock = boxModelObject.containingBlock();
424     // FIXME: This needs to be adapted for different writing modes inside the flow thread.
425     RenderRegion* startRegion = regionAtBlockOffset(objContainingBlock, referencePoint.y());
426     if (startRegion) {
427         // Take into account the offset coordinates of the region.
428         RenderBoxModelObject* startRegionBox = is<RenderNamedFlowFragment>(*startRegion) ? downcast<RenderBoxModelObject>(startRegion->parent()) : startRegion;
429         RenderBoxModelObject* currObject = startRegionBox;
430         RenderBoxModelObject* currOffsetParent;
431         while ((currOffsetParent = currObject->offsetParent())) {
432             referencePoint.move(currObject->offsetLeft(), currObject->offsetTop());
433             
434             // Since we're looking for the offset relative to the body, we must also
435             // take into consideration the borders of the region's offsetParent.
436             if (is<RenderBox>(*currOffsetParent) && !currOffsetParent->isBody())
437                 referencePoint.move(downcast<RenderBox>(*currOffsetParent).borderLeft(), downcast<RenderBox>(*currOffsetParent).borderTop());
438             
439             currObject = currOffsetParent;
440         }
441         
442         // We need to check if any of this box's containing blocks start in a different region
443         // and if so, drop the object's top position (which was computed relative to its containing block
444         // and is no longer valid) and recompute it using the region in which it flows as reference.
445         bool wasComputedRelativeToOtherRegion = false;
446         while (objContainingBlock && !is<RenderView>(*objContainingBlock) && !objContainingBlock->isRenderNamedFlowThread()) {
447             // Check if this object is in a different region.
448             RenderRegion* parentStartRegion = nullptr;
449             RenderRegion* parentEndRegion = nullptr;
450             if (getRegionRangeForBox(objContainingBlock, parentStartRegion, parentEndRegion) && parentStartRegion != startRegion) {
451                 wasComputedRelativeToOtherRegion = true;
452                 break;
453             }
454             objContainingBlock = objContainingBlock->containingBlock();
455         }
456         
457         if (wasComputedRelativeToOtherRegion) {
458             if (is<RenderBox>(boxModelObject)) {
459                 // Use borderBoxRectInRegion to account for variations such as percentage margins.
460                 LayoutRect borderBoxRect = downcast<RenderBox>(boxModelObject).borderBoxRectInRegion(startRegion, RenderBox::DoNotCacheRenderBoxRegionInfo);
461                 referencePoint.move(borderBoxRect.location().x(), 0);
462             }
463             
464             // Get the logical top coordinate of the current object.
465             LayoutUnit top = 0;
466             if (is<RenderBlock>(boxModelObject))
467                 top = downcast<RenderBlock>(boxModelObject).offsetFromLogicalTopOfFirstPage();
468             else {
469                 if (boxModelObject.containingBlock())
470                     top = boxModelObject.containingBlock()->offsetFromLogicalTopOfFirstPage();
471                 
472                 if (is<RenderBox>(boxModelObject))
473                     top += downcast<RenderBox>(boxModelObject).topLeftLocation().y();
474                 else if (is<RenderInline>(boxModelObject))
475                     top -= downcast<RenderInline>(boxModelObject).borderTop();
476             }
477             
478             // Get the logical top of the region this object starts in
479             // and compute the object's top, relative to the region's top.
480             LayoutUnit regionLogicalTop = startRegion->pageLogicalTopForOffset(top);
481             LayoutUnit topRelativeToRegion = top - regionLogicalTop;
482             referencePoint.setY(startRegionBox->offsetTop() + topRelativeToRegion);
483             
484             // Since the top has been overriden, check if the
485             // relative/sticky positioning must be reconsidered.
486             if (boxModelObject.isRelPositioned())
487                 referencePoint.move(0, boxModelObject.relativePositionOffset().height());
488             else if (boxModelObject.isStickyPositioned())
489                 referencePoint.move(0, boxModelObject.stickyPositionOffset().height());
490         }
491         
492         // Since we're looking for the offset relative to the body, we must also
493         // take into consideration the borders of the region.
494         referencePoint.move(startRegionBox->borderLeft(), startRegionBox->borderTop());
495     }
496     
497     return referencePoint;
498 }
499
500 LayoutUnit RenderFlowThread::pageLogicalTopForOffset(LayoutUnit offset) const
501 {
502     RenderRegion* region = regionAtBlockOffset(0, offset, false);
503     return region ? region->pageLogicalTopForOffset(offset) : LayoutUnit();
504 }
505
506 LayoutUnit RenderFlowThread::pageLogicalWidthForOffset(LayoutUnit offset) const
507 {
508     RenderRegion* region = regionAtBlockOffset(0, offset, true);
509     return region ? region->pageLogicalWidth() : contentLogicalWidth();
510 }
511
512 LayoutUnit RenderFlowThread::pageLogicalHeightForOffset(LayoutUnit offset) const
513 {
514     RenderRegion* region = regionAtBlockOffset(0, offset, false);
515     if (!region)
516         return 0;
517
518     return region->pageLogicalHeight();
519 }
520
521 LayoutUnit RenderFlowThread::pageRemainingLogicalHeightForOffset(LayoutUnit offset, PageBoundaryRule pageBoundaryRule) const
522 {
523     RenderRegion* region = regionAtBlockOffset(0, offset, false);
524     if (!region)
525         return 0;
526
527     LayoutUnit pageLogicalTop = region->pageLogicalTopForOffset(offset);
528     LayoutUnit pageLogicalHeight = region->pageLogicalHeight();
529     LayoutUnit pageLogicalBottom = pageLogicalTop + pageLogicalHeight;
530     LayoutUnit remainingHeight = pageLogicalBottom - offset;
531     if (pageBoundaryRule == IncludePageBoundary) {
532         // If IncludePageBoundary is set, the line exactly on the top edge of a
533         // region will act as being part of the previous region.
534         remainingHeight = intMod(remainingHeight, pageLogicalHeight);
535     }
536     return remainingHeight;
537 }
538
539 RenderRegion* RenderFlowThread::mapFromFlowToRegion(TransformState& transformState) const
540 {
541     if (!hasValidRegionInfo())
542         return nullptr;
543
544     RenderRegion* renderRegion = currentRegion();
545     if (!renderRegion) {
546         LayoutRect boxRect = transformState.mappedQuad().enclosingBoundingBox();
547         flipForWritingMode(boxRect);
548
549         LayoutPoint center = boxRect.center();
550         renderRegion = regionAtBlockOffset(this, isHorizontalWritingMode() ? center.y() : center.x(), true);
551         if (!renderRegion)
552             return nullptr;
553     }
554
555     LayoutRect flippedRegionRect(renderRegion->flowThreadPortionRect());
556     flipForWritingMode(flippedRegionRect);
557
558     transformState.move(renderRegion->contentBoxRect().location() - flippedRegionRect.location());
559
560     return renderRegion;
561 }
562
563 void RenderFlowThread::removeRenderBoxRegionInfo(RenderBox* box)
564 {
565     if (!hasRegions())
566         return;
567
568     // If the region chain was invalidated the next layout will clear the box information from all the regions.
569     if (m_regionsInvalidated) {
570         ASSERT(selfNeedsLayout());
571         return;
572     }
573
574     RenderRegion* startRegion = nullptr;
575     RenderRegion* endRegion = nullptr;
576     if (getRegionRangeForBox(box, startRegion, endRegion)) {
577         for (auto it = m_regionList.find(startRegion), end = m_regionList.end(); it != end; ++it) {
578             RenderRegion* region = *it;
579             region->removeRenderBoxRegionInfo(box);
580             if (region == endRegion)
581                 break;
582         }
583     }
584
585 #ifndef NDEBUG
586     // We have to make sure we did not leave any RenderBoxRegionInfo attached.
587     for (auto& region : m_regionList)
588         ASSERT(!region->renderBoxRegionInfo(box));
589 #endif
590
591     m_regionRangeMap.remove(box);
592 }
593
594 void RenderFlowThread::removeLineRegionInfo(const RenderBlockFlow* blockFlow)
595 {
596     if (!m_lineToRegionMap || blockFlow->lineLayoutPath() == SimpleLinesPath)
597         return;
598
599     for (RootInlineBox* curr = blockFlow->firstRootBox(); curr; curr = curr->nextRootBox()) {
600         if (m_lineToRegionMap->contains(curr))
601             m_lineToRegionMap->remove(curr);
602     }
603
604     ASSERT_WITH_SECURITY_IMPLICATION(checkLinesConsistency(blockFlow));
605 }
606
607 void RenderFlowThread::logicalWidthChangedInRegionsForBlock(const RenderBlock* block, bool& relayoutChildren)
608 {
609     if (!hasValidRegionInfo()) {
610         // FIXME: Remove once we stop laying out flow threads without regions.
611         // If we had regions but don't any more, relayout the children because the code below
612         // can't properly detect this scenario.
613         relayoutChildren |= previousRegionCountChanged();
614         return;
615     }
616
617     auto it = m_regionRangeMap.find(block);
618     if (it == m_regionRangeMap.end())
619         return;
620
621     RenderRegionRange& range = it->value;
622     bool rangeInvalidated = range.rangeInvalidated();
623     range.clearRangeInvalidated();
624
625     // If there will be a relayout anyway skip the next steps because they only verify
626     // the state of the ranges.
627     if (relayoutChildren)
628         return;
629
630     // Not necessary for the flow thread, since we already computed the correct info for it.
631     // If the regions have changed invalidate the children.
632     if (block == this) {
633         relayoutChildren = m_pageLogicalSizeChanged;
634         return;
635     }
636
637     RenderRegion* startRegion = nullptr;
638     RenderRegion* endRegion = nullptr;
639     if (!getRegionRangeForBox(block, startRegion, endRegion))
640         return;
641
642     for (auto it = m_regionList.find(startRegion), end = m_regionList.end(); it != end; ++it) {
643         RenderRegion* region = *it;
644         ASSERT(!region->needsLayout() || region->isRenderRegionSet());
645
646         // We have no information computed for this region so we need to do it.
647         std::unique_ptr<RenderBoxRegionInfo> oldInfo = region->takeRenderBoxRegionInfo(block);
648         if (!oldInfo) {
649             relayoutChildren = rangeInvalidated;
650             return;
651         }
652
653         LayoutUnit oldLogicalWidth = oldInfo->logicalWidth();
654         RenderBoxRegionInfo* newInfo = block->renderBoxRegionInfo(region);
655         if (!newInfo || newInfo->logicalWidth() != oldLogicalWidth) {
656             relayoutChildren = true;
657             return;
658         }
659
660         if (region == endRegion)
661             break;
662     }
663 }
664
665 LayoutUnit RenderFlowThread::contentLogicalWidthOfFirstRegion() const
666 {
667     RenderRegion* firstValidRegionInFlow = firstRegion();
668     if (!firstValidRegionInFlow)
669         return 0;
670     return isHorizontalWritingMode() ? firstValidRegionInFlow->contentWidth() : firstValidRegionInFlow->contentHeight();
671 }
672
673 LayoutUnit RenderFlowThread::contentLogicalHeightOfFirstRegion() const
674 {
675     RenderRegion* firstValidRegionInFlow = firstRegion();
676     if (!firstValidRegionInFlow)
677         return 0;
678     return isHorizontalWritingMode() ? firstValidRegionInFlow->contentHeight() : firstValidRegionInFlow->contentWidth();
679 }
680
681 LayoutUnit RenderFlowThread::contentLogicalLeftOfFirstRegion() const
682 {
683     RenderRegion* firstValidRegionInFlow = firstRegion();
684     if (!firstValidRegionInFlow)
685         return 0;
686     return isHorizontalWritingMode() ? firstValidRegionInFlow->flowThreadPortionRect().x() : firstValidRegionInFlow->flowThreadPortionRect().y();
687 }
688
689 RenderRegion* RenderFlowThread::firstRegion() const
690 {
691     if (!hasRegions())
692         return nullptr;
693     return m_regionList.first();
694 }
695
696 RenderRegion* RenderFlowThread::lastRegion() const
697 {
698     if (!hasRegions())
699         return nullptr;
700     return m_regionList.last();
701 }
702
703 void RenderFlowThread::clearRenderBoxRegionInfoAndCustomStyle(const RenderBox* box,
704     const RenderRegion* newStartRegion, const RenderRegion* newEndRegion,
705     const RenderRegion* oldStartRegion, const RenderRegion* oldEndRegion)
706 {
707     ASSERT(newStartRegion && newEndRegion && oldStartRegion && oldEndRegion);
708
709     bool insideOldRegionRange = false;
710     bool insideNewRegionRange = false;
711     for (auto& region : m_regionList) {
712         if (oldStartRegion == region)
713             insideOldRegionRange = true;
714         if (newStartRegion == region)
715             insideNewRegionRange = true;
716
717         if (!(insideOldRegionRange && insideNewRegionRange)) {
718             if (is<RenderNamedFlowFragment>(*region))
719                 downcast<RenderNamedFlowFragment>(*region).clearObjectStyleInRegion(box);
720             if (region->renderBoxRegionInfo(box))
721                 region->removeRenderBoxRegionInfo(box);
722         }
723
724         if (oldEndRegion == region)
725             insideOldRegionRange = false;
726         if (newEndRegion == region)
727             insideNewRegionRange = false;
728     }
729 }
730
731 void RenderFlowThread::setRegionRangeForBox(const RenderBox* box, RenderRegion* startRegion, RenderRegion* endRegion)
732 {
733     ASSERT(hasRegions());
734     ASSERT(startRegion && endRegion && startRegion->flowThread() == this && endRegion->flowThread() == this);
735
736     auto it = m_regionRangeMap.find(box);
737     if (it == m_regionRangeMap.end()) {
738         m_regionRangeMap.set(box, RenderRegionRange(startRegion, endRegion));
739         return;
740     }
741
742     // If nothing changed, just bail.
743     RenderRegionRange& range = it->value;
744     if (range.startRegion() == startRegion && range.endRegion() == endRegion)
745         return;
746
747     clearRenderBoxRegionInfoAndCustomStyle(box, startRegion, endRegion, range.startRegion(), range.endRegion());
748     range.setRange(startRegion, endRegion);
749 }
750
751 bool RenderFlowThread::hasCachedRegionRangeForBox(const RenderBox* box) const
752 {
753     ASSERT(box);
754
755     return m_regionRangeMap.contains(box);
756 }
757
758 bool RenderFlowThread::getRegionRangeForBoxFromCachedInfo(const RenderBox* box, RenderRegion*& startRegion, RenderRegion*& endRegion) const
759 {
760     ASSERT(box);
761     ASSERT(hasValidRegionInfo());
762     ASSERT((startRegion == nullptr) && (endRegion == nullptr));
763
764     auto it = m_regionRangeMap.find(box);
765     if (it != m_regionRangeMap.end()) {
766         const RenderRegionRange& range = it->value;
767         startRegion = range.startRegion();
768         endRegion = range.endRegion();
769         ASSERT(m_regionList.contains(startRegion) && m_regionList.contains(endRegion));
770         return true;
771     }
772
773     return false;
774 }
775
776 bool RenderFlowThread::getRegionRangeForBox(const RenderBox* box, RenderRegion*& startRegion, RenderRegion*& endRegion) const
777 {
778     ASSERT(box);
779
780     startRegion = endRegion = nullptr;
781     if (!hasValidRegionInfo()) // We clear the ranges when we invalidate the regions.
782         return false;
783
784     if (m_regionList.size() == 1) {
785         startRegion = endRegion = m_regionList.first();
786         return true;
787     }
788
789     if (getRegionRangeForBoxFromCachedInfo(box, startRegion, endRegion))
790         return true;
791
792     return false;
793 }
794
795 bool RenderFlowThread::computedRegionRangeForBox(const RenderBox* box, RenderRegion*& startRegion, RenderRegion*& endRegion) const
796 {
797     ASSERT(box);
798
799     startRegion = endRegion = nullptr;
800     if (!hasValidRegionInfo()) // We clear the ranges when we invalidate the regions.
801         return false;
802
803     if (getRegionRangeForBox(box, startRegion, endRegion))
804         return true;
805
806     // Search the region range using the information provided by the
807     // containing block chain.
808     RenderBox* cb = const_cast<RenderBox*>(box);
809     while (!cb->isRenderFlowThread()) {
810         InlineElementBox* boxWrapper = cb->inlineBoxWrapper();
811         if (boxWrapper && boxWrapper->root().containingRegion()) {
812             startRegion = endRegion = boxWrapper->root().containingRegion();
813             ASSERT(m_regionList.contains(startRegion));
814             return true;
815         }
816
817         // FIXME: Use the containingBlock() value once we patch all the layout systems to be region range aware
818         // (e.g. if we use containingBlock() the shadow controls of a video element won't get the range from the
819         // video box because it's not a block; they need to be patched separately).
820         ASSERT(cb->parent());
821         cb = &cb->parent()->enclosingBox();
822         ASSERT(cb);
823
824         // If a box doesn't have a cached region range it usually means the box belongs to a line so startRegion should be equal with endRegion.
825         // FIXME: Find the cases when this startRegion should not be equal with endRegion and make sure these boxes have cached region ranges.
826         if (hasCachedRegionRangeForBox(cb)) {
827             startRegion = endRegion = regionAtBlockOffset(cb, box->offsetFromLogicalTopOfFirstPage(), true);
828             return true;
829         }
830     }
831
832     ASSERT_NOT_REACHED();
833     return false;
834 }
835
836 bool RenderFlowThread::regionInRange(const RenderRegion* targetRegion, const RenderRegion* startRegion, const RenderRegion* endRegion) const
837 {
838     ASSERT(targetRegion);
839
840     for (auto it = m_regionList.find(const_cast<RenderRegion*>(startRegion)), end = m_regionList.end(); it != end; ++it) {
841         const RenderRegion* currRegion = *it;
842         if (targetRegion == currRegion)
843             return true;
844         if (currRegion == endRegion)
845             break;
846     }
847
848     return false;
849 }
850
851 bool RenderFlowThread::objectShouldFragmentInFlowRegion(const RenderObject* object, const RenderRegion* region) const
852 {
853     ASSERT(object);
854     ASSERT(region);
855     
856     RenderFlowThread* flowThread = object->flowThreadContainingBlock();
857     if (flowThread != this)
858         return false;
859
860     if (!m_regionList.contains(const_cast<RenderRegion*>(region)))
861         return false;
862     
863     RenderRegion* enclosingBoxStartRegion = nullptr;
864     RenderRegion* enclosingBoxEndRegion = nullptr;
865     // If the box has no range, do not check regionInRange. Boxes inside inlines do not get ranges.
866     // Instead, the containing RootInlineBox will abort when trying to paint inside the wrong region.
867     if (computedRegionRangeForBox(&object->enclosingBox(), enclosingBoxStartRegion, enclosingBoxEndRegion)
868         && !regionInRange(region, enclosingBoxStartRegion, enclosingBoxEndRegion))
869         return false;
870     
871     return object->isBox() || object->isRenderInline();
872 }
873
874 bool RenderFlowThread::objectInFlowRegion(const RenderObject* object, const RenderRegion* region) const
875 {
876     ASSERT(object);
877     ASSERT(region);
878
879     RenderFlowThread* flowThread = object->flowThreadContainingBlock();
880     if (flowThread != this)
881         return false;
882
883     if (!m_regionList.contains(const_cast<RenderRegion*>(region)))
884         return false;
885
886     RenderRegion* enclosingBoxStartRegion = nullptr;
887     RenderRegion* enclosingBoxEndRegion = nullptr;
888     if (!getRegionRangeForBox(&object->enclosingBox(), enclosingBoxStartRegion, enclosingBoxEndRegion))
889         return false;
890
891     if (!regionInRange(region, enclosingBoxStartRegion, enclosingBoxEndRegion))
892         return false;
893
894     if (object->isBox())
895         return true;
896
897     LayoutRect objectABBRect = object->absoluteBoundingBoxRect(true);
898     if (!objectABBRect.width())
899         objectABBRect.setWidth(1);
900     if (!objectABBRect.height())
901         objectABBRect.setHeight(1); 
902     if (objectABBRect.intersects(region->absoluteBoundingBoxRect(true)))
903         return true;
904
905     if (region == lastRegion()) {
906         // If the object does not intersect any of the enclosing box regions
907         // then the object is in last region.
908         for (auto it = m_regionList.find(enclosingBoxStartRegion), end = m_regionList.end(); it != end; ++it) {
909             const RenderRegion* currRegion = *it;
910             if (currRegion == region)
911                 break;
912             if (objectABBRect.intersects(currRegion->absoluteBoundingBoxRect(true)))
913                 return false;
914         }
915         return true;
916     }
917
918     return false;
919 }
920
921 #ifndef NDEBUG
922 bool RenderFlowThread::isAutoLogicalHeightRegionsCountConsistent() const
923 {
924     unsigned autoLogicalHeightRegions = 0;
925     for (const auto& region : m_regionList) {
926         if (region->hasAutoLogicalHeight())
927             autoLogicalHeightRegions++;
928     }
929
930     return autoLogicalHeightRegions == m_autoLogicalHeightRegionsCount;
931 }
932 #endif
933
934 #if !ASSERT_WITH_SECURITY_IMPLICATION_DISABLED
935 bool RenderFlowThread::checkLinesConsistency(const RenderBlockFlow* removedBlock) const
936 {
937     if (!m_lineToRegionMap)
938         return true;
939
940     for (auto& linePair : *m_lineToRegionMap.get()) {
941         const RootInlineBox* line = linePair.key;
942         RenderRegion* region = linePair.value;
943         if (&line->blockFlow() == removedBlock)
944             return false;
945         if (line->blockFlow().flowThreadState() == NotInsideFlowThread)
946             return false;
947         if (!m_regionList.contains(region))
948             return false;
949     }
950
951     return true;
952 }
953 #endif
954
955 void RenderFlowThread::clearLinesToRegionMap()
956 {
957     if (m_lineToRegionMap)
958         m_lineToRegionMap->clear();
959 }
960
961 void RenderFlowThread::deleteLines()
962 {
963     clearLinesToRegionMap();
964     RenderBlockFlow::deleteLines();
965 }
966
967 void RenderFlowThread::willBeDestroyed()
968 {
969     clearLinesToRegionMap();
970     RenderBlockFlow::willBeDestroyed();
971 }
972
973 // During the measure content layout phase of the named flow the regions are initialized with a height equal to their max-height.
974 // This way unforced breaks are automatically placed when a region is full and the content height/position correctly estimated.
975 // Also, the region where a forced break falls is exactly the region found at the forced break offset inside the flow content.
976 void RenderFlowThread::initializeRegionsComputedAutoHeight(RenderRegion* startRegion)
977 {
978     ASSERT(inMeasureContentLayoutPhase());
979     if (!hasAutoLogicalHeightRegions())
980         return;
981
982     for (auto regionIter = startRegion ? m_regionList.find(startRegion) : m_regionList.begin(), end = m_regionList.end(); regionIter != end; ++regionIter) {
983         RenderRegion& region = **regionIter;
984         if (region.hasAutoLogicalHeight()) {
985             auto& namedFlowFragment = downcast<RenderNamedFlowFragment>(region);
986             namedFlowFragment.setComputedAutoHeight(namedFlowFragment.maxPageLogicalHeight());
987         }
988     }
989 }
990
991 void RenderFlowThread::markAutoLogicalHeightRegionsForLayout()
992 {
993     ASSERT(hasAutoLogicalHeightRegions());
994
995     for (auto& region : m_regionList) {
996         if (!region->hasAutoLogicalHeight())
997             continue;
998
999         // FIXME: We need to find a way to avoid marking all the regions ancestors for layout
1000         // as we are already inside layout.
1001         region->setNeedsLayout();
1002     }
1003 }
1004
1005 void RenderFlowThread::markRegionsForOverflowLayoutIfNeeded()
1006 {
1007     if (!hasRegions())
1008         return;
1009
1010     for (auto& region : m_regionList)
1011         region->setNeedsSimplifiedNormalFlowLayout();
1012 }
1013
1014 void RenderFlowThread::updateRegionsFlowThreadPortionRect(const RenderRegion* lastRegionWithContent)
1015 {
1016     ASSERT(!lastRegionWithContent || (inMeasureContentLayoutPhase() && hasAutoLogicalHeightRegions()));
1017     LayoutUnit logicalHeight = 0;
1018     bool emptyRegionsSegment = false;
1019     // FIXME: Optimize not to clear the interval all the time. This implies manually managing the tree nodes lifecycle.
1020     m_regionIntervalTree.clear();
1021     for (auto& region : m_regionList) {
1022         // If we find an empty auto-height region, clear the computedAutoHeight value.
1023         if (emptyRegionsSegment && region->hasAutoLogicalHeight())
1024             downcast<RenderNamedFlowFragment>(*region).clearComputedAutoHeight();
1025
1026         LayoutUnit regionLogicalWidth = region->pageLogicalWidth();
1027         LayoutUnit regionLogicalHeight = std::min<LayoutUnit>(RenderFlowThread::maxLogicalHeight() - logicalHeight, region->logicalHeightOfAllFlowThreadContent());
1028
1029         LayoutRect regionRect(style().direction() == LTR ? LayoutUnit() : logicalWidth() - regionLogicalWidth, logicalHeight, regionLogicalWidth, regionLogicalHeight);
1030
1031         region->setFlowThreadPortionRect(isHorizontalWritingMode() ? regionRect : regionRect.transposedRect());
1032
1033         m_regionIntervalTree.add(RegionIntervalTree::createInterval(logicalHeight, logicalHeight + regionLogicalHeight, region));
1034
1035         logicalHeight += regionLogicalHeight;
1036
1037         // Once we find the last region with content the next regions are considered empty.
1038         if (lastRegionWithContent == region)
1039             emptyRegionsSegment = true;
1040     }
1041
1042     ASSERT(!lastRegionWithContent || emptyRegionsSegment);
1043 }
1044
1045 // Even if we require the break to occur at offsetBreakInFlowThread, because regions may have min/max-height values,
1046 // it is possible that the break will occur at a different offset than the original one required.
1047 // offsetBreakAdjustment measures the different between the requested break offset and the current break offset.
1048 bool RenderFlowThread::addForcedRegionBreak(const RenderBlock* block, LayoutUnit offsetBreakInFlowThread, RenderBox* breakChild, bool isBefore, LayoutUnit* offsetBreakAdjustment)
1049 {
1050     // We take breaks into account for height computation for auto logical height regions
1051     // only in the layout phase in which we lay out the flows threads unconstrained
1052     // and we use the content breaks to determine the computed auto height for
1053     // auto logical height regions.
1054     if (!inMeasureContentLayoutPhase())
1055         return false;
1056
1057     // Breaks can come before or after some objects. We need to track these objects, so that if we get
1058     // multiple breaks for the same object (for example because of multiple layouts on the same object),
1059     // we need to invalidate every other region after the old one and start computing from fresh.
1060     RenderBoxToRegionMap& mapToUse = isBefore ? m_breakBeforeToRegionMap : m_breakAfterToRegionMap;
1061     auto iter = mapToUse.find(breakChild);
1062     if (iter != mapToUse.end()) {
1063         auto regionIter = m_regionList.find(iter->value);
1064         ASSERT(regionIter != m_regionList.end());
1065         ASSERT((*regionIter)->hasAutoLogicalHeight());
1066         initializeRegionsComputedAutoHeight(*regionIter);
1067
1068         // We need to update the regions flow thread portion rect because we are going to process
1069         // a break on these regions.
1070         updateRegionsFlowThreadPortionRect();
1071     }
1072
1073     // Simulate a region break at offsetBreakInFlowThread. If it points inside an auto logical height region,
1074     // then it determines the region computed auto height.
1075     RenderRegion* region = regionAtBlockOffset(block, offsetBreakInFlowThread);
1076     if (!region)
1077         return false;
1078
1079     bool lastBreakAfterContent = breakChild == this;
1080     bool hasComputedAutoHeight = false;
1081
1082     LayoutUnit currentRegionOffsetInFlowThread = isHorizontalWritingMode() ? region->flowThreadPortionRect().y() : region->flowThreadPortionRect().x();
1083     LayoutUnit offsetBreakInCurrentRegion = offsetBreakInFlowThread - currentRegionOffsetInFlowThread;
1084
1085     if (region->hasAutoLogicalHeight()) {
1086         auto& namedFlowFragment = downcast<RenderNamedFlowFragment>(*region);
1087
1088         // A forced break can appear only in an auto-height region that didn't have a forced break before.
1089         // This ASSERT is a good-enough heuristic to verify the above condition.
1090         ASSERT(namedFlowFragment.maxPageLogicalHeight() == namedFlowFragment.computedAutoHeight());
1091
1092         mapToUse.set(breakChild, &namedFlowFragment);
1093
1094         hasComputedAutoHeight = true;
1095
1096         // Compute the region height pretending that the offsetBreakInCurrentRegion is the logicalHeight for the auto-height region.
1097         LayoutUnit regionComputedAutoHeight = namedFlowFragment.constrainContentBoxLogicalHeightByMinMax(offsetBreakInCurrentRegion, Nullopt);
1098
1099         // The new height of this region needs to be smaller than the initial value, the max height. A forced break is the only way to change the initial
1100         // height of an auto-height region besides content ending.
1101         ASSERT(regionComputedAutoHeight <= namedFlowFragment.maxPageLogicalHeight());
1102
1103         namedFlowFragment.setComputedAutoHeight(regionComputedAutoHeight);
1104
1105         currentRegionOffsetInFlowThread += regionComputedAutoHeight;
1106     } else
1107         currentRegionOffsetInFlowThread += isHorizontalWritingMode() ? region->flowThreadPortionRect().height() : region->flowThreadPortionRect().width();
1108
1109     // If the break was found inside an auto-height region its size changed so we need to recompute the flow thread portion rectangles.
1110     // Also, if this is the last break after the content we need to clear the computedAutoHeight value on the last empty regions.
1111     if (hasAutoLogicalHeightRegions() && lastBreakAfterContent)
1112         updateRegionsFlowThreadPortionRect(region);
1113     else if (hasComputedAutoHeight)
1114         updateRegionsFlowThreadPortionRect();
1115
1116     if (offsetBreakAdjustment)
1117         *offsetBreakAdjustment = std::max<LayoutUnit>(0, currentRegionOffsetInFlowThread - offsetBreakInFlowThread);
1118
1119     return hasComputedAutoHeight;
1120 }
1121
1122 void RenderFlowThread::incrementAutoLogicalHeightRegions()
1123 {
1124     if (!m_autoLogicalHeightRegionsCount)
1125         view().flowThreadController().incrementFlowThreadsWithAutoLogicalHeightRegions();
1126     ++m_autoLogicalHeightRegionsCount;
1127 }
1128
1129 void RenderFlowThread::decrementAutoLogicalHeightRegions()
1130 {
1131     ASSERT(m_autoLogicalHeightRegionsCount > 0);
1132     --m_autoLogicalHeightRegionsCount;
1133     if (!m_autoLogicalHeightRegionsCount)
1134         view().flowThreadController().decrementFlowThreadsWithAutoLogicalHeightRegions();
1135 }
1136
1137 void RenderFlowThread::collectLayerFragments(LayerFragments& layerFragments, const LayoutRect& layerBoundingBox, const LayoutRect& dirtyRect)
1138 {
1139     ASSERT(!m_regionsInvalidated);
1140     
1141     for (auto& region : m_regionList)
1142         region->collectLayerFragments(layerFragments, layerBoundingBox, dirtyRect);
1143 }
1144
1145 LayoutRect RenderFlowThread::fragmentsBoundingBox(const LayoutRect& layerBoundingBox)
1146 {
1147     ASSERT(!m_regionsInvalidated);
1148     
1149     LayoutRect result;
1150     for (auto& region : m_regionList) {
1151         LayerFragments fragments;
1152         region->collectLayerFragments(fragments, layerBoundingBox, LayoutRect::infiniteRect());
1153         for (const auto& fragment : fragments) {
1154             LayoutRect fragmentRect(layerBoundingBox);
1155             fragmentRect.intersect(fragment.paginationClip);
1156             fragmentRect.move(fragment.paginationOffset);
1157             result.unite(fragmentRect);
1158         }
1159     }
1160     
1161     return result;
1162 }
1163
1164 bool RenderFlowThread::hasCachedOffsetFromLogicalTopOfFirstRegion(const RenderBox* box) const
1165 {
1166     return m_boxesToOffsetMap.contains(box);
1167 }
1168
1169 LayoutUnit RenderFlowThread::cachedOffsetFromLogicalTopOfFirstRegion(const RenderBox* box) const
1170 {
1171     return m_boxesToOffsetMap.get(box);
1172 }
1173
1174 void RenderFlowThread::setOffsetFromLogicalTopOfFirstRegion(const RenderBox* box, LayoutUnit offset)
1175 {
1176     m_boxesToOffsetMap.set(box, offset);
1177 }
1178
1179 void RenderFlowThread::clearOffsetFromLogicalTopOfFirstRegion(const RenderBox* box)
1180 {
1181     ASSERT(m_boxesToOffsetMap.contains(box));
1182     m_boxesToOffsetMap.remove(box);
1183 }
1184
1185 const RenderBox* RenderFlowThread::currentActiveRenderBox() const
1186 {
1187     if (m_activeObjectsStack.isEmpty())
1188         return nullptr;
1189
1190     const RenderObject* currentObject = m_activeObjectsStack.last();
1191     return is<RenderBox>(*currentObject) ? downcast<RenderBox>(currentObject) : nullptr;
1192 }
1193
1194 void RenderFlowThread::pushFlowThreadLayoutState(const RenderObject& object)
1195 {
1196     m_activeObjectsStack.append(&object);
1197
1198     if (const RenderBox* currentBoxDescendant = currentActiveRenderBox()) {
1199         LayoutState* layoutState = currentBoxDescendant->view().layoutState();
1200         if (layoutState && layoutState->isPaginated()) {
1201             ASSERT(layoutState->m_renderer == currentBoxDescendant);
1202             LayoutSize offsetDelta = layoutState->m_layoutOffset - layoutState->m_pageOffset;
1203             setOffsetFromLogicalTopOfFirstRegion(currentBoxDescendant, currentBoxDescendant->isHorizontalWritingMode() ? offsetDelta.height() : offsetDelta.width());
1204         }
1205     }
1206 }
1207
1208 void RenderFlowThread::popFlowThreadLayoutState()
1209 {
1210     if (const RenderBox* currentBoxDescendant = currentActiveRenderBox()) {
1211         LayoutState* layoutState = currentBoxDescendant->view().layoutState();
1212         if (layoutState && layoutState->isPaginated())
1213             clearOffsetFromLogicalTopOfFirstRegion(currentBoxDescendant);
1214     }
1215
1216     m_activeObjectsStack.removeLast();
1217 }
1218
1219 LayoutUnit RenderFlowThread::offsetFromLogicalTopOfFirstRegion(const RenderBlock* currentBlock) const
1220 {
1221     // First check if we cached the offset for the block if it's an ancestor containing block of the box
1222     // being currently laid out.
1223     if (hasCachedOffsetFromLogicalTopOfFirstRegion(currentBlock))
1224         return cachedOffsetFromLogicalTopOfFirstRegion(currentBlock);
1225
1226     // As a last resort, take the slow path.
1227     LayoutRect blockRect(0, 0, currentBlock->width(), currentBlock->height());
1228     while (currentBlock && !is<RenderView>(*currentBlock) && !currentBlock->isRenderFlowThread()) {
1229         RenderBlock* containerBlock = currentBlock->containingBlock();
1230         ASSERT(containerBlock);
1231         if (!containerBlock)
1232             return 0;
1233         LayoutPoint currentBlockLocation = currentBlock->location();
1234
1235         if (containerBlock->style().writingMode() != currentBlock->style().writingMode()) {
1236             // We have to put the block rect in container coordinates
1237             // and we have to take into account both the container and current block flipping modes
1238             if (containerBlock->style().isFlippedBlocksWritingMode()) {
1239                 if (containerBlock->isHorizontalWritingMode())
1240                     blockRect.setY(currentBlock->height() - blockRect.maxY());
1241                 else
1242                     blockRect.setX(currentBlock->width() - blockRect.maxX());
1243             }
1244             currentBlock->flipForWritingMode(blockRect);
1245         }
1246         blockRect.moveBy(currentBlockLocation);
1247         currentBlock = containerBlock;
1248     }
1249
1250     return currentBlock->isHorizontalWritingMode() ? blockRect.y() : blockRect.x();
1251 }
1252
1253 void RenderFlowThread::RegionSearchAdapter::collectIfNeeded(const RegionInterval& interval)
1254 {
1255     if (m_result)
1256         return;
1257     if (interval.low() <= m_offset && interval.high() > m_offset)
1258         m_result = interval.data();
1259 }
1260
1261 void RenderFlowThread::mapLocalToContainer(const RenderLayerModelObject* repaintContainer, TransformState& transformState, MapCoordinatesFlags mode, bool* wasFixed) const
1262 {
1263     if (this == repaintContainer)
1264         return;
1265
1266     if (RenderRegion* region = mapFromFlowToRegion(transformState)) {
1267         // FIXME: The cast below is probably not the best solution, we may need to find a better way.
1268         const RenderObject* regionObject = static_cast<const RenderObject*>(region);
1269
1270         // If the repaint container is nullptr, we have to climb up to the RenderView, otherwise swap
1271         // it with the region's repaint container.
1272         repaintContainer = repaintContainer ? region->containerForRepaint() : nullptr;
1273
1274         if (RenderFlowThread* regionFlowThread = region->flowThreadContainingBlock()) {
1275             RenderRegion* startRegion = nullptr;
1276             RenderRegion* endRegion = nullptr;
1277             if (regionFlowThread->getRegionRangeForBox(region, startRegion, endRegion)) {
1278                 CurrentRenderRegionMaintainer regionMaintainer(*startRegion);
1279                 regionObject->mapLocalToContainer(repaintContainer, transformState, mode, wasFixed);
1280                 return;
1281             }
1282         }
1283
1284         regionObject->mapLocalToContainer(repaintContainer, transformState, mode, wasFixed);
1285     }
1286 }
1287
1288 // FIXME: Make this function faster. Walking the render tree is slow, better use a caching mechanism (e.g. |cachedOffsetFromLogicalTopOfFirstRegion|).
1289 LayoutRect RenderFlowThread::mapFromLocalToFlowThread(const RenderBox* box, const LayoutRect& localRect) const
1290 {
1291     LayoutRect boxRect = localRect;
1292
1293     while (box && box != this) {
1294         RenderBlock* containerBlock = box->containingBlock();
1295         ASSERT(containerBlock);
1296         if (!containerBlock)
1297             return LayoutRect();
1298         LayoutPoint currentBoxLocation = box->location();
1299
1300         if (containerBlock->style().writingMode() != box->style().writingMode())
1301             box->flipForWritingMode(boxRect);
1302
1303         boxRect.moveBy(currentBoxLocation);
1304         box = containerBlock;
1305     }
1306
1307     return boxRect;
1308 }
1309
1310 // FIXME: Make this function faster. Walking the render tree is slow, better use a caching mechanism (e.g. |cachedOffsetFromLogicalTopOfFirstRegion|).
1311 LayoutRect RenderFlowThread::mapFromFlowThreadToLocal(const RenderBox* box, const LayoutRect& rect) const
1312 {
1313     LayoutRect localRect = rect;
1314     if (box == this)
1315         return localRect;
1316
1317     RenderBlock* containerBlock = box->containingBlock();
1318     ASSERT(containerBlock);
1319     if (!containerBlock)
1320         return LayoutRect();
1321     localRect = mapFromFlowThreadToLocal(containerBlock, localRect);
1322
1323     LayoutPoint currentBoxLocation = box->location();
1324     localRect.moveBy(-currentBoxLocation);
1325
1326     if (containerBlock->style().writingMode() != box->style().writingMode())
1327         box->flipForWritingMode(localRect);
1328
1329     return localRect;
1330 }
1331
1332 void RenderFlowThread::flipForWritingModeLocalCoordinates(LayoutRect& rect) const
1333 {
1334     if (!style().isFlippedBlocksWritingMode())
1335         return;
1336     
1337     if (isHorizontalWritingMode())
1338         rect.setY(0 - rect.maxY());
1339     else
1340         rect.setX(0 - rect.maxX());
1341 }
1342
1343 void RenderFlowThread::addRegionsVisualEffectOverflow(const RenderBox* box)
1344 {
1345     RenderRegion* startRegion = nullptr;
1346     RenderRegion* endRegion = nullptr;
1347     if (!getRegionRangeForBox(box, startRegion, endRegion))
1348         return;
1349
1350     for (auto iter = m_regionList.find(startRegion), end = m_regionList.end(); iter != end; ++iter) {
1351         RenderRegion* region = *iter;
1352
1353         LayoutRect borderBox = box->borderBoxRectInRegion(region);
1354         borderBox = box->applyVisualEffectOverflow(borderBox);
1355         borderBox = region->rectFlowPortionForBox(box, borderBox);
1356
1357         region->addVisualOverflowForBox(box, borderBox);
1358         if (region == endRegion)
1359             break;
1360     }
1361 }
1362
1363 void RenderFlowThread::addRegionsVisualOverflowFromTheme(const RenderBlock* block)
1364 {
1365     RenderRegion* startRegion = nullptr;
1366     RenderRegion* endRegion = nullptr;
1367     if (!getRegionRangeForBox(block, startRegion, endRegion))
1368         return;
1369
1370     for (auto iter = m_regionList.find(startRegion), end = m_regionList.end(); iter != end; ++iter) {
1371         RenderRegion* region = *iter;
1372
1373         LayoutRect borderBox = block->borderBoxRectInRegion(region);
1374         borderBox = region->rectFlowPortionForBox(block, borderBox);
1375
1376         FloatRect inflatedRect = borderBox;
1377         block->theme().adjustRepaintRect(*block, inflatedRect);
1378
1379         region->addVisualOverflowForBox(block, snappedIntRect(LayoutRect(inflatedRect)));
1380         if (region == endRegion)
1381             break;
1382     }
1383 }
1384
1385 void RenderFlowThread::addRegionsOverflowFromChild(const RenderBox* box, const RenderBox* child, const LayoutSize& delta)
1386 {
1387     RenderRegion* startRegion = nullptr;
1388     RenderRegion* endRegion = nullptr;
1389     if (!getRegionRangeForBox(child, startRegion, endRegion))
1390         return;
1391
1392     RenderRegion* containerStartRegion = nullptr;
1393     RenderRegion* containerEndRegion = nullptr;
1394     if (!getRegionRangeForBox(box, containerStartRegion, containerEndRegion))
1395         return;
1396
1397     for (auto iter = m_regionList.find(startRegion), end = m_regionList.end(); iter != end; ++iter) {
1398         RenderRegion* region = *iter;
1399         if (!regionInRange(region, containerStartRegion, containerEndRegion)) {
1400             if (region == endRegion)
1401                 break;
1402             continue;
1403         }
1404
1405         LayoutRect childLayoutOverflowRect = region->layoutOverflowRectForBoxForPropagation(child);
1406         childLayoutOverflowRect.move(delta);
1407         
1408         // When propagating the layout overflow to the flow thread object, make sure to include
1409         // the logical bottom padding of the scrollable region and the bottom margin of the flowed element.
1410         // In order to behave in a similar manner to the non-regions case, content overflowing the box
1411         // flowed into the region must be painted on top of the region's padding and the box's margin.
1412         // See http://lists.w3.org/Archives/Public/www-style/2014Jan/0089.html
1413         if (is<RenderNamedFlowThread>(*box)) {
1414             ASSERT(box == this);
1415             RenderBlockFlow& fragmentContainer = downcast<RenderNamedFlowFragment>(*region).fragmentContainer();
1416             LayoutUnit spacingAfterLayout = fragmentContainer.paddingAfter() + child->marginAfter();
1417             if (isHorizontalWritingMode()) {
1418                 if (fragmentContainer.scrollsOverflowY()) {
1419                     LayoutUnit layoutMaxLogicalY = region->rectFlowPortionForBox(child, child->frameRect()).maxY() + spacingAfterLayout;
1420                     LayoutUnit maxYDiff = layoutMaxLogicalY - childLayoutOverflowRect.maxY();
1421                     if (maxYDiff > 0)
1422                         childLayoutOverflowRect.expand(0, maxYDiff);
1423                 }
1424             } else {
1425                 if (fragmentContainer.scrollsOverflowX()) {
1426                     LayoutUnit layoutMaxLogicalY = region->rectFlowPortionForBox(child, child->frameRect()).maxX() + spacingAfterLayout;
1427                     LayoutUnit maxYDiff = layoutMaxLogicalY - childLayoutOverflowRect.maxX();
1428                     if (maxYDiff > 0)
1429                         childLayoutOverflowRect.expand(maxYDiff, 0);
1430                 }
1431             }
1432         }
1433         
1434         region->addLayoutOverflowForBox(box, childLayoutOverflowRect);
1435
1436         if (child->hasSelfPaintingLayer() || box->hasOverflowClip()) {
1437             if (region == endRegion)
1438                 break;
1439             continue;
1440         }
1441         LayoutRect childVisualOverflowRect = region->visualOverflowRectForBoxForPropagation(*child);
1442         childVisualOverflowRect.move(delta);
1443         region->addVisualOverflowForBox(box, childVisualOverflowRect);
1444
1445         if (region == endRegion)
1446             break;
1447     }
1448 }
1449     
1450 void RenderFlowThread::addRegionsLayoutOverflow(const RenderBox* box, const LayoutRect& layoutOverflow)
1451 {
1452     RenderRegion* startRegion = nullptr;
1453     RenderRegion* endRegion = nullptr;
1454     if (!getRegionRangeForBox(box, startRegion, endRegion))
1455         return;
1456
1457     for (auto iter = m_regionList.find(startRegion), end = m_regionList.end(); iter != end; ++iter) {
1458         RenderRegion* region = *iter;
1459         LayoutRect layoutOverflowInRegion = region->rectFlowPortionForBox(box, layoutOverflow);
1460
1461         region->addLayoutOverflowForBox(box, layoutOverflowInRegion);
1462
1463         if (region == endRegion)
1464             break;
1465     }
1466 }
1467
1468 void RenderFlowThread::addRegionsVisualOverflow(const RenderBox* box, const LayoutRect& visualOverflow)
1469 {
1470     RenderRegion* startRegion = nullptr;
1471     RenderRegion* endRegion = nullptr;
1472     if (!getRegionRangeForBox(box, startRegion, endRegion))
1473         return;
1474     
1475     for (RenderRegionList::iterator iter = m_regionList.find(startRegion); iter != m_regionList.end(); ++iter) {
1476         RenderRegion* region = *iter;
1477         LayoutRect visualOverflowInRegion = region->rectFlowPortionForBox(box, visualOverflow);
1478         
1479         region->addVisualOverflowForBox(box, visualOverflowInRegion);
1480         
1481         if (region == endRegion)
1482             break;
1483     }
1484 }
1485
1486 void RenderFlowThread::clearRegionsOverflow(const RenderBox* box)
1487 {
1488     RenderRegion* startRegion = nullptr;
1489     RenderRegion* endRegion = nullptr;
1490     if (!getRegionRangeForBox(box, startRegion, endRegion))
1491         return;
1492
1493     for (auto iter = m_regionList.find(startRegion), end = m_regionList.end(); iter != end; ++iter) {
1494         RenderRegion* region = *iter;
1495         RenderBoxRegionInfo* boxInfo = region->renderBoxRegionInfo(box);
1496         if (boxInfo && boxInfo->overflow())
1497             boxInfo->clearOverflow();
1498
1499         if (region == endRegion)
1500             break;
1501     }
1502 }
1503
1504 RenderRegion* RenderFlowThread::currentRegion() const
1505 {
1506     return m_currentRegionMaintainer ? &m_currentRegionMaintainer->region() : nullptr;
1507 }
1508
1509 ContainingRegionMap& RenderFlowThread::containingRegionMap()
1510 {
1511     if (!m_lineToRegionMap)
1512         m_lineToRegionMap = std::make_unique<ContainingRegionMap>();
1513
1514     return *m_lineToRegionMap.get();
1515 }
1516
1517
1518 } // namespace WebCore