8ecfcbe3f91b1c7a7945a798bdbb358b026ac298
[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 "BlockMarginCollapse.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 #include <wtf/IsoMallocInlines.h>
36
37 namespace WebCore {
38 namespace Layout {
39
40 WTF_MAKE_ISO_ALLOCATED_IMPL(BlockMarginCollapse);
41
42 static LayoutUnit marginValue(LayoutUnit currentMarginValue, LayoutUnit candidateMarginValue)
43 {
44     if (!candidateMarginValue)
45         return currentMarginValue;
46     if (!currentMarginValue)
47         return candidateMarginValue;
48     // Both margins are positive.
49     if (candidateMarginValue > 0 && currentMarginValue > 0)
50         return std::max(candidateMarginValue, currentMarginValue);
51     // Both margins are negative.
52     if (candidateMarginValue < 0 && currentMarginValue < 0)
53         return 0 - std::max(std::abs(candidateMarginValue.toFloat()), std::abs(currentMarginValue.toFloat()));
54     // One of the margins is negative.
55     return currentMarginValue + candidateMarginValue;
56 }
57
58 static bool isMarginTopCollapsedWithSibling(const Box& layoutBox)
59 {
60     if (layoutBox.isFloatingPositioned())
61         return false;
62
63     if (!layoutBox.isPositioned() || layoutBox.isInFlowPositioned())
64         return true;
65
66     // Out of flow positioned.
67     ASSERT(layoutBox.isOutOfFlowPositioned());
68     return layoutBox.style().top().isAuto();
69 }
70
71 static bool isMarginBottomCollapsedWithSibling(const Box& layoutBox)
72 {
73     if (layoutBox.isFloatingPositioned())
74         return false;
75
76     if (!layoutBox.isPositioned() || layoutBox.isInFlowPositioned())
77         return true;
78
79     // Out of flow positioned.
80     ASSERT(layoutBox.isOutOfFlowPositioned());
81     return layoutBox.style().bottom().isAuto();
82 }
83
84 static bool isMarginTopCollapsedWithParent(const Box& layoutBox)
85 {
86     // The first inflow child could propagate its top margin to parent.
87     // https://www.w3.org/TR/CSS21/box.html#collapsing-margins
88     if (layoutBox.isAnonymous())
89         return false;
90
91     if (layoutBox.isFloatingOrOutOfFlowPositioned())
92         return false;
93
94     // We never margin collapse the initial containing block.
95     ASSERT(layoutBox.parent());
96     auto& parent = *layoutBox.parent();
97     // Is this box the first inlflow child?
98     if (parent.firstInFlowChild() != &layoutBox)
99         return false;
100
101     if (parent.establishesBlockFormattingContext())
102         return false;
103
104     // Margins of the root element's box do not collapse.
105     if (parent.isInitialContainingBlock())
106         return false;
107
108     if (!parent.style().borderTop().nonZero())
109         return false;
110
111     if (!parent.style().paddingTop().isZero())
112         return false;
113
114     return true;
115 }
116
117 static bool isMarginBottomCollapsedWithParent(const Box& layoutBox)
118 {
119     // last inflow box to parent.
120     // https://www.w3.org/TR/CSS21/box.html#collapsing-margins
121     if (layoutBox.isAnonymous())
122         return false;
123
124     if (layoutBox.isFloatingOrOutOfFlowPositioned())
125         return false;
126
127     // We never margin collapse the initial containing block.
128     ASSERT(layoutBox.parent());
129     auto& parent = *layoutBox.parent();
130     // Is this the last inlflow child?
131     if (parent.lastInFlowChild() != &layoutBox)
132         return false;
133
134     if (parent.establishesBlockFormattingContext())
135         return false;
136
137     // Margins of the root element's box do not collapse.
138     if (parent.isInitialContainingBlock())
139         return false;
140
141     if (!parent.style().borderTop().nonZero())
142         return false;
143
144     if (!parent.style().paddingTop().isZero())
145         return false;
146
147     if (!parent.style().height().isAuto())
148         return false;
149
150     return true;
151 }
152
153 static LayoutUnit collapsedMarginTopFromFirstChild(const Box& layoutBox)
154 {
155     // Check if the first child collapses its margin top.
156     if (!is<Container>(layoutBox) || !downcast<Container>(layoutBox).hasInFlowChild())
157         return 0;
158
159     auto& firstInFlowChild = *downcast<Container>(layoutBox).firstInFlowChild();
160     if (!isMarginTopCollapsedWithParent(firstInFlowChild))
161         return 0;
162
163     // Collect collapsed margin top recursively.
164     return marginValue(firstInFlowChild.style().marginTop().value(), collapsedMarginTopFromFirstChild(firstInFlowChild));
165 }
166
167 static LayoutUnit collapsedMarginBottomFromLastChild(const Box& layoutBox)
168 {
169     // Check if the last child propagates its margin bottom.
170     if (!is<Container>(layoutBox) || !downcast<Container>(layoutBox).hasInFlowChild())
171         return 0;
172
173     auto& lastInFlowChild = *downcast<Container>(layoutBox).lastInFlowChild();
174     if (!isMarginBottomCollapsedWithParent(lastInFlowChild))
175         return 0;
176
177     // Collect collapsed margin bottom recursively.
178     return marginValue(lastInFlowChild.style().marginBottom().value(), collapsedMarginBottomFromLastChild(lastInFlowChild));
179 }
180
181 static LayoutUnit nonCollapsedMarginTop(const Box& layoutBox)
182 {
183     // Non collapsed margin top includes collapsed margin from inflow first child.
184     return marginValue(layoutBox.style().marginTop().value(), collapsedMarginTopFromFirstChild(layoutBox));
185 }
186
187 static LayoutUnit nonCollapsedMarginBottom(const Box& layoutBox)
188 {
189     // Non collapsed margin bottom includes collapsed margin from inflow last child.
190     return marginValue(layoutBox.style().marginBottom().value(), collapsedMarginBottomFromLastChild(layoutBox));
191 }
192
193 /*static bool hasAdjoiningMarginTopAndBottom(const Box&)
194 {
195     // Two margins are adjoining if and only if:
196     // 1. both belong to in-flow block-level boxes that participate in the same block formatting context
197     // 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.)
198     // 3. both belong to vertically-adjacent box edges, i.e. form one of the following pairs:
199     //        top margin of a box and top margin of its first in-flow child
200     //        bottom margin of box and top margin of its next in-flow following sibling
201     //        bottom margin of a last in-flow child and bottom margin of its parent if the parent has 'auto' computed height
202     //        top and bottom margins of a box that does not establish a new block formatting context and that has zero computed 'min-height',
203     //        zero or 'auto' computed 'height', and no in-flow children
204     // A collapsed margin is considered adjoining to another margin if any of its component margins is adjoining to that margin.
205     return false;
206 }*/
207
208 LayoutUnit BlockMarginCollapse::marginTop(const Box& layoutBox)
209 {
210     if (layoutBox.isAnonymous())
211         return 0;
212
213     // TODO: take _hasAdjoiningMarginTopAndBottom() into account.
214     if (isMarginTopCollapsedWithParent(layoutBox))
215         return 0;
216
217     // Floats and out of flow positioned boxes do not collapse their margins.
218     if (!isMarginTopCollapsedWithSibling(layoutBox))
219         return nonCollapsedMarginTop(layoutBox);
220
221     // The bottom margin of an in-flow block-level element always collapses with the top margin of its next in-flow block-level sibling,
222     // unless that sibling has clearance.
223     auto* previousInFlowSibling = layoutBox.previousInFlowSibling();
224     if (!previousInFlowSibling)
225         return nonCollapsedMarginTop(layoutBox);
226
227     auto previousSiblingMarginBottom = nonCollapsedMarginBottom(*previousInFlowSibling);
228     auto marginTop = nonCollapsedMarginTop(layoutBox);
229     return marginValue(marginTop, previousSiblingMarginBottom);
230 }
231
232 LayoutUnit BlockMarginCollapse::marginBottom(const Box& layoutBox)
233 {
234     if (layoutBox.isAnonymous())
235         return 0;
236
237     // TODO: take _hasAdjoiningMarginTopAndBottom() into account.
238     if (isMarginBottomCollapsedWithParent(layoutBox))
239         return 0;
240
241     // Floats and out of flow positioned boxes do not collapse their margins.
242     if (!isMarginBottomCollapsedWithSibling(layoutBox))
243         return nonCollapsedMarginBottom(layoutBox);
244
245     // The bottom margin of an in-flow block-level element always collapses with the top margin of its next in-flow block-level sibling,
246     // unless that sibling has clearance.
247     if (layoutBox.nextInFlowSibling())
248         return 0;
249     return nonCollapsedMarginBottom(layoutBox);
250 }
251
252 }
253 }
254 #endif