Use is<>() / downcast<>() for all remaining RenderObject subclasses
[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, PassRef<RenderStyle> style)
56     : RenderBlockFlow(document, WTF::move(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     setFlowThreadState(InsideOutOfFlowThread);
69 }
70
71 PassRef<RenderStyle> RenderFlowThread::createFlowThreadStyle(RenderStyle* parentStyle)
72 {
73     auto newStyle = RenderStyle::create();
74     newStyle.get().inheritFrom(parentStyle);
75     newStyle.get().setDisplay(BLOCK);
76     newStyle.get().setPosition(AbsolutePosition);
77     newStyle.get().setZIndex(0);
78     newStyle.get().setLeft(Length(0, Fixed));
79     newStyle.get().setTop(Length(0, Fixed));
80     newStyle.get().setWidth(Length(100, Percent));
81     newStyle.get().setHeight(Length(100, Percent));
82     newStyle.get().font().update(0);
83     return newStyle;
84 }
85
86 void RenderFlowThread::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
87 {
88     RenderBlockFlow::styleDidChange(diff, oldStyle);
89
90     if (oldStyle && oldStyle->writingMode() != style().writingMode())
91         invalidateRegions();
92 }
93
94 void RenderFlowThread::removeFlowChildInfo(RenderObject* child)
95 {
96     if (is<RenderBlockFlow>(*child))
97         removeLineRegionInfo(downcast<RenderBlockFlow>(child));
98     if (is<RenderBox>(*child))
99         removeRenderBoxRegionInfo(downcast<RenderBox>(child));
100 }
101
102 void RenderFlowThread::removeRegionFromThread(RenderRegion* renderRegion)
103 {
104     ASSERT(renderRegion);
105     m_regionList.remove(renderRegion);
106 }
107
108 void RenderFlowThread::invalidateRegions()
109 {
110     ASSERT(!inFinalLayoutPhase());
111
112     if (m_regionsInvalidated) {
113         ASSERT(selfNeedsLayout());
114         return;
115     }
116
117     m_regionRangeMap.clear();
118     m_breakBeforeToRegionMap.clear();
119     m_breakAfterToRegionMap.clear();
120     if (m_layerToRegionMap)
121         m_layerToRegionMap->clear();
122     if (m_regionToLayerListMap)
123         m_regionToLayerListMap->clear();
124     if (m_lineToRegionMap)
125         m_lineToRegionMap->clear();
126     m_layersToRegionMappingsDirty = true;
127     setNeedsLayout();
128
129     m_regionsInvalidated = true;
130 }
131
132 void RenderFlowThread::validateRegions()
133 {
134     if (m_regionsInvalidated) {
135         m_regionsInvalidated = false;
136         m_regionsHaveUniformLogicalWidth = true;
137         m_regionsHaveUniformLogicalHeight = true;
138
139         if (hasRegions()) {
140             LayoutUnit previousRegionLogicalWidth = 0;
141             LayoutUnit previousRegionLogicalHeight = 0;
142             bool firstRegionVisited = false;
143             
144             for (auto& region : m_regionList) {
145                 ASSERT(!region->needsLayout() || region->isRenderRegionSet());
146
147                 region->deleteAllRenderBoxRegionInfo();
148
149                 // In the measure content layout phase we need to initialize the computedAutoHeight for auto-height regions.
150                 // See initializeRegionsComputedAutoHeight for the explanation.
151                 // Also, if we have auto-height regions we can't assume m_regionsHaveUniformLogicalHeight to be true in the first phase
152                 // because the auto-height regions don't have their height computed yet.
153                 if (inMeasureContentLayoutPhase() && region->hasAutoLogicalHeight()) {
154                     auto& namedFlowFragment = downcast<RenderNamedFlowFragment>(*region);
155                     namedFlowFragment.setComputedAutoHeight(namedFlowFragment.maxPageLogicalHeight());
156                     m_regionsHaveUniformLogicalHeight = false;
157                 }
158
159                 LayoutUnit regionLogicalWidth = region->pageLogicalWidth();
160                 LayoutUnit regionLogicalHeight = region->pageLogicalHeight();
161
162                 if (!firstRegionVisited)
163                     firstRegionVisited = true;
164                 else {
165                     if (m_regionsHaveUniformLogicalWidth && previousRegionLogicalWidth != regionLogicalWidth)
166                         m_regionsHaveUniformLogicalWidth = false;
167                     if (m_regionsHaveUniformLogicalHeight && previousRegionLogicalHeight != regionLogicalHeight)
168                         m_regionsHaveUniformLogicalHeight = false;
169                 }
170
171                 previousRegionLogicalWidth = regionLogicalWidth;
172             }
173
174             setRegionRangeForBox(this, m_regionList.first(), m_regionList.last());
175         }
176     }
177
178     updateLogicalWidth(); // Called to get the maximum logical width for the region.
179     updateRegionsFlowThreadPortionRect();
180 }
181
182 void RenderFlowThread::layout()
183 {
184     StackStats::LayoutCheckPoint layoutCheckPoint;
185
186     m_pageLogicalSizeChanged = m_regionsInvalidated && everHadLayout();
187
188     // In case this is the second pass of the measure content phase we need to update the auto-height regions to their initial value.
189     // If the region chain was invalidated this will happen anyway.
190     if (!m_regionsInvalidated && inMeasureContentLayoutPhase())
191         initializeRegionsComputedAutoHeight();
192
193     // This is the first phase of the layout and because we have auto-height regions we'll need a second
194     // pass to update the flow with the computed auto-height regions.
195     // It's also possible to need a secondary layout if the overflow computation invalidated the region chain (e.g. overflow: auto scrollbars
196     // shrunk some regions) so repropagation is required.
197     m_needsTwoPhasesLayout = (inMeasureContentLayoutPhase() && hasAutoLogicalHeightRegions()) || (inOverflowLayoutPhase() && m_regionsInvalidated);
198
199     validateRegions();
200
201     RenderBlockFlow::layout();
202
203     m_pageLogicalSizeChanged = false;
204
205     // If there are children layers in the RenderFlowThread then we need to make sure that the
206     // composited children layers will land in the right RenderRegions. Also, the parent RenderRegions
207     // will get RenderLayers and become composited as needed.
208     // Note that there's no need to do so for the inline multi-column as we are not moving layers into different
209     // containers, but just adjusting the position of the RenderLayerBacking.
210     if (!m_needsTwoPhasesLayout) {
211         // If we have layers that moved from one region to another, we trigger
212         // a composited layers rebuild in here to make sure that the regions will collect the right layers.
213         if (updateAllLayerToRegionMappings())
214             layer()->compositor().setCompositingLayersNeedRebuild();
215     }
216 }
217
218 bool RenderFlowThread::hasCompositingRegionDescendant() const
219 {
220     for (auto& region : m_regionList) {
221         if (downcast<RenderNamedFlowFragment>(*region).layerOwner().layer()->hasCompositingDescendant())
222             return true;
223     }
224
225     return false;
226 }
227
228 const RenderLayerList* RenderFlowThread::getLayerListForRegion(RenderNamedFlowFragment* region) const
229 {
230     ASSERT(m_regionToLayerListMap);
231     auto iterator = m_regionToLayerListMap->find(region);
232     return iterator == m_regionToLayerListMap->end() ? nullptr : &iterator->value;
233 }
234
235 RenderNamedFlowFragment* RenderFlowThread::regionForCompositedLayer(RenderLayer& childLayer) const
236 {
237     if (childLayer.renderer().fixedPositionedWithNamedFlowContainingBlock())
238         return nullptr;
239
240     if (childLayer.renderBox()) {
241         RenderRegion* startRegion = nullptr;
242         RenderRegion* endRegion = nullptr;
243         if (getRegionRangeForBox(childLayer.renderBox(), startRegion, endRegion))
244             return downcast<RenderNamedFlowFragment>(startRegion);
245     }
246
247     // FIXME: remove this when we'll have region ranges for inlines as well.
248     LayoutPoint flowThreadOffset = flooredLayoutPoint(childLayer.renderer().localToContainerPoint(LayoutPoint(), this, ApplyContainerFlip));
249     return downcast<RenderNamedFlowFragment>(regionAtBlockOffset(0, flipForWritingMode(isHorizontalWritingMode() ? flowThreadOffset.y() : flowThreadOffset.x()), true));
250 }
251
252 RenderNamedFlowFragment* RenderFlowThread::cachedRegionForCompositedLayer(RenderLayer& childLayer) const
253 {
254     if (!m_layerToRegionMap) {
255         ASSERT(needsLayout());
256         ASSERT(m_layersToRegionMappingsDirty);
257         return nullptr;
258     }
259
260     RenderNamedFlowFragment* namedFlowFragment = m_layerToRegionMap->get(&childLayer);
261     ASSERT(!namedFlowFragment || m_regionList.contains(namedFlowFragment));
262     return namedFlowFragment;
263 }
264
265 void RenderFlowThread::updateLayerToRegionMappings(RenderLayer& layer, LayerToRegionMap& layerToRegionMap, RegionToLayerListMap& regionToLayerListMap, bool& needsLayerUpdate)
266 {
267     RenderNamedFlowFragment* region = regionForCompositedLayer(layer);
268     if (!needsLayerUpdate) {
269         // Figure out if we moved this layer from a region to the other.
270         RenderNamedFlowFragment* previousRegion = cachedRegionForCompositedLayer(layer);
271         if (previousRegion != region)
272             needsLayerUpdate = true;
273     }
274
275     if (!region)
276         return;
277
278     layerToRegionMap.set(&layer, region);
279
280     auto iterator = regionToLayerListMap.find(region);
281     RenderLayerList& list = iterator == regionToLayerListMap.end() ? regionToLayerListMap.set(region, RenderLayerList()).iterator->value : iterator->value;
282     ASSERT(!list.contains(&layer));
283     list.append(&layer);
284 }
285
286 bool RenderFlowThread::updateAllLayerToRegionMappings()
287 {
288     if (!collectsGraphicsLayersUnderRegions())
289         return false;
290
291     // If the RenderFlowThread had a z-index layer update, then we need to update the composited layers too.
292     bool needsLayerUpdate = layer()->isDirtyRenderFlowThread() || m_layersToRegionMappingsDirty || !m_layerToRegionMap.get();
293     layer()->updateLayerListsIfNeeded();
294
295     LayerToRegionMap layerToRegionMap;
296     RegionToLayerListMap regionToLayerListMap;
297
298     RenderLayerList* lists[] = { layer()->negZOrderList(), layer()->normalFlowList(), layer()->posZOrderList() };
299     for (size_t listIndex = 0; listIndex < sizeof(lists) / sizeof(lists[0]); ++listIndex) {
300         if (RenderLayerList* list = lists[listIndex]) {
301             for (size_t i = 0, listSize = list->size(); i < listSize; ++i)
302                 updateLayerToRegionMappings(*list->at(i), layerToRegionMap, regionToLayerListMap, needsLayerUpdate);
303         }
304     }
305
306     if (needsLayerUpdate) {
307         if (!m_layerToRegionMap)
308             m_layerToRegionMap = std::make_unique<LayerToRegionMap>();
309         m_layerToRegionMap->swap(layerToRegionMap);
310
311         if (!m_regionToLayerListMap)
312             m_regionToLayerListMap = std::make_unique<RegionToLayerListMap>();
313         m_regionToLayerListMap->swap(regionToLayerListMap);
314     }
315
316     m_layersToRegionMappingsDirty = false;
317
318     return needsLayerUpdate;
319 }
320
321 bool RenderFlowThread::collectsGraphicsLayersUnderRegions() const
322 {
323     // We only need to map layers to regions for named flow threads.
324     // Multi-column threads are displayed on top of the regions and do not require
325     // distributing the layers.
326
327     return false;
328 }
329
330 void RenderFlowThread::updateLogicalWidth()
331 {
332     LayoutUnit logicalWidth = initialLogicalWidth();
333     for (auto& region : m_regionList) {
334         ASSERT(!region->needsLayout() || region->isRenderRegionSet());
335         logicalWidth = std::max(region->pageLogicalWidth(), logicalWidth);
336     }
337     setLogicalWidth(logicalWidth);
338
339     // If the regions have non-uniform logical widths, then insert inset information for the RenderFlowThread.
340     for (auto& region : m_regionList) {
341         LayoutUnit regionLogicalWidth = region->pageLogicalWidth();
342         LayoutUnit logicalLeft = style().direction() == LTR ? LayoutUnit() : logicalWidth - regionLogicalWidth;
343         region->setRenderBoxRegionInfo(this, logicalLeft, regionLogicalWidth, false);
344     }
345 }
346
347 void RenderFlowThread::computeLogicalHeight(LayoutUnit, LayoutUnit logicalTop, LogicalExtentComputedValues& computedValues) const
348 {
349     computedValues.m_position = logicalTop;
350     computedValues.m_extent = 0;
351
352     const LayoutUnit maxFlowSize = RenderFlowThread::maxLogicalHeight();
353     for (auto& region : m_regionList) {
354         ASSERT(!region->needsLayout() || region->isRenderRegionSet());
355
356         LayoutUnit distanceToMaxSize = maxFlowSize - computedValues.m_extent;
357         computedValues.m_extent += std::min(distanceToMaxSize, region->logicalHeightOfAllFlowThreadContent());
358
359         // If we reached the maximum size there's no point in going further.
360         if (computedValues.m_extent == maxFlowSize)
361             return;
362     }
363 }
364
365 bool RenderFlowThread::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction hitTestAction)
366 {
367     if (hitTestAction == HitTestBlockBackground)
368         return false;
369     return RenderBlockFlow::nodeAtPoint(request, result, locationInContainer, accumulatedOffset, hitTestAction);
370 }
371
372 bool RenderFlowThread::shouldRepaint(const LayoutRect& r) const
373 {
374     if (view().printing() || r.isEmpty())
375         return false;
376
377     return true;
378 }
379
380 void RenderFlowThread::repaintRectangleInRegions(const LayoutRect& repaintRect) const
381 {
382     if (!shouldRepaint(repaintRect) || !hasValidRegionInfo())
383         return;
384
385     LayoutStateDisabler layoutStateDisabler(&view()); // We can't use layout state to repaint, since the regions are somewhere else.
386
387     for (auto& region : m_regionList)
388         region->repaintFlowThreadContent(repaintRect);
389 }
390
391 RenderRegion* RenderFlowThread::regionAtBlockOffset(const RenderBox* clampBox, LayoutUnit offset, bool extendLastRegion) const
392 {
393     ASSERT(!m_regionsInvalidated);
394
395     if (m_regionList.isEmpty())
396         return nullptr;
397
398     if (m_regionList.size() == 1 && extendLastRegion)
399         return m_regionList.first();
400
401     if (offset <= 0)
402         return clampBox ? clampBox->clampToStartAndEndRegions(m_regionList.first()) : m_regionList.first();
403
404     RegionSearchAdapter adapter(offset);
405     m_regionIntervalTree.allOverlapsWithAdapter<RegionSearchAdapter>(adapter);
406
407     // If no region was found, the offset is in the flow thread overflow.
408     // The last region will contain the offset if extendLastRegion is set or if the last region is a set.
409     if (!adapter.result() && (extendLastRegion || m_regionList.last()->isRenderRegionSet()))
410         return clampBox ? clampBox->clampToStartAndEndRegions(m_regionList.last()) : m_regionList.last();
411
412     RenderRegion* region = adapter.result();
413     if (!clampBox)
414         return region;
415     return region ? clampBox->clampToStartAndEndRegions(region) : nullptr;
416 }
417
418 LayoutPoint RenderFlowThread::adjustedPositionRelativeToOffsetParent(const RenderBoxModelObject& boxModelObject, const LayoutPoint& startPoint) const
419 {
420     LayoutPoint referencePoint = startPoint;
421     
422     const RenderBlock* objContainingBlock = boxModelObject.containingBlock();
423     // FIXME: This needs to be adapted for different writing modes inside the flow thread.
424     RenderRegion* startRegion = regionAtBlockOffset(objContainingBlock, referencePoint.y());
425     if (startRegion) {
426         // Take into account the offset coordinates of the region.
427         RenderBoxModelObject* startRegionBox = is<RenderNamedFlowFragment>(*startRegion) ? downcast<RenderBoxModelObject>(startRegion->parent()) : startRegion;
428         RenderBoxModelObject* currObject = startRegionBox;
429         RenderBoxModelObject* currOffsetParent;
430         while ((currOffsetParent = currObject->offsetParent())) {
431             referencePoint.move(currObject->offsetLeft(), currObject->offsetTop());
432             
433             // Since we're looking for the offset relative to the body, we must also
434             // take into consideration the borders of the region's offsetParent.
435             if (is<RenderBox>(*currOffsetParent) && !currOffsetParent->isBody())
436                 referencePoint.move(downcast<RenderBox>(*currOffsetParent).borderLeft(), downcast<RenderBox>(*currOffsetParent).borderTop());
437             
438             currObject = currOffsetParent;
439         }
440         
441         // We need to check if any of this box's containing blocks start in a different region
442         // and if so, drop the object's top position (which was computed relative to its containing block
443         // and is no longer valid) and recompute it using the region in which it flows as reference.
444         bool wasComputedRelativeToOtherRegion = false;
445         while (objContainingBlock && !objContainingBlock->isRenderNamedFlowThread()) {
446             // Check if this object is in a different region.
447             RenderRegion* parentStartRegion = nullptr;
448             RenderRegion* parentEndRegion = nullptr;
449             if (getRegionRangeForBox(objContainingBlock, parentStartRegion, parentEndRegion) && parentStartRegion != startRegion) {
450                 wasComputedRelativeToOtherRegion = true;
451                 break;
452             }
453             objContainingBlock = objContainingBlock->containingBlock();
454         }
455         
456         if (wasComputedRelativeToOtherRegion) {
457             if (is<RenderBox>(boxModelObject)) {
458                 // Use borderBoxRectInRegion to account for variations such as percentage margins.
459                 LayoutRect borderBoxRect = downcast<RenderBox>(boxModelObject).borderBoxRectInRegion(startRegion, RenderBox::DoNotCacheRenderBoxRegionInfo);
460                 referencePoint.move(borderBoxRect.location().x(), 0);
461             }
462             
463             // Get the logical top coordinate of the current object.
464             LayoutUnit top = 0;
465             if (is<RenderBlock>(boxModelObject))
466                 top = downcast<RenderBlock>(boxModelObject).offsetFromLogicalTopOfFirstPage();
467             else {
468                 if (boxModelObject.containingBlock())
469                     top = boxModelObject.containingBlock()->offsetFromLogicalTopOfFirstPage();
470                 
471                 if (is<RenderBox>(boxModelObject))
472                     top += downcast<RenderBox>(boxModelObject).topLeftLocation().y();
473                 else if (is<RenderInline>(boxModelObject))
474                     top -= downcast<RenderInline>(boxModelObject).borderTop();
475             }
476             
477             // Get the logical top of the region this object starts in
478             // and compute the object's top, relative to the region's top.
479             LayoutUnit regionLogicalTop = startRegion->pageLogicalTopForOffset(top);
480             LayoutUnit topRelativeToRegion = top - regionLogicalTop;
481             referencePoint.setY(startRegionBox->offsetTop() + topRelativeToRegion);
482             
483             // Since the top has been overriden, check if the
484             // relative/sticky positioning must be reconsidered.
485             if (boxModelObject.isRelPositioned())
486                 referencePoint.move(0, boxModelObject.relativePositionOffset().height());
487             else if (boxModelObject.isStickyPositioned())
488                 referencePoint.move(0, boxModelObject.stickyPositionOffset().height());
489         }
490         
491         // Since we're looking for the offset relative to the body, we must also
492         // take into consideration the borders of the region.
493         referencePoint.move(startRegionBox->borderLeft(), startRegionBox->borderTop());
494     }
495     
496     return referencePoint;
497 }
498
499 LayoutUnit RenderFlowThread::pageLogicalTopForOffset(LayoutUnit offset) const
500 {
501     RenderRegion* region = regionAtBlockOffset(0, offset, false);
502     return region ? region->pageLogicalTopForOffset(offset) : LayoutUnit();
503 }
504
505 LayoutUnit RenderFlowThread::pageLogicalWidthForOffset(LayoutUnit offset) const
506 {
507     RenderRegion* region = regionAtBlockOffset(0, offset, true);
508     return region ? region->pageLogicalWidth() : contentLogicalWidth();
509 }
510
511 LayoutUnit RenderFlowThread::pageLogicalHeightForOffset(LayoutUnit offset) const
512 {
513     RenderRegion* region = regionAtBlockOffset(0, offset, false);
514     if (!region)
515         return 0;
516
517     return region->pageLogicalHeight();
518 }
519
520 LayoutUnit RenderFlowThread::pageRemainingLogicalHeightForOffset(LayoutUnit offset, PageBoundaryRule pageBoundaryRule) const
521 {
522     RenderRegion* region = regionAtBlockOffset(0, offset, false);
523     if (!region)
524         return 0;
525
526     LayoutUnit pageLogicalTop = region->pageLogicalTopForOffset(offset);
527     LayoutUnit pageLogicalHeight = region->pageLogicalHeight();
528     LayoutUnit pageLogicalBottom = pageLogicalTop + pageLogicalHeight;
529     LayoutUnit remainingHeight = pageLogicalBottom - offset;
530     if (pageBoundaryRule == IncludePageBoundary) {
531         // If IncludePageBoundary is set, the line exactly on the top edge of a
532         // region will act as being part of the previous region.
533         remainingHeight = intMod(remainingHeight, pageLogicalHeight);
534     }
535     return remainingHeight;
536 }
537
538 RenderRegion* RenderFlowThread::mapFromFlowToRegion(TransformState& transformState) const
539 {
540     if (!hasValidRegionInfo())
541         return nullptr;
542
543     RenderRegion* renderRegion = currentRegion();
544     if (!renderRegion) {
545         LayoutRect boxRect = transformState.mappedQuad().enclosingBoundingBox();
546         flipForWritingMode(boxRect);
547
548         LayoutPoint center = boxRect.center();
549         renderRegion = regionAtBlockOffset(this, isHorizontalWritingMode() ? center.y() : center.x(), true);
550         if (!renderRegion)
551             return nullptr;
552     }
553
554     LayoutRect flippedRegionRect(renderRegion->flowThreadPortionRect());
555     flipForWritingMode(flippedRegionRect);
556
557     transformState.move(renderRegion->contentBoxRect().location() - flippedRegionRect.location());
558
559     return renderRegion;
560 }
561
562 void RenderFlowThread::removeRenderBoxRegionInfo(RenderBox* box)
563 {
564     if (!hasRegions())
565         return;
566
567     // If the region chain was invalidated the next layout will clear the box information from all the regions.
568     if (m_regionsInvalidated) {
569         ASSERT(selfNeedsLayout());
570         return;
571     }
572
573     RenderRegion* startRegion = nullptr;
574     RenderRegion* endRegion = nullptr;
575     if (getRegionRangeForBox(box, startRegion, endRegion)) {
576         for (auto it = m_regionList.find(startRegion), end = m_regionList.end(); it != end; ++it) {
577             RenderRegion* region = *it;
578             region->removeRenderBoxRegionInfo(box);
579             if (region == endRegion)
580                 break;
581         }
582     }
583
584 #ifndef NDEBUG
585     // We have to make sure we did not leave any RenderBoxRegionInfo attached.
586     for (auto& region : m_regionList)
587         ASSERT(!region->renderBoxRegionInfo(box));
588 #endif
589
590     m_regionRangeMap.remove(box);
591 }
592
593 void RenderFlowThread::removeLineRegionInfo(const RenderBlockFlow* blockFlow)
594 {
595     if (!m_lineToRegionMap || blockFlow->m_lineLayoutPath == SimpleLinesPath)
596         return;
597
598     for (RootInlineBox* curr = blockFlow->firstRootBox(); curr; curr = curr->nextRootBox()) {
599         if (m_lineToRegionMap->contains(curr))
600             m_lineToRegionMap->remove(curr);
601     }
602
603     ASSERT_WITH_SECURITY_IMPLICATION(checkLinesConsistency(blockFlow));
604 }
605
606 void RenderFlowThread::logicalWidthChangedInRegionsForBlock(const RenderBlock* block, bool& relayoutChildren)
607 {
608     if (!hasValidRegionInfo()) {
609         // FIXME: Remove once we stop laying out flow threads without regions.
610         // If we had regions but don't any more, relayout the children because the code below
611         // can't properly detect this scenario.
612         relayoutChildren |= previousRegionCountChanged();
613         return;
614     }
615
616     auto it = m_regionRangeMap.find(block);
617     if (it == m_regionRangeMap.end())
618         return;
619
620     RenderRegionRange& range = it->value;
621     bool rangeInvalidated = range.rangeInvalidated();
622     range.clearRangeInvalidated();
623
624     // If there will be a relayout anyway skip the next steps because they only verify
625     // the state of the ranges.
626     if (relayoutChildren)
627         return;
628
629     // Not necessary for the flow thread, since we already computed the correct info for it.
630     // If the regions have changed invalidate the children.
631     if (block == this) {
632         relayoutChildren = m_pageLogicalSizeChanged;
633         return;
634     }
635
636     RenderRegion* startRegion = nullptr;
637     RenderRegion* endRegion = nullptr;
638     if (!getRegionRangeForBox(block, startRegion, endRegion))
639         return;
640
641     for (auto it = m_regionList.find(startRegion), end = m_regionList.end(); it != end; ++it) {
642         RenderRegion* region = *it;
643         ASSERT(!region->needsLayout() || region->isRenderRegionSet());
644
645         // We have no information computed for this region so we need to do it.
646         std::unique_ptr<RenderBoxRegionInfo> oldInfo = region->takeRenderBoxRegionInfo(block);
647         if (!oldInfo) {
648             relayoutChildren = rangeInvalidated;
649             return;
650         }
651
652         LayoutUnit oldLogicalWidth = oldInfo->logicalWidth();
653         RenderBoxRegionInfo* newInfo = block->renderBoxRegionInfo(region);
654         if (!newInfo || newInfo->logicalWidth() != oldLogicalWidth) {
655             relayoutChildren = true;
656             return;
657         }
658
659         if (region == endRegion)
660             break;
661     }
662 }
663
664 LayoutUnit RenderFlowThread::contentLogicalWidthOfFirstRegion() const
665 {
666     RenderRegion* firstValidRegionInFlow = firstRegion();
667     if (!firstValidRegionInFlow)
668         return 0;
669     return isHorizontalWritingMode() ? firstValidRegionInFlow->contentWidth() : firstValidRegionInFlow->contentHeight();
670 }
671
672 LayoutUnit RenderFlowThread::contentLogicalHeightOfFirstRegion() const
673 {
674     RenderRegion* firstValidRegionInFlow = firstRegion();
675     if (!firstValidRegionInFlow)
676         return 0;
677     return isHorizontalWritingMode() ? firstValidRegionInFlow->contentHeight() : firstValidRegionInFlow->contentWidth();
678 }
679
680 LayoutUnit RenderFlowThread::contentLogicalLeftOfFirstRegion() const
681 {
682     RenderRegion* firstValidRegionInFlow = firstRegion();
683     if (!firstValidRegionInFlow)
684         return 0;
685     return isHorizontalWritingMode() ? firstValidRegionInFlow->flowThreadPortionRect().x() : firstValidRegionInFlow->flowThreadPortionRect().y();
686 }
687
688 RenderRegion* RenderFlowThread::firstRegion() const
689 {
690     if (!hasRegions())
691         return nullptr;
692     return m_regionList.first();
693 }
694
695 RenderRegion* RenderFlowThread::lastRegion() const
696 {
697     if (!hasRegions())
698         return nullptr;
699     return m_regionList.last();
700 }
701
702 void RenderFlowThread::clearRenderBoxRegionInfoAndCustomStyle(const RenderBox* box,
703     const RenderRegion* newStartRegion, const RenderRegion* newEndRegion,
704     const RenderRegion* oldStartRegion, const RenderRegion* oldEndRegion)
705 {
706     ASSERT(newStartRegion && newEndRegion && oldStartRegion && oldEndRegion);
707
708     bool insideOldRegionRange = false;
709     bool insideNewRegionRange = false;
710     for (auto& region : m_regionList) {
711         if (oldStartRegion == region)
712             insideOldRegionRange = true;
713         if (newStartRegion == region)
714             insideNewRegionRange = true;
715
716         if (!(insideOldRegionRange && insideNewRegionRange)) {
717             if (is<RenderNamedFlowFragment>(*region))
718                 downcast<RenderNamedFlowFragment>(*region).clearObjectStyleInRegion(box);
719             if (region->renderBoxRegionInfo(box))
720                 region->removeRenderBoxRegionInfo(box);
721         }
722
723         if (oldEndRegion == region)
724             insideOldRegionRange = false;
725         if (newEndRegion == region)
726             insideNewRegionRange = false;
727     }
728 }
729
730 void RenderFlowThread::setRegionRangeForBox(const RenderBox* box, RenderRegion* startRegion, RenderRegion* endRegion)
731 {
732     ASSERT(hasRegions());
733     ASSERT(startRegion && endRegion && startRegion->flowThread() == this && endRegion->flowThread() == this);
734
735     auto it = m_regionRangeMap.find(box);
736     if (it == m_regionRangeMap.end()) {
737         m_regionRangeMap.set(box, RenderRegionRange(startRegion, endRegion));
738         return;
739     }
740
741     // If nothing changed, just bail.
742     RenderRegionRange& range = it->value;
743     if (range.startRegion() == startRegion && range.endRegion() == endRegion)
744         return;
745
746     clearRenderBoxRegionInfoAndCustomStyle(box, startRegion, endRegion, range.startRegion(), range.endRegion());
747     range.setRange(startRegion, endRegion);
748 }
749
750 bool RenderFlowThread::hasCachedRegionRangeForBox(const RenderBox* box) const
751 {
752     ASSERT(box);
753
754     return m_regionRangeMap.contains(box);
755 }
756
757 bool RenderFlowThread::getRegionRangeForBoxFromCachedInfo(const RenderBox* box, RenderRegion*& startRegion, RenderRegion*& endRegion) const
758 {
759     ASSERT(box);
760     ASSERT(hasValidRegionInfo());
761     ASSERT((startRegion == nullptr) && (endRegion == nullptr));
762
763     auto it = m_regionRangeMap.find(box);
764     if (it != m_regionRangeMap.end()) {
765         const RenderRegionRange& range = it->value;
766         startRegion = range.startRegion();
767         endRegion = range.endRegion();
768         ASSERT(m_regionList.contains(startRegion) && m_regionList.contains(endRegion));
769         return true;
770     }
771
772     return false;
773 }
774
775 bool RenderFlowThread::getRegionRangeForBox(const RenderBox* box, RenderRegion*& startRegion, RenderRegion*& endRegion) const
776 {
777     ASSERT(box);
778
779     startRegion = endRegion = nullptr;
780     if (!hasValidRegionInfo()) // We clear the ranges when we invalidate the regions.
781         return false;
782
783     if (m_regionList.size() == 1) {
784         startRegion = endRegion = m_regionList.first();
785         return true;
786     }
787
788     if (getRegionRangeForBoxFromCachedInfo(box, startRegion, endRegion))
789         return true;
790
791     return false;
792 }
793
794 bool RenderFlowThread::computedRegionRangeForBox(const RenderBox* box, RenderRegion*& startRegion, RenderRegion*& endRegion) const
795 {
796     ASSERT(box);
797
798     startRegion = endRegion = nullptr;
799     if (!hasValidRegionInfo()) // We clear the ranges when we invalidate the regions.
800         return false;
801
802     if (getRegionRangeForBox(box, startRegion, endRegion))
803         return true;
804
805     // Search the region range using the information provided by the
806     // containing block chain.
807     RenderBox* cb = const_cast<RenderBox*>(box);
808     while (!cb->isRenderFlowThread()) {
809         InlineElementBox* boxWrapper = cb->inlineBoxWrapper();
810         if (boxWrapper && boxWrapper->root().containingRegion()) {
811             startRegion = endRegion = boxWrapper->root().containingRegion();
812             ASSERT(m_regionList.contains(startRegion));
813             return true;
814         }
815
816         // FIXME: Use the containingBlock() value once we patch all the layout systems to be region range aware
817         // (e.g. if we use containingBlock() the shadow controls of a video element won't get the range from the
818         // video box because it's not a block; they need to be patched separately).
819         ASSERT(cb->parent());
820         cb = &cb->parent()->enclosingBox();
821         ASSERT(cb);
822
823         // 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.
824         // FIXME: Find the cases when this startRegion should not be equal with endRegion and make sure these boxes have cached region ranges.
825         if (hasCachedRegionRangeForBox(cb)) {
826             startRegion = endRegion = regionAtBlockOffset(cb, box->offsetFromLogicalTopOfFirstPage(), true);
827             return true;
828         }
829     }
830
831     ASSERT_NOT_REACHED();
832     return false;
833 }
834
835 bool RenderFlowThread::regionInRange(const RenderRegion* targetRegion, const RenderRegion* startRegion, const RenderRegion* endRegion) const
836 {
837     ASSERT(targetRegion);
838
839     for (auto it = m_regionList.find(const_cast<RenderRegion*>(startRegion)), end = m_regionList.end(); it != end; ++it) {
840         const RenderRegion* currRegion = *it;
841         if (targetRegion == currRegion)
842             return true;
843         if (currRegion == endRegion)
844             break;
845     }
846
847     return false;
848 }
849
850 bool RenderFlowThread::objectShouldFragmentInFlowRegion(const RenderObject* object, const RenderRegion* region) const
851 {
852     ASSERT(object);
853     ASSERT(region);
854     
855     RenderFlowThread* flowThread = object->flowThreadContainingBlock();
856     if (flowThread != this)
857         return false;
858
859     if (!m_regionList.contains(const_cast<RenderRegion*>(region)))
860         return false;
861     
862     RenderRegion* enclosingBoxStartRegion = nullptr;
863     RenderRegion* enclosingBoxEndRegion = nullptr;
864     // If the box has no range, do not check regionInRange. Boxes inside inlines do not get ranges.
865     // Instead, the containing RootInlineBox will abort when trying to paint inside the wrong region.
866     if (computedRegionRangeForBox(&object->enclosingBox(), enclosingBoxStartRegion, enclosingBoxEndRegion)
867         && !regionInRange(region, enclosingBoxStartRegion, enclosingBoxEndRegion))
868         return false;
869     
870     return object->isBox() || object->isRenderInline();
871 }
872
873 bool RenderFlowThread::objectInFlowRegion(const RenderObject* object, const RenderRegion* region) const
874 {
875     ASSERT(object);
876     ASSERT(region);
877
878     RenderFlowThread* flowThread = object->flowThreadContainingBlock();
879     if (flowThread != this)
880         return false;
881
882     if (!m_regionList.contains(const_cast<RenderRegion*>(region)))
883         return false;
884
885     RenderRegion* enclosingBoxStartRegion = nullptr;
886     RenderRegion* enclosingBoxEndRegion = nullptr;
887     if (!getRegionRangeForBox(&object->enclosingBox(), enclosingBoxStartRegion, enclosingBoxEndRegion))
888         return false;
889
890     if (!regionInRange(region, enclosingBoxStartRegion, enclosingBoxEndRegion))
891         return false;
892
893     if (object->isBox())
894         return true;
895
896     LayoutRect objectABBRect = object->absoluteBoundingBoxRect(true);
897     if (!objectABBRect.width())
898         objectABBRect.setWidth(1);
899     if (!objectABBRect.height())
900         objectABBRect.setHeight(1); 
901     if (objectABBRect.intersects(region->absoluteBoundingBoxRect(true)))
902         return true;
903
904     if (region == lastRegion()) {
905         // If the object does not intersect any of the enclosing box regions
906         // then the object is in last region.
907         for (auto it = m_regionList.find(enclosingBoxStartRegion), end = m_regionList.end(); it != end; ++it) {
908             const RenderRegion* currRegion = *it;
909             if (currRegion == region)
910                 break;
911             if (objectABBRect.intersects(currRegion->absoluteBoundingBoxRect(true)))
912                 return false;
913         }
914         return true;
915     }
916
917     return false;
918 }
919
920 #ifndef NDEBUG
921 bool RenderFlowThread::isAutoLogicalHeightRegionsCountConsistent() const
922 {
923     unsigned autoLogicalHeightRegions = 0;
924     for (const auto& region : m_regionList) {
925         if (region->hasAutoLogicalHeight())
926             autoLogicalHeightRegions++;
927     }
928
929     return autoLogicalHeightRegions == m_autoLogicalHeightRegionsCount;
930 }
931 #endif
932
933 #if !ASSERT_WITH_SECURITY_IMPLICATION_DISABLED
934 bool RenderFlowThread::checkLinesConsistency(const RenderBlockFlow* removedBlock) const
935 {
936     if (!m_lineToRegionMap)
937         return true;
938
939     for (auto& linePair : *m_lineToRegionMap.get()) {
940         const RootInlineBox* line = linePair.key;
941         RenderRegion* region = linePair.value;
942         if (&line->blockFlow() == removedBlock)
943             return false;
944         if (line->blockFlow().flowThreadState() == NotInsideFlowThread)
945             return false;
946         if (!m_regionList.contains(region))
947             return false;
948     }
949
950     return true;
951 }
952 #endif
953
954 void RenderFlowThread::clearLinesToRegionMap()
955 {
956     if (m_lineToRegionMap)
957         m_lineToRegionMap->clear();
958 }
959
960 void RenderFlowThread::deleteLines()
961 {
962     clearLinesToRegionMap();
963     RenderBlockFlow::deleteLines();
964 }
965
966 void RenderFlowThread::willBeDestroyed()
967 {
968     clearLinesToRegionMap();
969     RenderBlockFlow::willBeDestroyed();
970 }
971
972 // During the measure content layout phase of the named flow the regions are initialized with a height equal to their max-height.
973 // This way unforced breaks are automatically placed when a region is full and the content height/position correctly estimated.
974 // Also, the region where a forced break falls is exactly the region found at the forced break offset inside the flow content.
975 void RenderFlowThread::initializeRegionsComputedAutoHeight(RenderRegion* startRegion)
976 {
977     ASSERT(inMeasureContentLayoutPhase());
978     if (!hasAutoLogicalHeightRegions())
979         return;
980
981     for (auto regionIter = startRegion ? m_regionList.find(startRegion) : m_regionList.begin(), end = m_regionList.end(); regionIter != end; ++regionIter) {
982         RenderRegion& region = **regionIter;
983         if (region.hasAutoLogicalHeight()) {
984             auto& namedFlowFragment = downcast<RenderNamedFlowFragment>(region);
985             namedFlowFragment.setComputedAutoHeight(namedFlowFragment.maxPageLogicalHeight());
986         }
987     }
988 }
989
990 void RenderFlowThread::markAutoLogicalHeightRegionsForLayout()
991 {
992     ASSERT(hasAutoLogicalHeightRegions());
993
994     for (auto& region : m_regionList) {
995         if (!region->hasAutoLogicalHeight())
996             continue;
997
998         // FIXME: We need to find a way to avoid marking all the regions ancestors for layout
999         // as we are already inside layout.
1000         region->setNeedsLayout();
1001     }
1002 }
1003
1004 void RenderFlowThread::markRegionsForOverflowLayoutIfNeeded()
1005 {
1006     if (!hasRegions())
1007         return;
1008
1009     for (auto& region : m_regionList)
1010         region->setNeedsSimplifiedNormalFlowLayout();
1011 }
1012
1013 void RenderFlowThread::updateRegionsFlowThreadPortionRect(const RenderRegion* lastRegionWithContent)
1014 {
1015     ASSERT(!lastRegionWithContent || (inMeasureContentLayoutPhase() && hasAutoLogicalHeightRegions()));
1016     LayoutUnit logicalHeight = 0;
1017     bool emptyRegionsSegment = false;
1018     // FIXME: Optimize not to clear the interval all the time. This implies manually managing the tree nodes lifecycle.
1019     m_regionIntervalTree.clear();
1020     m_regionIntervalTree.initIfNeeded();
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);
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.add(&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 && !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