Replace PassRef with Ref/Ref&& across the board.
[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, 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 Ref<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     for (auto& region : m_regionList) {
1021         // If we find an empty auto-height region, clear the computedAutoHeight value.
1022         if (emptyRegionsSegment && region->hasAutoLogicalHeight())
1023             downcast<RenderNamedFlowFragment>(*region).clearComputedAutoHeight();
1024
1025         LayoutUnit regionLogicalWidth = region->pageLogicalWidth();
1026         LayoutUnit regionLogicalHeight = std::min<LayoutUnit>(RenderFlowThread::maxLogicalHeight() - logicalHeight, region->logicalHeightOfAllFlowThreadContent());
1027
1028         LayoutRect regionRect(style().direction() == LTR ? LayoutUnit() : logicalWidth() - regionLogicalWidth, logicalHeight, regionLogicalWidth, regionLogicalHeight);
1029
1030         region->setFlowThreadPortionRect(isHorizontalWritingMode() ? regionRect : regionRect.transposedRect());
1031
1032         m_regionIntervalTree.add(RegionIntervalTree::createInterval(logicalHeight, logicalHeight + regionLogicalHeight, region));
1033
1034         logicalHeight += regionLogicalHeight;
1035
1036         // Once we find the last region with content the next regions are considered empty.
1037         if (lastRegionWithContent == region)
1038             emptyRegionsSegment = true;
1039     }
1040
1041     ASSERT(!lastRegionWithContent || emptyRegionsSegment);
1042 }
1043
1044 // Even if we require the break to occur at offsetBreakInFlowThread, because regions may have min/max-height values,
1045 // it is possible that the break will occur at a different offset than the original one required.
1046 // offsetBreakAdjustment measures the different between the requested break offset and the current break offset.
1047 bool RenderFlowThread::addForcedRegionBreak(const RenderBlock* block, LayoutUnit offsetBreakInFlowThread, RenderBox* breakChild, bool isBefore, LayoutUnit* offsetBreakAdjustment)
1048 {
1049     // We take breaks into account for height computation for auto logical height regions
1050     // only in the layout phase in which we lay out the flows threads unconstrained
1051     // and we use the content breaks to determine the computed auto height for
1052     // auto logical height regions.
1053     if (!inMeasureContentLayoutPhase())
1054         return false;
1055
1056     // Breaks can come before or after some objects. We need to track these objects, so that if we get
1057     // multiple breaks for the same object (for example because of multiple layouts on the same object),
1058     // we need to invalidate every other region after the old one and start computing from fresh.
1059     RenderBoxToRegionMap& mapToUse = isBefore ? m_breakBeforeToRegionMap : m_breakAfterToRegionMap;
1060     auto iter = mapToUse.find(breakChild);
1061     if (iter != mapToUse.end()) {
1062         auto regionIter = m_regionList.find(iter->value);
1063         ASSERT(regionIter != m_regionList.end());
1064         ASSERT((*regionIter)->hasAutoLogicalHeight());
1065         initializeRegionsComputedAutoHeight(*regionIter);
1066
1067         // We need to update the regions flow thread portion rect because we are going to process
1068         // a break on these regions.
1069         updateRegionsFlowThreadPortionRect();
1070     }
1071
1072     // Simulate a region break at offsetBreakInFlowThread. If it points inside an auto logical height region,
1073     // then it determines the region computed auto height.
1074     RenderRegion* region = regionAtBlockOffset(block, offsetBreakInFlowThread);
1075     if (!region)
1076         return false;
1077
1078     bool lastBreakAfterContent = breakChild == this;
1079     bool hasComputedAutoHeight = false;
1080
1081     LayoutUnit currentRegionOffsetInFlowThread = isHorizontalWritingMode() ? region->flowThreadPortionRect().y() : region->flowThreadPortionRect().x();
1082     LayoutUnit offsetBreakInCurrentRegion = offsetBreakInFlowThread - currentRegionOffsetInFlowThread;
1083
1084     if (region->hasAutoLogicalHeight()) {
1085         auto& namedFlowFragment = downcast<RenderNamedFlowFragment>(*region);
1086
1087         // A forced break can appear only in an auto-height region that didn't have a forced break before.
1088         // This ASSERT is a good-enough heuristic to verify the above condition.
1089         ASSERT(namedFlowFragment.maxPageLogicalHeight() == namedFlowFragment.computedAutoHeight());
1090
1091         mapToUse.set(breakChild, &namedFlowFragment);
1092
1093         hasComputedAutoHeight = true;
1094
1095         // Compute the region height pretending that the offsetBreakInCurrentRegion is the logicalHeight for the auto-height region.
1096         LayoutUnit regionComputedAutoHeight = namedFlowFragment.constrainContentBoxLogicalHeightByMinMax(offsetBreakInCurrentRegion);
1097
1098         // 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
1099         // height of an auto-height region besides content ending.
1100         ASSERT(regionComputedAutoHeight <= namedFlowFragment.maxPageLogicalHeight());
1101
1102         namedFlowFragment.setComputedAutoHeight(regionComputedAutoHeight);
1103
1104         currentRegionOffsetInFlowThread += regionComputedAutoHeight;
1105     } else
1106         currentRegionOffsetInFlowThread += isHorizontalWritingMode() ? region->flowThreadPortionRect().height() : region->flowThreadPortionRect().width();
1107
1108     // If the break was found inside an auto-height region its size changed so we need to recompute the flow thread portion rectangles.
1109     // Also, if this is the last break after the content we need to clear the computedAutoHeight value on the last empty regions.
1110     if (hasAutoLogicalHeightRegions() && lastBreakAfterContent)
1111         updateRegionsFlowThreadPortionRect(region);
1112     else if (hasComputedAutoHeight)
1113         updateRegionsFlowThreadPortionRect();
1114
1115     if (offsetBreakAdjustment)
1116         *offsetBreakAdjustment = std::max<LayoutUnit>(0, currentRegionOffsetInFlowThread - offsetBreakInFlowThread);
1117
1118     return hasComputedAutoHeight;
1119 }
1120
1121 void RenderFlowThread::incrementAutoLogicalHeightRegions()
1122 {
1123     if (!m_autoLogicalHeightRegionsCount)
1124         view().flowThreadController().incrementFlowThreadsWithAutoLogicalHeightRegions();
1125     ++m_autoLogicalHeightRegionsCount;
1126 }
1127
1128 void RenderFlowThread::decrementAutoLogicalHeightRegions()
1129 {
1130     ASSERT(m_autoLogicalHeightRegionsCount > 0);
1131     --m_autoLogicalHeightRegionsCount;
1132     if (!m_autoLogicalHeightRegionsCount)
1133         view().flowThreadController().decrementFlowThreadsWithAutoLogicalHeightRegions();
1134 }
1135
1136 void RenderFlowThread::collectLayerFragments(LayerFragments& layerFragments, const LayoutRect& layerBoundingBox, const LayoutRect& dirtyRect)
1137 {
1138     ASSERT(!m_regionsInvalidated);
1139     
1140     for (auto& region : m_regionList)
1141         region->collectLayerFragments(layerFragments, layerBoundingBox, dirtyRect);
1142 }
1143
1144 LayoutRect RenderFlowThread::fragmentsBoundingBox(const LayoutRect& layerBoundingBox)
1145 {
1146     ASSERT(!m_regionsInvalidated);
1147     
1148     LayoutRect result;
1149     for (auto& region : m_regionList) {
1150         LayerFragments fragments;
1151         region->collectLayerFragments(fragments, layerBoundingBox, LayoutRect::infiniteRect());
1152         for (const auto& fragment : fragments) {
1153             LayoutRect fragmentRect(layerBoundingBox);
1154             fragmentRect.intersect(fragment.paginationClip);
1155             fragmentRect.move(fragment.paginationOffset);
1156             result.unite(fragmentRect);
1157         }
1158     }
1159     
1160     return result;
1161 }
1162
1163 bool RenderFlowThread::hasCachedOffsetFromLogicalTopOfFirstRegion(const RenderBox* box) const
1164 {
1165     return m_boxesToOffsetMap.contains(box);
1166 }
1167
1168 LayoutUnit RenderFlowThread::cachedOffsetFromLogicalTopOfFirstRegion(const RenderBox* box) const
1169 {
1170     return m_boxesToOffsetMap.get(box);
1171 }
1172
1173 void RenderFlowThread::setOffsetFromLogicalTopOfFirstRegion(const RenderBox* box, LayoutUnit offset)
1174 {
1175     m_boxesToOffsetMap.set(box, offset);
1176 }
1177
1178 void RenderFlowThread::clearOffsetFromLogicalTopOfFirstRegion(const RenderBox* box)
1179 {
1180     ASSERT(m_boxesToOffsetMap.contains(box));
1181     m_boxesToOffsetMap.remove(box);
1182 }
1183
1184 const RenderBox* RenderFlowThread::currentActiveRenderBox() const
1185 {
1186     if (m_activeObjectsStack.isEmpty())
1187         return nullptr;
1188
1189     const RenderObject* currentObject = m_activeObjectsStack.last();
1190     return is<RenderBox>(*currentObject) ? downcast<RenderBox>(currentObject) : nullptr;
1191 }
1192
1193 void RenderFlowThread::pushFlowThreadLayoutState(const RenderObject& object)
1194 {
1195     m_activeObjectsStack.add(&object);
1196
1197     if (const RenderBox* currentBoxDescendant = currentActiveRenderBox()) {
1198         LayoutState* layoutState = currentBoxDescendant->view().layoutState();
1199         if (layoutState && layoutState->isPaginated()) {
1200             ASSERT(layoutState->m_renderer == currentBoxDescendant);
1201             LayoutSize offsetDelta = layoutState->m_layoutOffset - layoutState->m_pageOffset;
1202             setOffsetFromLogicalTopOfFirstRegion(currentBoxDescendant, currentBoxDescendant->isHorizontalWritingMode() ? offsetDelta.height() : offsetDelta.width());
1203         }
1204     }
1205 }
1206
1207 void RenderFlowThread::popFlowThreadLayoutState()
1208 {
1209     if (const RenderBox* currentBoxDescendant = currentActiveRenderBox()) {
1210         LayoutState* layoutState = currentBoxDescendant->view().layoutState();
1211         if (layoutState && layoutState->isPaginated())
1212             clearOffsetFromLogicalTopOfFirstRegion(currentBoxDescendant);
1213     }
1214
1215     m_activeObjectsStack.removeLast();
1216 }
1217
1218 LayoutUnit RenderFlowThread::offsetFromLogicalTopOfFirstRegion(const RenderBlock* currentBlock) const
1219 {
1220     // First check if we cached the offset for the block if it's an ancestor containing block of the box
1221     // being currently laid out.
1222     if (hasCachedOffsetFromLogicalTopOfFirstRegion(currentBlock))
1223         return cachedOffsetFromLogicalTopOfFirstRegion(currentBlock);
1224
1225     // As a last resort, take the slow path.
1226     LayoutRect blockRect(0, 0, currentBlock->width(), currentBlock->height());
1227     while (currentBlock && !currentBlock->isRenderFlowThread()) {
1228         RenderBlock* containerBlock = currentBlock->containingBlock();
1229         ASSERT(containerBlock);
1230         if (!containerBlock)
1231             return 0;
1232         LayoutPoint currentBlockLocation = currentBlock->location();
1233
1234         if (containerBlock->style().writingMode() != currentBlock->style().writingMode()) {
1235             // We have to put the block rect in container coordinates
1236             // and we have to take into account both the container and current block flipping modes
1237             if (containerBlock->style().isFlippedBlocksWritingMode()) {
1238                 if (containerBlock->isHorizontalWritingMode())
1239                     blockRect.setY(currentBlock->height() - blockRect.maxY());
1240                 else
1241                     blockRect.setX(currentBlock->width() - blockRect.maxX());
1242             }
1243             currentBlock->flipForWritingMode(blockRect);
1244         }
1245         blockRect.moveBy(currentBlockLocation);
1246         currentBlock = containerBlock;
1247     }
1248
1249     return currentBlock->isHorizontalWritingMode() ? blockRect.y() : blockRect.x();
1250 }
1251
1252 void RenderFlowThread::RegionSearchAdapter::collectIfNeeded(const RegionInterval& interval)
1253 {
1254     if (m_result)
1255         return;
1256     if (interval.low() <= m_offset && interval.high() > m_offset)
1257         m_result = interval.data();
1258 }
1259
1260 void RenderFlowThread::mapLocalToContainer(const RenderLayerModelObject* repaintContainer, TransformState& transformState, MapCoordinatesFlags mode, bool* wasFixed) const
1261 {
1262     if (this == repaintContainer)
1263         return;
1264
1265     if (RenderRegion* region = mapFromFlowToRegion(transformState)) {
1266         // FIXME: The cast below is probably not the best solution, we may need to find a better way.
1267         const RenderObject* regionObject = static_cast<const RenderObject*>(region);
1268
1269         // If the repaint container is nullptr, we have to climb up to the RenderView, otherwise swap
1270         // it with the region's repaint container.
1271         repaintContainer = repaintContainer ? region->containerForRepaint() : nullptr;
1272
1273         if (RenderFlowThread* regionFlowThread = region->flowThreadContainingBlock()) {
1274             RenderRegion* startRegion = nullptr;
1275             RenderRegion* endRegion = nullptr;
1276             if (regionFlowThread->getRegionRangeForBox(region, startRegion, endRegion)) {
1277                 CurrentRenderRegionMaintainer regionMaintainer(*startRegion);
1278                 regionObject->mapLocalToContainer(repaintContainer, transformState, mode, wasFixed);
1279                 return;
1280             }
1281         }
1282
1283         regionObject->mapLocalToContainer(repaintContainer, transformState, mode, wasFixed);
1284     }
1285 }
1286
1287 // FIXME: Make this function faster. Walking the render tree is slow, better use a caching mechanism (e.g. |cachedOffsetFromLogicalTopOfFirstRegion|).
1288 LayoutRect RenderFlowThread::mapFromLocalToFlowThread(const RenderBox* box, const LayoutRect& localRect) const
1289 {
1290     LayoutRect boxRect = localRect;
1291
1292     while (box && box != this) {
1293         RenderBlock* containerBlock = box->containingBlock();
1294         ASSERT(containerBlock);
1295         if (!containerBlock)
1296             return LayoutRect();
1297         LayoutPoint currentBoxLocation = box->location();
1298
1299         if (containerBlock->style().writingMode() != box->style().writingMode())
1300             box->flipForWritingMode(boxRect);
1301
1302         boxRect.moveBy(currentBoxLocation);
1303         box = containerBlock;
1304     }
1305
1306     return boxRect;
1307 }
1308
1309 // FIXME: Make this function faster. Walking the render tree is slow, better use a caching mechanism (e.g. |cachedOffsetFromLogicalTopOfFirstRegion|).
1310 LayoutRect RenderFlowThread::mapFromFlowThreadToLocal(const RenderBox* box, const LayoutRect& rect) const
1311 {
1312     LayoutRect localRect = rect;
1313     if (box == this)
1314         return localRect;
1315
1316     RenderBlock* containerBlock = box->containingBlock();
1317     ASSERT(containerBlock);
1318     if (!containerBlock)
1319         return LayoutRect();
1320     localRect = mapFromFlowThreadToLocal(containerBlock, localRect);
1321
1322     LayoutPoint currentBoxLocation = box->location();
1323     localRect.moveBy(-currentBoxLocation);
1324
1325     if (containerBlock->style().writingMode() != box->style().writingMode())
1326         box->flipForWritingMode(localRect);
1327
1328     return localRect;
1329 }
1330
1331 void RenderFlowThread::flipForWritingModeLocalCoordinates(LayoutRect& rect) const
1332 {
1333     if (!style().isFlippedBlocksWritingMode())
1334         return;
1335     
1336     if (isHorizontalWritingMode())
1337         rect.setY(0 - rect.maxY());
1338     else
1339         rect.setX(0 - rect.maxX());
1340 }
1341
1342 void RenderFlowThread::addRegionsVisualEffectOverflow(const RenderBox* box)
1343 {
1344     RenderRegion* startRegion = nullptr;
1345     RenderRegion* endRegion = nullptr;
1346     if (!getRegionRangeForBox(box, startRegion, endRegion))
1347         return;
1348
1349     for (auto iter = m_regionList.find(startRegion), end = m_regionList.end(); iter != end; ++iter) {
1350         RenderRegion* region = *iter;
1351
1352         LayoutRect borderBox = box->borderBoxRectInRegion(region);
1353         borderBox = box->applyVisualEffectOverflow(borderBox);
1354         borderBox = region->rectFlowPortionForBox(box, borderBox);
1355
1356         region->addVisualOverflowForBox(box, borderBox);
1357         if (region == endRegion)
1358             break;
1359     }
1360 }
1361
1362 void RenderFlowThread::addRegionsVisualOverflowFromTheme(const RenderBlock* block)
1363 {
1364     RenderRegion* startRegion = nullptr;
1365     RenderRegion* endRegion = nullptr;
1366     if (!getRegionRangeForBox(block, startRegion, endRegion))
1367         return;
1368
1369     for (auto iter = m_regionList.find(startRegion), end = m_regionList.end(); iter != end; ++iter) {
1370         RenderRegion* region = *iter;
1371
1372         LayoutRect borderBox = block->borderBoxRectInRegion(region);
1373         borderBox = region->rectFlowPortionForBox(block, borderBox);
1374
1375         FloatRect inflatedRect = borderBox;
1376         block->theme().adjustRepaintRect(*block, inflatedRect);
1377
1378         region->addVisualOverflowForBox(block, snappedIntRect(LayoutRect(inflatedRect)));
1379         if (region == endRegion)
1380             break;
1381     }
1382 }
1383
1384 void RenderFlowThread::addRegionsOverflowFromChild(const RenderBox* box, const RenderBox* child, const LayoutSize& delta)
1385 {
1386     RenderRegion* startRegion = nullptr;
1387     RenderRegion* endRegion = nullptr;
1388     if (!getRegionRangeForBox(child, startRegion, endRegion))
1389         return;
1390
1391     RenderRegion* containerStartRegion = nullptr;
1392     RenderRegion* containerEndRegion = nullptr;
1393     if (!getRegionRangeForBox(box, containerStartRegion, containerEndRegion))
1394         return;
1395
1396     for (auto iter = m_regionList.find(startRegion), end = m_regionList.end(); iter != end; ++iter) {
1397         RenderRegion* region = *iter;
1398         if (!regionInRange(region, containerStartRegion, containerEndRegion)) {
1399             if (region == endRegion)
1400                 break;
1401             continue;
1402         }
1403
1404         LayoutRect childLayoutOverflowRect = region->layoutOverflowRectForBoxForPropagation(child);
1405         childLayoutOverflowRect.move(delta);
1406         
1407         // When propagating the layout overflow to the flow thread object, make sure to include
1408         // the logical bottom padding of the scrollable region and the bottom margin of the flowed element.
1409         // In order to behave in a similar manner to the non-regions case, content overflowing the box
1410         // flowed into the region must be painted on top of the region's padding and the box's margin.
1411         // See http://lists.w3.org/Archives/Public/www-style/2014Jan/0089.html
1412         if (is<RenderNamedFlowThread>(*box)) {
1413             ASSERT(box == this);
1414             RenderBlockFlow& fragmentContainer = downcast<RenderNamedFlowFragment>(*region).fragmentContainer();
1415             LayoutUnit spacingAfterLayout = fragmentContainer.paddingAfter() + child->marginAfter();
1416             if (isHorizontalWritingMode()) {
1417                 if (fragmentContainer.scrollsOverflowY()) {
1418                     LayoutUnit layoutMaxLogicalY = region->rectFlowPortionForBox(child, child->frameRect()).maxY() + spacingAfterLayout;
1419                     LayoutUnit maxYDiff = layoutMaxLogicalY - childLayoutOverflowRect.maxY();
1420                     if (maxYDiff > 0)
1421                         childLayoutOverflowRect.expand(0, maxYDiff);
1422                 }
1423             } else {
1424                 if (fragmentContainer.scrollsOverflowX()) {
1425                     LayoutUnit layoutMaxLogicalY = region->rectFlowPortionForBox(child, child->frameRect()).maxX() + spacingAfterLayout;
1426                     LayoutUnit maxYDiff = layoutMaxLogicalY - childLayoutOverflowRect.maxX();
1427                     if (maxYDiff > 0)
1428                         childLayoutOverflowRect.expand(maxYDiff, 0);
1429                 }
1430             }
1431         }
1432         
1433         region->addLayoutOverflowForBox(box, childLayoutOverflowRect);
1434
1435         if (child->hasSelfPaintingLayer() || box->hasOverflowClip()) {
1436             if (region == endRegion)
1437                 break;
1438             continue;
1439         }
1440         LayoutRect childVisualOverflowRect = region->visualOverflowRectForBoxForPropagation(*child);
1441         childVisualOverflowRect.move(delta);
1442         region->addVisualOverflowForBox(box, childVisualOverflowRect);
1443
1444         if (region == endRegion)
1445             break;
1446     }
1447 }
1448     
1449 void RenderFlowThread::addRegionsLayoutOverflow(const RenderBox* box, const LayoutRect& layoutOverflow)
1450 {
1451     RenderRegion* startRegion = nullptr;
1452     RenderRegion* endRegion = nullptr;
1453     if (!getRegionRangeForBox(box, startRegion, endRegion))
1454         return;
1455
1456     for (auto iter = m_regionList.find(startRegion), end = m_regionList.end(); iter != end; ++iter) {
1457         RenderRegion* region = *iter;
1458         LayoutRect layoutOverflowInRegion = region->rectFlowPortionForBox(box, layoutOverflow);
1459
1460         region->addLayoutOverflowForBox(box, layoutOverflowInRegion);
1461
1462         if (region == endRegion)
1463             break;
1464     }
1465 }
1466
1467 void RenderFlowThread::addRegionsVisualOverflow(const RenderBox* box, const LayoutRect& visualOverflow)
1468 {
1469     RenderRegion* startRegion = nullptr;
1470     RenderRegion* endRegion = nullptr;
1471     if (!getRegionRangeForBox(box, startRegion, endRegion))
1472         return;
1473     
1474     for (RenderRegionList::iterator iter = m_regionList.find(startRegion); iter != m_regionList.end(); ++iter) {
1475         RenderRegion* region = *iter;
1476         LayoutRect visualOverflowInRegion = region->rectFlowPortionForBox(box, visualOverflow);
1477         
1478         region->addVisualOverflowForBox(box, visualOverflowInRegion);
1479         
1480         if (region == endRegion)
1481             break;
1482     }
1483 }
1484
1485 void RenderFlowThread::clearRegionsOverflow(const RenderBox* box)
1486 {
1487     RenderRegion* startRegion = nullptr;
1488     RenderRegion* endRegion = nullptr;
1489     if (!getRegionRangeForBox(box, startRegion, endRegion))
1490         return;
1491
1492     for (auto iter = m_regionList.find(startRegion), end = m_regionList.end(); iter != end; ++iter) {
1493         RenderRegion* region = *iter;
1494         RenderBoxRegionInfo* boxInfo = region->renderBoxRegionInfo(box);
1495         if (boxInfo && boxInfo->overflow())
1496             boxInfo->clearOverflow();
1497
1498         if (region == endRegion)
1499             break;
1500     }
1501 }
1502
1503 RenderRegion* RenderFlowThread::currentRegion() const
1504 {
1505     return m_currentRegionMaintainer ? &m_currentRegionMaintainer->region() : nullptr;
1506 }
1507
1508 ContainingRegionMap& RenderFlowThread::containingRegionMap()
1509 {
1510     if (!m_lineToRegionMap)
1511         m_lineToRegionMap = std::make_unique<ContainingRegionMap>();
1512
1513     return *m_lineToRegionMap.get();
1514 }
1515
1516
1517 } // namespace WebCore