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