[LFC][Quirk] Move quirk functions to dedicated classes.
[WebKit-https.git] / Source / WebCore / layout / blockformatting / BlockMarginCollapse.cpp
1 /*
2  * Copyright (C) 2018 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. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "BlockFormattingContext.h"
28
29 #if ENABLE(LAYOUT_FORMATTING_CONTEXT)
30
31 #include "LayoutBox.h"
32 #include "LayoutContainer.h"
33 #include "LayoutUnit.h"
34 #include "RenderStyle.h"
35
36 namespace WebCore {
37 namespace Layout {
38
39 static LayoutUnit marginValue(LayoutUnit currentMarginValue, LayoutUnit candidateMarginValue)
40 {
41     if (!candidateMarginValue)
42         return currentMarginValue;
43     if (!currentMarginValue)
44         return candidateMarginValue;
45     // Both margins are positive.
46     if (candidateMarginValue > 0 && currentMarginValue > 0)
47         return std::max(candidateMarginValue, currentMarginValue);
48     // Both margins are negative.
49     if (candidateMarginValue < 0 && currentMarginValue < 0)
50         return 0 - std::max(std::abs(candidateMarginValue.toFloat()), std::abs(currentMarginValue.toFloat()));
51     // One of the margins is negative.
52     return currentMarginValue + candidateMarginValue;
53 }
54
55 static bool isMarginTopCollapsedWithSibling(const Box& layoutBox)
56 {
57     ASSERT(layoutBox.isBlockLevelBox());
58
59     if (layoutBox.isFloatingPositioned())
60         return false;
61
62     if (!layoutBox.isPositioned() || layoutBox.isInFlowPositioned())
63         return true;
64
65     // Out of flow positioned.
66     ASSERT(layoutBox.isOutOfFlowPositioned());
67     return layoutBox.style().top().isAuto();
68 }
69
70 static bool isMarginBottomCollapsedWithSibling(const Box& layoutBox)
71 {
72     ASSERT(layoutBox.isBlockLevelBox());
73
74     if (layoutBox.isFloatingPositioned())
75         return false;
76
77     if (!layoutBox.isPositioned() || layoutBox.isInFlowPositioned())
78         return true;
79
80     // Out of flow positioned.
81     ASSERT(layoutBox.isOutOfFlowPositioned());
82     return layoutBox.style().bottom().isAuto();
83 }
84
85 bool BlockFormattingContext::Geometry::MarginCollapse::isMarginTopCollapsedWithParent(const LayoutState& layoutState, const Box& layoutBox)
86 {
87     // The first inflow child could propagate its top margin to parent.
88     // https://www.w3.org/TR/CSS21/box.html#collapsing-margins
89     if (layoutBox.isAnonymous())
90         return false;
91
92     ASSERT(layoutBox.isBlockLevelBox());
93
94     if (layoutBox.isFloatingOrOutOfFlowPositioned())
95         return false;
96
97     // We never margin collapse the initial containing block.
98     ASSERT(layoutBox.parent());
99     auto& parent = *layoutBox.parent();
100     // Only the first inlflow child collapses with parent.
101     if (layoutBox.previousInFlowSibling())
102         return false;
103
104     if (parent.establishesBlockFormattingContext())
105         return false;
106
107     // Margins of the root element's box do not collapse.
108     if (parent.isDocumentBox() || parent.isInitialContainingBlock())
109         return false;
110
111     auto& parentDisplayBox = layoutState.displayBoxForLayoutBox(parent);
112     if (parentDisplayBox.borderTop())
113         return false;
114
115     if (parentDisplayBox.paddingTop().value_or(0))
116         return false;
117
118     if (BlockFormattingContext::Quirks::shouldIgnoreMarginTop(layoutState, layoutBox))
119         return false;
120
121     return true;
122 }
123
124 static bool isMarginBottomCollapsedThrough(const LayoutState& layoutState, const Box& layoutBox)
125 {
126     ASSERT(layoutBox.isBlockLevelBox());
127
128     // If the top and bottom margins of a box are adjoining, then it is possible for margins to collapse through it.
129     auto& displayBox = layoutState.displayBoxForLayoutBox(layoutBox);
130
131     if (displayBox.borderTop() || displayBox.borderBottom())
132         return false;
133
134     if (displayBox.paddingTop().value_or(0) || displayBox.paddingBottom().value_or(0))
135         return false;
136
137     if (!layoutBox.style().height().isAuto() || !layoutBox.style().minHeight().isAuto())
138         return false;
139
140     if (!is<Container>(layoutBox))
141         return true;
142
143     auto& container = downcast<Container>(layoutBox);
144     if (container.hasInFlowOrFloatingChild())
145         return false;
146
147     return true;
148 }
149
150 LayoutUnit BlockFormattingContext::Geometry::MarginCollapse::collapsedMarginTopFromFirstChild(const LayoutState& layoutState, const Box& layoutBox)
151 {
152     ASSERT(layoutBox.isBlockLevelBox());
153
154     // Check if the first child collapses its margin top.
155     if (!is<Container>(layoutBox) || !downcast<Container>(layoutBox).hasInFlowChild())
156         return 0;
157
158     // Do not collapse margin with a box from a non-block formatting context <div><span>foobar</span></div>.
159     if (layoutBox.establishesFormattingContext() && !layoutBox.establishesBlockFormattingContextOnly())
160         return 0;
161
162     // FIXME: Take collapsed through margin into account.
163     auto& firstInFlowChild = *downcast<Container>(layoutBox).firstInFlowChild();
164     if (!isMarginTopCollapsedWithParent(layoutState, firstInFlowChild))
165         return 0;
166     // Collect collapsed margin top recursively.
167     return marginValue(computedNonCollapsedMarginTop(layoutState, firstInFlowChild), collapsedMarginTopFromFirstChild(layoutState, firstInFlowChild));
168 }
169
170 LayoutUnit BlockFormattingContext::Geometry::MarginCollapse::nonCollapsedMarginTop(const LayoutState& layoutState, const Box& layoutBox)
171 {
172     ASSERT(layoutBox.isBlockLevelBox());
173
174     // Non collapsed margin top includes collapsed margin from inflow first child.
175     return marginValue(computedNonCollapsedMarginTop(layoutState, layoutBox), collapsedMarginTopFromFirstChild(layoutState, layoutBox));
176 }
177
178 /*static bool hasAdjoiningMarginTopAndBottom(const Box&)
179 {
180     // Two margins are adjoining if and only if:
181     // 1. both belong to in-flow block-level boxes that participate in the same block formatting context
182     // 2. no line boxes, no clearance, no padding and no border separate them (Note that certain zero-height line boxes (see 9.4.2) are ignored for this purpose.)
183     // 3. both belong to vertically-adjacent box edges, i.e. form one of the following pairs:
184     //        top margin of a box and top margin of its first in-flow child
185     //        bottom margin of box and top margin of its next in-flow following sibling
186     //        bottom margin of a last in-flow child and bottom margin of its parent if the parent has 'auto' computed height
187     //        top and bottom margins of a box that does not establish a new block formatting context and that has zero computed 'min-height',
188     //        zero or 'auto' computed 'height', and no in-flow children
189     // A collapsed margin is considered adjoining to another margin if any of its component margins is adjoining to that margin.
190     return false;
191 }*/
192 LayoutUnit BlockFormattingContext::Geometry::MarginCollapse::computedNonCollapsedMarginTop(const LayoutState& layoutState, const Box& layoutBox)
193 {
194     ASSERT(layoutBox.isBlockLevelBox());
195
196     return computedNonCollapsedVerticalMarginValue(layoutState, layoutBox).top;
197 }
198
199 LayoutUnit BlockFormattingContext::Geometry::MarginCollapse::computedNonCollapsedMarginBottom(const LayoutState& layoutState, const Box& layoutBox)
200 {
201     ASSERT(layoutBox.isBlockLevelBox());
202
203     return computedNonCollapsedVerticalMarginValue(layoutState, layoutBox).bottom;
204 }
205
206 LayoutUnit BlockFormattingContext::Geometry::MarginCollapse::marginTop(const LayoutState& layoutState, const Box& layoutBox)
207 {
208     if (layoutBox.isAnonymous())
209         return 0;
210
211     ASSERT(layoutBox.isBlockLevelBox());
212
213     // TODO: take _hasAdjoiningMarginTopAndBottom() into account.
214     if (isMarginTopCollapsedWithParent(layoutState, layoutBox))
215         return 0;
216
217     // FIXME: Find out the logic behind this.
218     if (BlockFormattingContext::Quirks::shouldIgnoreMarginTop(layoutState, layoutBox))
219         return 0;
220
221     if (!isMarginTopCollapsedWithSibling(layoutBox)) {
222         if (!isMarginBottomCollapsedThrough(layoutState, layoutBox))
223             return nonCollapsedMarginTop(layoutState, layoutBox);
224         // Compute the collapsed through value.
225         auto marginTop = nonCollapsedMarginTop(layoutState, layoutBox);
226         auto marginBottom = nonCollapsedMarginBottom(layoutState, layoutBox); 
227         return marginValue(marginTop, marginBottom);
228     }
229
230     // The bottom margin of an in-flow block-level element always collapses with the top margin of its next in-flow block-level sibling,
231     // unless that sibling has clearance.
232     auto* previousInFlowSibling = layoutBox.previousInFlowSibling();
233     if (!previousInFlowSibling)
234         return nonCollapsedMarginTop(layoutState, layoutBox);
235
236     auto previousSiblingMarginBottom = nonCollapsedMarginBottom(layoutState, *previousInFlowSibling);
237     auto marginTop = nonCollapsedMarginTop(layoutState, layoutBox);
238     return marginValue(marginTop, previousSiblingMarginBottom);
239 }
240
241 LayoutUnit BlockFormattingContext::Geometry::MarginCollapse::marginBottom(const LayoutState& layoutState, const Box& layoutBox)
242 {
243     if (layoutBox.isAnonymous())
244         return 0;
245
246     ASSERT(layoutBox.isBlockLevelBox());
247
248     // TODO: take _hasAdjoiningMarginTopAndBottom() into account.
249     if (isMarginBottomCollapsedWithParent(layoutState, layoutBox))
250         return 0;
251
252     if (isMarginBottomCollapsedThrough(layoutState, layoutBox))
253         return 0;
254
255     // Floats and out of flow positioned boxes do not collapse their margins.
256     if (!isMarginBottomCollapsedWithSibling(layoutBox))
257         return nonCollapsedMarginBottom(layoutState, layoutBox);
258
259     // The bottom margin of an in-flow block-level element always collapses with the top margin of its next in-flow block-level sibling,
260     // unless that sibling has clearance.
261     if (layoutBox.nextInFlowSibling())
262         return 0;
263     return nonCollapsedMarginBottom(layoutState, layoutBox);
264 }
265
266 bool BlockFormattingContext::Geometry::MarginCollapse::isMarginBottomCollapsedWithParent(const LayoutState& layoutState, const Box& layoutBox)
267 {
268     // last inflow box to parent.
269     // https://www.w3.org/TR/CSS21/box.html#collapsing-margins
270     if (layoutBox.isAnonymous())
271         return false;
272
273     ASSERT(layoutBox.isBlockLevelBox());
274
275     if (layoutBox.isFloatingOrOutOfFlowPositioned())
276         return false;
277
278     if (isMarginBottomCollapsedThrough(layoutState, layoutBox))
279         return false;
280
281     // We never margin collapse the initial containing block.
282     ASSERT(layoutBox.parent());
283     auto& parent = *layoutBox.parent();
284     // Only the last inlflow child collapses with parent.
285     if (layoutBox.nextInFlowSibling())
286         return false;
287
288     if (parent.establishesBlockFormattingContext())
289         return false;
290
291     // Margins of the root element's box do not collapse.
292     if (parent.isDocumentBox() || parent.isInitialContainingBlock())
293         return false;
294
295     auto& parentDisplayBox = layoutState.displayBoxForLayoutBox(parent);
296     if (parentDisplayBox.borderTop())
297         return false;
298
299     if (parentDisplayBox.paddingTop().value_or(0))
300         return false;
301
302     if (!parent.style().height().isAuto())
303         return false;
304
305     return true;
306 }
307
308 bool BlockFormattingContext::Geometry::MarginCollapse::isMarginTopCollapsedWithParentMarginBottom(const Box&)
309 {
310     return false;
311 }
312
313 LayoutUnit BlockFormattingContext::Geometry::MarginCollapse::collapsedMarginBottomFromLastChild(const LayoutState& layoutState, const Box& layoutBox)
314 {
315     ASSERT(layoutBox.isBlockLevelBox());
316
317     // Check if the last child propagates its margin bottom.
318     if (!is<Container>(layoutBox) || !downcast<Container>(layoutBox).hasInFlowChild())
319         return 0;
320
321     // Do not collapse margin with a box from a non-block formatting context <div><span>foobar</span></div>.
322     if (layoutBox.establishesFormattingContext() && !layoutBox.establishesBlockFormattingContextOnly())
323         return 0;
324
325     // FIXME: Check for collapsed through margin.
326     auto& lastInFlowChild = *downcast<Container>(layoutBox).lastInFlowChild();
327     if (!isMarginBottomCollapsedWithParent(layoutState, lastInFlowChild))
328         return 0;
329
330     // Collect collapsed margin bottom recursively.
331     return marginValue(computedNonCollapsedMarginBottom(layoutState, lastInFlowChild), collapsedMarginBottomFromLastChild(layoutState, lastInFlowChild));
332 }
333
334 LayoutUnit BlockFormattingContext::Geometry::MarginCollapse::nonCollapsedMarginBottom(const LayoutState& layoutState, const Box& layoutBox)
335 {
336     ASSERT(layoutBox.isBlockLevelBox());
337
338     // Non collapsed margin bottom includes collapsed margin from inflow last child.
339     return marginValue(computedNonCollapsedMarginBottom(layoutState, layoutBox), collapsedMarginBottomFromLastChild(layoutState, layoutBox));
340 }
341
342 }
343 }
344 #endif