Replace PassRef with Ref/Ref&& across the board.
[WebKit-https.git] / Source / WebCore / rendering / RenderMultiColumnFlowThread.cpp
1 /*
2  * Copyright (C) 2012 Apple Inc.  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  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS IN..0TERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "RenderMultiColumnFlowThread.h"
28
29 #include "HitTestResult.h"
30 #include "LayoutState.h"
31 #include "RenderIterator.h"
32 #include "RenderMultiColumnSet.h"
33 #include "RenderMultiColumnSpannerPlaceholder.h"
34 #include "RenderView.h"
35 #include "TransformState.h"
36
37 namespace WebCore {
38
39 bool RenderMultiColumnFlowThread::gShiftingSpanner = false;
40
41 RenderMultiColumnFlowThread::RenderMultiColumnFlowThread(Document& document, Ref<RenderStyle>&& style)
42     : RenderFlowThread(document, WTF::move(style))
43     , m_lastSetWorkedOn(nullptr)
44     , m_columnCount(1)
45     , m_columnWidth(0)
46     , m_columnHeightAvailable(0)
47     , m_inLayout(false)
48     , m_inBalancingPass(false)
49     , m_needsHeightsRecalculation(false)
50     , m_progressionIsInline(false)
51     , m_progressionIsReversed(false)
52     , m_beingEvacuated(false)
53 {
54     setFlowThreadState(InsideInFlowThread);
55 }
56
57 RenderMultiColumnFlowThread::~RenderMultiColumnFlowThread()
58 {
59 }
60
61 void RenderMultiColumnFlowThread::removeFlowChildInfo(RenderObject* child)
62 {
63     RenderFlowThread::removeFlowChildInfo(child);
64     flowThreadRelativeWillBeRemoved(child);
65 }
66
67 const char* RenderMultiColumnFlowThread::renderName() const
68 {    
69     return "RenderMultiColumnFlowThread";
70 }
71
72 RenderMultiColumnSet* RenderMultiColumnFlowThread::firstMultiColumnSet() const
73 {
74     for (RenderObject* sibling = nextSibling(); sibling; sibling = sibling->nextSibling()) {
75         if (is<RenderMultiColumnSet>(*sibling))
76             return downcast<RenderMultiColumnSet>(sibling);
77     }
78     return nullptr;
79 }
80
81 RenderMultiColumnSet* RenderMultiColumnFlowThread::lastMultiColumnSet() const
82 {
83     for (RenderObject* sibling = multiColumnBlockFlow()->lastChild(); sibling; sibling = sibling->previousSibling()) {
84         if (is<RenderMultiColumnSet>(*sibling))
85             return downcast<RenderMultiColumnSet>(sibling);
86     }
87     return nullptr;
88 }
89
90 RenderBox* RenderMultiColumnFlowThread::firstColumnSetOrSpanner() const
91 {
92     if (RenderObject* sibling = nextSibling()) {
93         ASSERT(is<RenderBox>(*sibling));
94         ASSERT(is<RenderMultiColumnSet>(*sibling) || findColumnSpannerPlaceholder(downcast<RenderBox>(sibling)));
95         return downcast<RenderBox>(sibling);
96     }
97     return nullptr;
98 }
99
100 RenderBox* RenderMultiColumnFlowThread::nextColumnSetOrSpannerSiblingOf(const RenderBox* child)
101 {
102     if (!child)
103         return nullptr;
104     if (RenderObject* sibling = child->nextSibling())
105         return downcast<RenderBox>(sibling);
106     return nullptr;
107 }
108
109 RenderBox* RenderMultiColumnFlowThread::previousColumnSetOrSpannerSiblingOf(const RenderBox* child)
110 {
111     if (!child)
112         return nullptr;
113     if (RenderObject* sibling = child->previousSibling()) {
114         if (is<RenderFlowThread>(*sibling))
115             return nullptr;
116         return downcast<RenderBox>(sibling);
117     }
118     return nullptr;
119 }
120
121 void RenderMultiColumnFlowThread::layout()
122 {
123     ASSERT(!m_inLayout);
124     m_inLayout = true;
125     m_lastSetWorkedOn = nullptr;
126     if (RenderBox* first = firstColumnSetOrSpanner()) {
127         if (is<RenderMultiColumnSet>(*first)) {
128             m_lastSetWorkedOn = downcast<RenderMultiColumnSet>(first);
129             m_lastSetWorkedOn->beginFlow(this);
130         }
131     }
132     RenderFlowThread::layout();
133     if (RenderMultiColumnSet* lastSet = lastMultiColumnSet()) {
134         if (!nextColumnSetOrSpannerSiblingOf(lastSet))
135             lastSet->endFlow(this, logicalHeight());
136         lastSet->expandToEncompassFlowThreadContentsIfNeeded();
137     }
138     m_inLayout = false;
139     m_lastSetWorkedOn = nullptr;
140 }
141
142 RenderMultiColumnSet* RenderMultiColumnFlowThread::findSetRendering(RenderObject* renderer) const
143 {
144     for (RenderMultiColumnSet* multicolSet = firstMultiColumnSet(); multicolSet; multicolSet = multicolSet->nextSiblingMultiColumnSet()) {
145         if (multicolSet->containsRendererInFlowThread(renderer))
146             return multicolSet;
147     }
148     return nullptr;
149 }
150
151 void RenderMultiColumnFlowThread::populate()
152 {
153     RenderBlockFlow* multicolContainer = multiColumnBlockFlow();
154     ASSERT(!nextSibling());
155     // Reparent children preceding the flow thread into the flow thread. It's multicol content
156     // now. At this point there's obviously nothing after the flow thread, but renderers (column
157     // sets and spanners) will be inserted there as we insert elements into the flow thread.
158     LayoutStateDisabler layoutStateDisabler(&view());
159     multicolContainer->moveChildrenTo(this, multicolContainer->firstChild(), this, true);
160 }
161
162 void RenderMultiColumnFlowThread::evacuateAndDestroy()
163 {
164     RenderBlockFlow* multicolContainer = multiColumnBlockFlow();
165     m_beingEvacuated = true;
166     
167     // Delete the line box tree.
168     deleteLines();
169     
170     LayoutStateDisabler layoutStateDisabler(&view());
171
172     // First promote all children of the flow thread. Before we move them to the flow thread's
173     // container, we need to unregister the flow thread, so that they aren't just re-added again to
174     // the flow thread that we're trying to empty.
175     multicolContainer->setMultiColumnFlowThread(nullptr);
176     moveAllChildrenTo(multicolContainer, true);
177
178     // Move spanners back to their original DOM position in the tree, and destroy the placeholders.
179     SpannerMap::iterator it;
180     while ((it = m_spannerMap.begin()) != m_spannerMap.end()) {
181         RenderBox* spanner = it->key;
182         RenderMultiColumnSpannerPlaceholder* placeholder = it->value;
183         RenderBlockFlow& originalContainer = downcast<RenderBlockFlow>(*placeholder->parent());
184         multicolContainer->removeChild(*spanner);
185         originalContainer.addChild(spanner, placeholder);
186         placeholder->destroy();
187         m_spannerMap.remove(it);
188     }
189
190     // Remove all sets.
191     while (RenderMultiColumnSet* columnSet = firstMultiColumnSet())
192         columnSet->destroy();
193     
194     destroy();
195 }
196
197 void RenderMultiColumnFlowThread::addRegionToThread(RenderRegion* renderRegion)
198 {
199     auto* columnSet = downcast<RenderMultiColumnSet>(renderRegion);
200     if (RenderMultiColumnSet* nextSet = columnSet->nextSiblingMultiColumnSet()) {
201         RenderRegionList::iterator it = m_regionList.find(nextSet);
202         ASSERT(it != m_regionList.end());
203         m_regionList.insertBefore(it, columnSet);
204     } else
205         m_regionList.add(columnSet);
206     renderRegion->setIsValid(true);
207 }
208
209 void RenderMultiColumnFlowThread::willBeRemovedFromTree()
210 {
211     // Detach all column sets from the flow thread. Cannot destroy them at this point, since they
212     // are siblings of this object, and there may be pointers to this object's sibling somewhere
213     // further up on the call stack.
214     for (RenderMultiColumnSet* columnSet = firstMultiColumnSet(); columnSet; columnSet = columnSet->nextSiblingMultiColumnSet())
215         columnSet->detachRegion();
216     multiColumnBlockFlow()->setMultiColumnFlowThread(nullptr);
217     RenderFlowThread::willBeRemovedFromTree();
218 }
219
220 RenderObject* RenderMultiColumnFlowThread::resolveMovedChild(RenderObject* child) const
221 {
222     if (child->style().columnSpan() != ColumnSpanAll || !is<RenderBox>(*child)) {
223         // We only need to resolve for column spanners.
224         return child;
225     }
226     // The renderer for the actual DOM node that establishes a spanner is moved from its original
227     // location in the render tree to becoming a sibling of the column sets. In other words, it's
228     // moved out from the flow thread (and becomes a sibling of it). When we for instance want to
229     // create and insert a renderer for the sibling node immediately preceding the spanner, we need
230     // to map that spanner renderer to the spanner's placeholder, which is where the new inserted
231     // renderer belongs.
232     if (RenderMultiColumnSpannerPlaceholder* placeholder = findColumnSpannerPlaceholder(downcast<RenderBox>(child)))
233         return placeholder;
234
235     // This is an invalid spanner, or its placeholder hasn't been created yet. This happens when
236     // moving an entire subtree into the flow thread, when we are processing the insertion of this
237     // spanner's preceding sibling, and we obviously haven't got as far as processing this spanner
238     // yet.
239     return child;
240 }
241
242 static bool isValidColumnSpanner(RenderMultiColumnFlowThread* flowThread, RenderObject* descendant)
243 {
244     // We assume that we're inside the flow thread. This function is not to be called otherwise.
245     ASSERT(descendant->isDescendantOf(flowThread));
246
247     // First make sure that the renderer itself has the right properties for becoming a spanner.
248     RenderStyle& style = descendant->style();
249     if (style.columnSpan() != ColumnSpanAll || !is<RenderBox>(*descendant) || descendant->isFloatingOrOutOfFlowPositioned())
250         return false;
251
252     RenderElement* container = descendant->parent();
253     if (!is<RenderBlockFlow>(*container) || container->childrenInline()) {
254         // Needs to be block-level.
255         return false;
256     }
257     
258     // We need to have the flow thread as the containing block. A spanner cannot break out of the flow thread.
259     RenderFlowThread* enclosingFlowThread = descendant->flowThreadContainingBlock();
260     if (enclosingFlowThread != flowThread)
261         return false;
262
263     // This looks like a spanner, but if we're inside something unbreakable, it's not to be treated as one.
264     for (RenderBox* ancestor = downcast<RenderBox>(*descendant).containingBlock(); ancestor; ancestor = ancestor->containingBlock()) {
265         if (ancestor->isRenderFlowThread()) {
266             // Don't allow any intervening non-multicol fragmentation contexts. The spec doesn't say
267             // anything about disallowing this, but it's just going to be too complicated to
268             // implement (not to mention specify behavior).
269             return ancestor == flowThread;
270         }
271         ASSERT(ancestor->style().columnSpan() != ColumnSpanAll || !isValidColumnSpanner(flowThread, ancestor));
272         if (ancestor->isUnsplittableForPagination())
273             return false;
274     }
275     ASSERT_NOT_REACHED();
276     return false;
277 }
278
279 RenderObject* RenderMultiColumnFlowThread::processPossibleSpannerDescendant(RenderObject*& subtreeRoot, RenderObject* descendant)
280 {
281     RenderBlockFlow* multicolContainer = multiColumnBlockFlow();
282     RenderObject* nextRendererInFlowThread = descendant->nextInPreOrderAfterChildren(this);
283     RenderObject* insertBeforeMulticolChild = nullptr;
284     RenderObject* nextDescendant = descendant;
285
286     if (isValidColumnSpanner(this, descendant)) {
287         // This is a spanner (column-span:all). Such renderers are moved from where they would
288         // otherwise occur in the render tree to becoming a direct child of the multicol container,
289         // so that they live among the column sets. This simplifies the layout implementation, and
290         // basically just relies on regular block layout done by the RenderBlockFlow that
291         // establishes the multicol container.
292         RenderBlockFlow* container = downcast<RenderBlockFlow>(descendant->parent());
293         RenderMultiColumnSet* setToSplit = nullptr;
294         if (nextRendererInFlowThread) {
295             setToSplit = findSetRendering(descendant);
296             if (setToSplit) {
297                 setToSplit->setNeedsLayout();
298                 insertBeforeMulticolChild = setToSplit->nextSibling();
299             }
300         }
301         // Moving a spanner's renderer so that it becomes a sibling of the column sets requires us
302         // to insert an anonymous placeholder in the tree where the spanner's renderer otherwise
303         // would have been. This is needed for a two reasons: We need a way of separating inline
304         // content before and after the spanner, so that it becomes separate line boxes. Secondly,
305         // this placeholder serves as a break point for column sets, so that, when encountered, we
306         // end flowing one column set and move to the next one.
307         RenderMultiColumnSpannerPlaceholder* placeholder = RenderMultiColumnSpannerPlaceholder::createAnonymous(this, downcast<RenderBox>(descendant), &container->style());
308         container->addChild(placeholder, descendant->nextSibling());
309         container->removeChild(*descendant);
310         
311         // This is a guard to stop an ancestor flow thread from processing the spanner.
312         gShiftingSpanner = true;
313         multicolContainer->RenderBlock::addChild(descendant, insertBeforeMulticolChild);
314         gShiftingSpanner = false;
315         
316         // The spanner has now been moved out from the flow thread, but we don't want to
317         // examine its children anyway. They are all part of the spanner and shouldn't trigger
318         // creation of column sets or anything like that. Continue at its original position in
319         // the tree, i.e. where the placeholder was just put.
320         if (subtreeRoot == descendant)
321             subtreeRoot = placeholder;
322         nextDescendant = placeholder;
323     } else {
324         // This is regular multicol content, i.e. not part of a spanner.
325         if (is<RenderMultiColumnSpannerPlaceholder>(nextRendererInFlowThread)) {
326             // Inserted right before a spanner. Is there a set for us there?
327             RenderMultiColumnSpannerPlaceholder& placeholder = downcast<RenderMultiColumnSpannerPlaceholder>(*nextRendererInFlowThread);
328             if (RenderObject* previous = placeholder.spanner()->previousSibling()) {
329                 if (is<RenderMultiColumnSet>(*previous))
330                     return nextDescendant; // There's already a set there. Nothing to do.
331             }
332             insertBeforeMulticolChild = placeholder.spanner();
333         } else if (RenderMultiColumnSet* lastSet = lastMultiColumnSet()) {
334             // This child is not an immediate predecessor of a spanner, which means that if this
335             // child precedes a spanner at all, there has to be a column set created for us there
336             // already. If it doesn't precede any spanner at all, on the other hand, we need a
337             // column set at the end of the multicol container. We don't really check here if the
338             // child inserted precedes any spanner or not (as that's an expensive operation). Just
339             // make sure we have a column set at the end. It's no big deal if it remains unused.
340             if (!lastSet->nextSibling())
341                 return nextDescendant;
342         }
343     }
344     // Need to create a new column set when there's no set already created. We also always insert
345     // another column set after a spanner. Even if it turns out that there are no renderers
346     // following the spanner, there may be bottom margins there, which take up space.
347     RenderMultiColumnSet* newSet = new RenderMultiColumnSet(*this, RenderStyle::createAnonymousStyleWithDisplay(&multicolContainer->style(), BLOCK));
348     newSet->initializeStyle();
349     multicolContainer->RenderBlock::addChild(newSet, insertBeforeMulticolChild);
350     invalidateRegions();
351
352     // We cannot handle immediate column set siblings at the moment (and there's no need for
353     // it, either). There has to be at least one spanner separating them.
354     ASSERT(!previousColumnSetOrSpannerSiblingOf(newSet) || !previousColumnSetOrSpannerSiblingOf(newSet)->isRenderMultiColumnSet());
355     ASSERT(!nextColumnSetOrSpannerSiblingOf(newSet) || !nextColumnSetOrSpannerSiblingOf(newSet)->isRenderMultiColumnSet());
356     
357     return nextDescendant;
358 }
359
360 void RenderMultiColumnFlowThread::flowThreadDescendantInserted(RenderObject* descendant)
361 {
362     if (gShiftingSpanner || m_beingEvacuated || descendant->isInFlowRenderFlowThread())
363         return;
364     RenderObject* subtreeRoot = descendant;
365     for (; descendant; descendant = (descendant ? descendant->nextInPreOrder(subtreeRoot) : nullptr)) {
366         if (is<RenderMultiColumnSpannerPlaceholder>(*descendant)) {
367             // A spanner's placeholder has been inserted. The actual spanner renderer is moved from
368             // where it would otherwise occur (if it weren't a spanner) to becoming a sibling of the
369             // column sets.
370             RenderMultiColumnSpannerPlaceholder& placeholder = downcast<RenderMultiColumnSpannerPlaceholder>(*descendant);
371             if (placeholder.flowThread() != this) {
372                 // This isn't our spanner! It shifted here from an ancestor multicolumn block. It's going to end up
373                 // becoming our spanner instead, but for it to do that we first have to nuke the original spanner,
374                 // and get the spanner content back into this flow thread.
375                 RenderBox* spanner = placeholder.spanner();
376                 
377                 // Insert after the placeholder, but don't let a notification happen.
378                 gShiftingSpanner = true;
379                 RenderBlockFlow& ancestorBlock = downcast<RenderBlockFlow>(*spanner->parent());
380                 ancestorBlock.moveChildTo(placeholder.parentBox(), spanner, placeholder.nextSibling(), true);
381                 gShiftingSpanner = false;
382                 
383                 // We have to nuke the placeholder, since the ancestor already lost the mapping to it when
384                 // we shifted the placeholder down into this flow thread.
385                 if (subtreeRoot == descendant)
386                     subtreeRoot = spanner;
387                 placeholder.parent()->removeChild(placeholder);
388
389                 // Now we process the spanner.
390                 descendant = processPossibleSpannerDescendant(subtreeRoot, spanner);
391                 continue;
392             }
393             
394             ASSERT(!m_spannerMap.get(placeholder.spanner()));
395             m_spannerMap.add(placeholder.spanner(), &placeholder);
396             ASSERT(!placeholder.firstChild()); // There should be no children here, but if there are, we ought to skip them.
397             continue;
398         }
399         
400         descendant = processPossibleSpannerDescendant(subtreeRoot, descendant);
401     }
402 }
403
404 void RenderMultiColumnFlowThread::handleSpannerRemoval(RenderObject* spanner)
405 {
406      // The placeholder may already have been removed, but if it hasn't, do so now.
407     if (RenderMultiColumnSpannerPlaceholder* placeholder = m_spannerMap.get(downcast<RenderBox>(spanner))) {
408         placeholder->parent()->removeChild(*placeholder);
409         m_spannerMap.remove(downcast<RenderBox>(spanner));
410     }
411
412     if (RenderObject* next = spanner->nextSibling()) {
413         if (RenderObject* previous = spanner->previousSibling()) {
414             if (previous->isRenderMultiColumnSet() && next->isRenderMultiColumnSet()) {
415                 // Merge two sets that no longer will be separated by a spanner.
416                 next->destroy();
417                 previous->setNeedsLayout();
418             }
419         }
420     }
421 }
422
423 void RenderMultiColumnFlowThread::flowThreadRelativeWillBeRemoved(RenderObject* relative)
424 {
425     if (m_beingEvacuated)
426         return;
427     invalidateRegions();
428     if (is<RenderMultiColumnSpannerPlaceholder>(*relative)) {
429         // Remove the map entry for this spanner, but leave the actual spanner renderer alone. Also
430         // keep the reference to the spanner, since the placeholder may be about to be re-inserted
431         // in the tree.
432         ASSERT(relative->isDescendantOf(this));
433         m_spannerMap.remove(downcast<RenderMultiColumnSpannerPlaceholder>(*relative).spanner());
434         return;
435     }
436     if (relative->style().columnSpan() == ColumnSpanAll) {
437         if (relative->parent() != parent())
438             return; // not a valid spanner.
439         
440         handleSpannerRemoval(relative);
441     }
442     // Note that we might end up with empty column sets if all column content is removed. That's no
443     // big deal though (and locating them would be expensive), and they will be found and re-used if
444     // content is added again later.
445 }
446
447 void RenderMultiColumnFlowThread::flowThreadDescendantBoxLaidOut(RenderBox* descendant)
448 {
449     if (!is<RenderMultiColumnSpannerPlaceholder>(*descendant))
450         return;
451     auto& placeholder = downcast<RenderMultiColumnSpannerPlaceholder>(*descendant);
452     RenderBlock* container = placeholder.containingBlock();
453
454     for (RenderBox* prev = previousColumnSetOrSpannerSiblingOf(placeholder.spanner()); prev; prev = previousColumnSetOrSpannerSiblingOf(prev)) {
455         if (is<RenderMultiColumnSet>(*prev)) {
456             downcast<RenderMultiColumnSet>(*prev).endFlow(container, placeholder.logicalTop());
457             break;
458         }
459     }
460
461     for (RenderBox* next = nextColumnSetOrSpannerSiblingOf(placeholder.spanner()); next; next = nextColumnSetOrSpannerSiblingOf(next)) {
462         if (is<RenderMultiColumnSet>(*next)) {
463             m_lastSetWorkedOn = downcast<RenderMultiColumnSet>(next);
464             m_lastSetWorkedOn->beginFlow(container);
465             break;
466         }
467     }
468 }
469
470 void RenderMultiColumnFlowThread::computeLogicalHeight(LayoutUnit logicalHeight, LayoutUnit logicalTop, LogicalExtentComputedValues& computedValues) const
471 {
472     // We simply remain at our intrinsic height.
473     computedValues.m_extent = logicalHeight;
474     computedValues.m_position = logicalTop;
475 }
476
477 LayoutUnit RenderMultiColumnFlowThread::initialLogicalWidth() const
478 {
479     return columnWidth();
480 }
481
482 void RenderMultiColumnFlowThread::setPageBreak(const RenderBlock* block, LayoutUnit offset, LayoutUnit spaceShortage)
483 {
484     if (auto* multicolSet = downcast<RenderMultiColumnSet>(regionAtBlockOffset(block, offset)))
485         multicolSet->recordSpaceShortage(spaceShortage);
486 }
487
488 void RenderMultiColumnFlowThread::updateMinimumPageHeight(const RenderBlock* block, LayoutUnit offset, LayoutUnit minHeight)
489 {
490     if (auto* multicolSet = downcast<RenderMultiColumnSet>(regionAtBlockOffset(block, offset)))
491         multicolSet->updateMinimumColumnHeight(minHeight);
492 }
493
494 RenderRegion* RenderMultiColumnFlowThread::regionAtBlockOffset(const RenderBox* box, LayoutUnit offset, bool extendLastRegion) const
495 {
496     if (!m_inLayout)
497         return RenderFlowThread::regionAtBlockOffset(box, offset, extendLastRegion);
498
499     // Layout in progress. We are calculating the set heights as we speak, so the region range
500     // information is not up-to-date.
501
502     RenderMultiColumnSet* columnSet = m_lastSetWorkedOn ? m_lastSetWorkedOn : firstMultiColumnSet();
503     if (!columnSet) {
504         // If there's no set, bail. This multicol is empty or only consists of spanners. There
505         // are no regions.
506         return nullptr;
507     }
508     // The last set worked on is a good guess. But if we're not within the bounds, search for the
509     // right one.
510     if (offset < columnSet->logicalTopInFlowThread()) {
511         do {
512             if (RenderMultiColumnSet* prev = columnSet->previousSiblingMultiColumnSet())
513                 columnSet = prev;
514             else
515                 break;
516         } while (offset < columnSet->logicalTopInFlowThread());
517     } else {
518         while (offset >= columnSet->logicalBottomInFlowThread()) {
519             RenderMultiColumnSet* next = columnSet->nextSiblingMultiColumnSet();
520             if (!next || !next->hasBeenFlowed())
521                 break;
522             columnSet = next;
523         }
524     }
525     return columnSet;
526 }
527
528 void RenderMultiColumnFlowThread::setRegionRangeForBox(const RenderBox* box, RenderRegion* startRegion, RenderRegion* endRegion)
529 {
530     // Some column sets may have zero height, which means that two or more sets may start at the
531     // exact same flow thread position, which means that some parts of the code may believe that a
532     // given box lives in sets that it doesn't really live in. Make some adjustments here and
533     // include such sets if they are adjacent to the start and/or end regions.
534     for (RenderMultiColumnSet* columnSet = downcast<RenderMultiColumnSet>(*startRegion).previousSiblingMultiColumnSet(); columnSet; columnSet = columnSet->previousSiblingMultiColumnSet()) {
535         if (columnSet->logicalHeightInFlowThread())
536             break;
537         startRegion = columnSet;
538     }
539     for (RenderMultiColumnSet* columnSet = downcast<RenderMultiColumnSet>(*startRegion).nextSiblingMultiColumnSet(); columnSet; columnSet = columnSet->nextSiblingMultiColumnSet()) {
540         if (columnSet->logicalHeightInFlowThread())
541             break;
542         endRegion = columnSet;
543     }
544
545     RenderFlowThread::setRegionRangeForBox(box, startRegion, endRegion);
546 }
547
548 bool RenderMultiColumnFlowThread::addForcedRegionBreak(const RenderBlock* block, LayoutUnit offset, RenderBox* /*breakChild*/, bool /*isBefore*/, LayoutUnit* offsetBreakAdjustment)
549 {
550     if (auto* multicolSet = downcast<RenderMultiColumnSet>(regionAtBlockOffset(block, offset))) {
551         multicolSet->addForcedBreak(offset);
552         if (offsetBreakAdjustment)
553             *offsetBreakAdjustment = pageLogicalHeightForOffset(offset) ? pageRemainingLogicalHeightForOffset(offset, IncludePageBoundary) : LayoutUnit::fromPixel(0);
554         return true;
555     }
556     return false;
557 }
558
559 void RenderMultiColumnFlowThread::computeLineGridPaginationOrigin(LayoutState& layoutState) const
560 {
561     if (!progressionIsInline())
562         return;
563     
564     // We need to cache a line grid pagination origin so that we understand how to reset the line grid
565     // at the top of each column.
566     // Get the current line grid and offset.
567     const auto lineGrid = layoutState.lineGrid();
568     if (!lineGrid)
569         return;
570
571     // Get the hypothetical line box used to establish the grid.
572     auto lineGridBox = lineGrid->lineGridBox();
573     if (!lineGridBox)
574         return;
575     
576     bool isHorizontalWritingMode = lineGrid->isHorizontalWritingMode();
577
578     LayoutUnit lineGridBlockOffset = isHorizontalWritingMode ? layoutState.lineGridOffset().height() : layoutState.lineGridOffset().width();
579
580     // Now determine our position on the grid. Our baseline needs to be adjusted to the nearest baseline multiple
581     // as established by the line box.
582     // FIXME: Need to handle crazy line-box-contain values that cause the root line box to not be considered. I assume
583     // the grid should honor line-box-contain.
584     LayoutUnit gridLineHeight = lineGridBox->lineBottomWithLeading() - lineGridBox->lineTopWithLeading();
585     if (!gridLineHeight)
586         return;
587
588     LayoutUnit firstLineTopWithLeading = lineGridBlockOffset + lineGridBox->lineTopWithLeading();
589     
590     if (layoutState.isPaginated() && layoutState.pageLogicalHeight()) {
591         LayoutUnit pageLogicalTop = isHorizontalWritingMode ? layoutState.pageOffset().height() : layoutState.pageOffset().width();
592         if (pageLogicalTop > firstLineTopWithLeading) {
593             // Shift to the next highest line grid multiple past the page logical top. Cache the delta
594             // between this new value and the page logical top as the pagination origin.
595             LayoutUnit remainder = roundToInt(pageLogicalTop - firstLineTopWithLeading) % roundToInt(gridLineHeight);
596             LayoutUnit paginationDelta = gridLineHeight - remainder;
597             if (isHorizontalWritingMode)
598                 layoutState.setLineGridPaginationOrigin(LayoutSize(layoutState.lineGridPaginationOrigin().width(), paginationDelta));
599             else
600                 layoutState.setLineGridPaginationOrigin(LayoutSize(paginationDelta, layoutState.lineGridPaginationOrigin().height()));
601         }
602     }
603 }
604
605 LayoutSize RenderMultiColumnFlowThread::offsetFromContainer(RenderElement& enclosingContainer, const LayoutPoint& physicalPoint, bool* offsetDependsOnPoint) const
606 {
607     ASSERT(&enclosingContainer == container());
608
609     if (offsetDependsOnPoint)
610         *offsetDependsOnPoint = true;
611     
612     LayoutPoint translatedPhysicalPoint(physicalPoint);
613     if (RenderRegion* region = physicalTranslationFromFlowToRegion(translatedPhysicalPoint))
614         translatedPhysicalPoint.moveBy(region->topLeftLocation());
615     
616     LayoutSize offset(translatedPhysicalPoint.x(), translatedPhysicalPoint.y());
617     if (is<RenderBox>(enclosingContainer))
618         offset -= downcast<RenderBox>(enclosingContainer).scrolledContentOffset();
619     return offset;
620 }
621     
622 void RenderMultiColumnFlowThread::mapAbsoluteToLocalPoint(MapCoordinatesFlags mode, TransformState& transformState) const
623 {
624     // First get the transform state's point into the block flow thread's physical coordinate space.
625     parent()->mapAbsoluteToLocalPoint(mode, transformState);
626     LayoutPoint transformPoint(transformState.mappedPoint());
627     
628     // Now walk through each region.
629     const RenderMultiColumnSet* candidateColumnSet = nullptr;
630     LayoutPoint candidatePoint;
631     LayoutSize candidateContainerOffset;
632     
633     for (const auto& columnSet : childrenOfType<RenderMultiColumnSet>(*parent())) {
634         candidateContainerOffset = columnSet.offsetFromContainer(*parent(), LayoutPoint());
635         
636         candidatePoint = transformPoint - candidateContainerOffset;
637         candidateColumnSet = &columnSet;
638         
639         // We really have no clue what to do with overflow. We'll just use the closest region to the point in that case.
640         LayoutUnit pointOffset = isHorizontalWritingMode() ? candidatePoint.y() : candidatePoint.x();
641         LayoutUnit regionOffset = isHorizontalWritingMode() ? columnSet.topLeftLocation().y() : columnSet.topLeftLocation().x();
642         if (pointOffset < regionOffset + columnSet.logicalHeight())
643             break;
644     }
645     
646     // Once we have a good guess as to which region we hit tested through (and yes, this was just a heuristic, but it's
647     // the best we could do), then we can map from the region into the flow thread.
648     LayoutSize translationOffset = physicalTranslationFromRegionToFlow(candidateColumnSet, candidatePoint) + candidateContainerOffset;
649     bool preserve3D = mode & UseTransforms && (parent()->style().preserves3D() || style().preserves3D());
650     if (mode & UseTransforms && shouldUseTransformFromContainer(parent())) {
651         TransformationMatrix t;
652         getTransformFromContainer(parent(), translationOffset, t);
653         transformState.applyTransform(t, preserve3D ? TransformState::AccumulateTransform : TransformState::FlattenTransform);
654     } else
655         transformState.move(translationOffset.width(), translationOffset.height(), preserve3D ? TransformState::AccumulateTransform : TransformState::FlattenTransform);
656 }
657
658 LayoutSize RenderMultiColumnFlowThread::physicalTranslationFromRegionToFlow(const RenderMultiColumnSet* columnSet, const LayoutPoint& physicalPoint) const
659 {
660     LayoutPoint logicalPoint = columnSet->flipForWritingMode(physicalPoint);
661     LayoutPoint translatedPoint = columnSet->translateRegionPointToFlowThread(logicalPoint);
662     LayoutPoint physicalTranslatedPoint = columnSet->flipForWritingMode(translatedPoint);
663     return physicalPoint - physicalTranslatedPoint;
664 }
665
666 RenderRegion* RenderMultiColumnFlowThread::mapFromFlowToRegion(TransformState& transformState) const
667 {
668     if (!hasValidRegionInfo())
669         return nullptr;
670
671     // Get back into our local flow thread space.
672     LayoutRect boxRect = transformState.mappedQuad().enclosingBoundingBox();
673     flipForWritingMode(boxRect);
674
675     // FIXME: We need to refactor RenderObject::absoluteQuads to be able to split the quads across regions,
676     // for now we just take the center of the mapped enclosing box and map it to a column.
677     LayoutPoint centerPoint = boxRect.center();
678     LayoutUnit centerLogicalOffset = isHorizontalWritingMode() ? centerPoint.y() : centerPoint.x();
679     RenderRegion* renderRegion = regionAtBlockOffset(this, centerLogicalOffset, true);
680     if (!renderRegion)
681         return nullptr;
682     transformState.move(physicalTranslationOffsetFromFlowToRegion(renderRegion, centerLogicalOffset));
683     return renderRegion;
684 }
685
686 LayoutSize RenderMultiColumnFlowThread::physicalTranslationOffsetFromFlowToRegion(const RenderRegion* renderRegion, const LayoutUnit logicalOffset) const
687 {
688     // Now that we know which multicolumn set we hit, we need to get the appropriate translation offset for the column.
689     const auto* columnSet = downcast<RenderMultiColumnSet>(renderRegion);
690     LayoutPoint translationOffset = columnSet->columnTranslationForOffset(logicalOffset);
691     
692     // Now we know how we want the rect to be translated into the region. At this point we're converting
693     // back to physical coordinates.
694     if (style().isFlippedBlocksWritingMode()) {
695         LayoutRect portionRect(columnSet->flowThreadPortionRect());
696         LayoutRect columnRect = columnSet->columnRectAt(0);
697         LayoutUnit physicalDeltaFromPortionBottom = logicalHeight() - columnSet->logicalBottomInFlowThread();
698         if (isHorizontalWritingMode())
699             columnRect.setHeight(portionRect.height());
700         else
701             columnRect.setWidth(portionRect.width());
702         columnSet->flipForWritingMode(columnRect);
703         if (isHorizontalWritingMode())
704             translationOffset.move(0, columnRect.y() - portionRect.y() - physicalDeltaFromPortionBottom);
705         else
706             translationOffset.move(columnRect.x() - portionRect.x() - physicalDeltaFromPortionBottom, 0);
707     }
708     
709     return LayoutSize(translationOffset.x(), translationOffset.y());
710 }
711
712 RenderRegion* RenderMultiColumnFlowThread::physicalTranslationFromFlowToRegion(LayoutPoint& physicalPoint) const
713 {
714     if (!hasValidRegionInfo())
715         return nullptr;
716     
717     // Put the physical point into the flow thread's coordinate space.
718     LayoutPoint logicalPoint = flipForWritingMode(physicalPoint);
719     
720     // Now get the region that we are in.
721     LayoutUnit logicalOffset = isHorizontalWritingMode() ? logicalPoint.y() : logicalPoint.x();
722     RenderRegion* renderRegion = regionAtBlockOffset(this, logicalOffset, true);
723     if (!renderRegion)
724         return nullptr;
725     
726     // Translate to the coordinate space of the region.
727     LayoutSize translationOffset = physicalTranslationOffsetFromFlowToRegion(renderRegion, logicalOffset);
728     
729     // Now shift the physical point into the region's coordinate space.
730     physicalPoint += translationOffset;
731     
732     return renderRegion;
733 }
734
735 bool RenderMultiColumnFlowThread::isPageLogicalHeightKnown() const
736 {
737     if (RenderMultiColumnSet* columnSet = lastMultiColumnSet())
738         return columnSet->computedColumnHeight();
739     return false;
740 }
741
742 bool RenderMultiColumnFlowThread::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction hitTestAction)
743 {
744     // You cannot be inside an in-flow RenderFlowThread without a corresponding DOM node. It's better to
745     // just let the ancestor figure out where we are instead.
746     if (hitTestAction == HitTestBlockBackground)
747         return false;
748     bool inside = RenderFlowThread::nodeAtPoint(request, result, locationInContainer, accumulatedOffset, hitTestAction);
749     if (inside && !result.innerNode())
750         return false;
751     return inside;
752 }
753
754 bool RenderMultiColumnFlowThread::shouldCheckColumnBreaks() const
755 {
756     if (!parent()->isRenderView())
757         return true;
758     return view().frameView().pagination().behavesLikeColumns;
759 }
760
761 }