Remove CSS_SHAPES feature definition. This should always be on.
[WebKit-https.git] / Source / WebCore / rendering / RenderBox.h
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  * Copyright (C) 2003, 2006, 2007, 2015 Apple Inc. All rights reserved.
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Library General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Library General Public License for more details.
15  *
16  * You should have received a copy of the GNU Library General Public License
17  * along with this library; see the file COPYING.LIB.  If not, write to
18  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19  * Boston, MA 02110-1301, USA.
20  *
21  */
22
23 #ifndef RenderBox_h
24 #define RenderBox_h
25
26 #include "FrameView.h"
27 #include "RenderBoxModelObject.h"
28 #include "RenderOverflow.h"
29 #include "ScrollTypes.h"
30 #include "ShapeOutsideInfo.h"
31
32 namespace WebCore {
33
34 class InlineElementBox;
35 class RenderBlockFlow;
36 class RenderBoxRegionInfo;
37 class RenderRegion;
38 struct PaintInfo;
39
40 enum SizeType { MainOrPreferredSize, MinSize, MaxSize };
41 enum AvailableLogicalHeightType { ExcludeMarginBorderPadding, IncludeMarginBorderPadding };
42 enum OverlayScrollbarSizeRelevancy { IgnoreOverlayScrollbarSize, IncludeOverlayScrollbarSize };
43
44 enum ShouldComputePreferred { ComputeActual, ComputePreferred };
45
46 class RenderBox : public RenderBoxModelObject {
47 public:
48     virtual ~RenderBox();
49
50     // hasAutoZIndex only returns true if the element is positioned or a flex-item since
51     // position:static elements that are not flex-items get their z-index coerced to auto.
52     bool requiresLayer() const override
53     {
54         return isDocumentElementRenderer() || isPositioned() || createsGroup() || hasClipPath() || hasOverflowClip()
55             || hasTransformRelatedProperty() || hasHiddenBackface() || hasReflection() || style().specifiesColumns()
56             || !style().hasAutoZIndex();
57     }
58
59     bool backgroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect) const final;
60
61     // Use this with caution! No type checking is done!
62     RenderBox* firstChildBox() const;
63     RenderBox* lastChildBox() const;
64
65     LayoutUnit x() const { return m_frameRect.x(); }
66     LayoutUnit y() const { return m_frameRect.y(); }
67     LayoutUnit width() const { return m_frameRect.width(); }
68     LayoutUnit height() const { return m_frameRect.height(); }
69
70     // These represent your location relative to your container as a physical offset.
71     // In layout related methods you almost always want the logical location (e.g. x() and y()).
72     LayoutUnit top() const { return topLeftLocation().y(); }
73     LayoutUnit left() const { return topLeftLocation().x(); }
74
75     void setX(LayoutUnit x) { m_frameRect.setX(x); }
76     void setY(LayoutUnit y) { m_frameRect.setY(y); }
77     void setWidth(LayoutUnit width) { m_frameRect.setWidth(width); }
78     void setHeight(LayoutUnit height) { m_frameRect.setHeight(height); }
79
80     LayoutUnit logicalLeft() const { return style().isHorizontalWritingMode() ? x() : y(); }
81     LayoutUnit logicalRight() const { return logicalLeft() + logicalWidth(); }
82     LayoutUnit logicalTop() const { return style().isHorizontalWritingMode() ? y() : x(); }
83     LayoutUnit logicalBottom() const { return logicalTop() + logicalHeight(); }
84     LayoutUnit logicalWidth() const { return style().isHorizontalWritingMode() ? width() : height(); }
85     LayoutUnit logicalHeight() const { return style().isHorizontalWritingMode() ? height() : width(); }
86
87     LayoutUnit constrainLogicalWidthInRegionByMinMax(LayoutUnit, LayoutUnit, RenderBlock&, RenderRegion* = nullptr) const;
88     LayoutUnit constrainLogicalHeightByMinMax(LayoutUnit logicalHeight, Optional<LayoutUnit> intrinsicContentHeight) const;
89     LayoutUnit constrainContentBoxLogicalHeightByMinMax(LayoutUnit logicalHeight, Optional<LayoutUnit> intrinsicContentHeight) const;
90
91     void setLogicalLeft(LayoutUnit left)
92     {
93         if (style().isHorizontalWritingMode())
94             setX(left);
95         else
96             setY(left);
97     }
98     void setLogicalTop(LayoutUnit top)
99     {
100         if (style().isHorizontalWritingMode())
101             setY(top);
102         else
103             setX(top);
104     }
105     void setLogicalLocation(const LayoutPoint& location)
106     {
107         if (style().isHorizontalWritingMode())
108             setLocation(location);
109         else
110             setLocation(location.transposedPoint());
111     }
112     void setLogicalWidth(LayoutUnit size)
113     {
114         if (style().isHorizontalWritingMode())
115             setWidth(size);
116         else
117             setHeight(size);
118     }
119     void setLogicalHeight(LayoutUnit size)
120     {
121         if (style().isHorizontalWritingMode())
122             setHeight(size);
123         else
124             setWidth(size);
125     }
126     void setLogicalSize(const LayoutSize& size)
127     {
128         if (style().isHorizontalWritingMode())
129             setSize(size);
130         else
131             setSize(size.transposedSize());
132     }
133
134     LayoutPoint location() const { return m_frameRect.location(); }
135     LayoutSize locationOffset() const { return LayoutSize(x(), y()); }
136     LayoutSize size() const { return m_frameRect.size(); }
137
138     void setLocation(const LayoutPoint& location) { m_frameRect.setLocation(location); }
139     
140     void setSize(const LayoutSize& size) { m_frameRect.setSize(size); }
141     void move(LayoutUnit dx, LayoutUnit dy) { m_frameRect.move(dx, dy); }
142
143     LayoutRect frameRect() const { return m_frameRect; }
144     void setFrameRect(const LayoutRect& rect) { m_frameRect = rect; }
145
146     LayoutRect marginBoxRect() const
147     {
148         LayoutRect box = borderBoxRect();
149         box.expand(m_marginBox);
150         return box;
151     }
152     LayoutRect borderBoxRect() const { return LayoutRect(LayoutPoint(), size()); }
153     LayoutRect paddingBoxRect() const { return LayoutRect(borderLeft(), borderTop(), contentWidth() + paddingLeft() + paddingRight(), contentHeight() + paddingTop() + paddingBottom()); }
154     LayoutRect borderBoundingBox() const final { return borderBoxRect(); }
155
156     WEBCORE_EXPORT RoundedRect::Radii borderRadii() const;
157
158     // The content area of the box (excludes padding - and intrinsic padding for table cells, etc... - and border).
159     LayoutRect contentBoxRect() const;
160     // The content box in absolute coords. Ignores transforms.
161     IntRect absoluteContentBox() const;
162     // The content box converted to absolute coords (taking transforms into account).
163     WEBCORE_EXPORT FloatQuad absoluteContentQuad() const;
164
165     // This returns the content area of the box (excluding padding and border). The only difference with contentBoxRect is that computedCSSContentBoxRect
166     // does include the intrinsic padding in the content box as this is what some callers expect (like getComputedStyle).
167     LayoutRect computedCSSContentBoxRect() const { return LayoutRect(borderLeft() + computedCSSPaddingLeft(), borderTop() + computedCSSPaddingTop(), clientWidth() - computedCSSPaddingLeft() - computedCSSPaddingRight(), clientHeight() - computedCSSPaddingTop() - computedCSSPaddingBottom()); }
168
169     // Bounds of the outline box in absolute coords. Respects transforms
170     LayoutRect outlineBoundsForRepaint(const RenderLayerModelObject* /*repaintContainer*/, const RenderGeometryMap*) const final;
171     void addFocusRingRects(Vector<LayoutRect>&, const LayoutPoint& additionalOffset, const RenderLayerModelObject* paintContainer = nullptr) override;
172     
173     FloatRect repaintRectInLocalCoordinates() const override { return borderBoxRect(); }
174     FloatRect objectBoundingBox() const override { return borderBoxRect(); }
175
176     // Use this with caution! No type checking is done!
177     RenderBox* previousSiblingBox() const;
178     RenderBox* nextSiblingBox() const;
179     RenderBox* parentBox() const;
180
181     // Visual and layout overflow are in the coordinate space of the box.  This means that they aren't purely physical directions.
182     // For horizontal-tb and vertical-lr they will match physical directions, but for horizontal-bt and vertical-rl, the top/bottom and left/right
183     // respectively are flipped when compared to their physical counterparts.  For example minX is on the left in vertical-lr,
184     // but it is on the right in vertical-rl.
185     WEBCORE_EXPORT LayoutRect flippedClientBoxRect() const;
186     LayoutRect layoutOverflowRect() const { return m_overflow ? m_overflow->layoutOverflowRect() : flippedClientBoxRect(); }
187     LayoutUnit logicalLeftLayoutOverflow() const { return style().isHorizontalWritingMode() ? layoutOverflowRect().x() : layoutOverflowRect().y(); }
188     LayoutUnit logicalRightLayoutOverflow() const { return style().isHorizontalWritingMode() ? layoutOverflowRect().maxX() : layoutOverflowRect().maxY(); }
189     
190     virtual LayoutRect visualOverflowRect() const { return m_overflow ? m_overflow->visualOverflowRect() : borderBoxRect(); }
191     LayoutUnit logicalLeftVisualOverflow() const { return style().isHorizontalWritingMode() ? visualOverflowRect().x() : visualOverflowRect().y(); }
192     LayoutUnit logicalRightVisualOverflow() const { return style().isHorizontalWritingMode() ? visualOverflowRect().maxX() : visualOverflowRect().maxY(); }
193
194     LayoutRect overflowRectForPaintRejection(RenderNamedFlowFragment*) const;
195     
196     void addLayoutOverflow(const LayoutRect&);
197     void addVisualOverflow(const LayoutRect&);
198     void clearOverflow();
199     
200     virtual bool isTopLayoutOverflowAllowed() const { return !style().isLeftToRightDirection() && !isHorizontalWritingMode(); }
201     virtual bool isLeftLayoutOverflowAllowed() const { return !style().isLeftToRightDirection() && isHorizontalWritingMode(); }
202     
203     void addVisualEffectOverflow();
204     LayoutRect applyVisualEffectOverflow(const LayoutRect&) const;
205     void addOverflowFromChild(const RenderBox* child) { addOverflowFromChild(child, child->locationOffset()); }
206     void addOverflowFromChild(const RenderBox* child, const LayoutSize& delta);
207     
208     void updateLayerTransform();
209
210     LayoutSize contentSize() const { return { contentWidth(), contentHeight() }; }
211     LayoutUnit contentWidth() const { return clientWidth() - paddingLeft() - paddingRight(); }
212     LayoutUnit contentHeight() const { return clientHeight() - paddingTop() - paddingBottom(); }
213     LayoutUnit contentLogicalWidth() const { return style().isHorizontalWritingMode() ? contentWidth() : contentHeight(); }
214     LayoutUnit contentLogicalHeight() const { return style().isHorizontalWritingMode() ? contentHeight() : contentWidth(); }
215
216     // IE extensions. Used to calculate offsetWidth/Height.  Overridden by inlines (RenderFlow)
217     // to return the remaining width on a given line (and the height of a single line).
218     LayoutUnit offsetWidth() const override { return width(); }
219     LayoutUnit offsetHeight() const override { return height(); }
220
221     // More IE extensions.  clientWidth and clientHeight represent the interior of an object
222     // excluding border and scrollbar.  clientLeft/Top are just the borderLeftWidth and borderTopWidth.
223     LayoutUnit clientLeft() const { return borderLeft(); }
224     LayoutUnit clientTop() const { return borderTop(); }
225     WEBCORE_EXPORT LayoutUnit clientWidth() const;
226     WEBCORE_EXPORT LayoutUnit clientHeight() const;
227     LayoutUnit clientLogicalWidth() const { return style().isHorizontalWritingMode() ? clientWidth() : clientHeight(); }
228     LayoutUnit clientLogicalHeight() const { return style().isHorizontalWritingMode() ? clientHeight() : clientWidth(); }
229     LayoutUnit clientLogicalBottom() const { return borderBefore() + clientLogicalHeight(); }
230     LayoutRect clientBoxRect() const { return LayoutRect(clientLeft(), clientTop(), clientWidth(), clientHeight()); }
231
232     // scrollWidth/scrollHeight will be the same as clientWidth/clientHeight unless the
233     // object has overflow:hidden/scroll/auto specified and also has overflow.
234     // scrollLeft/Top return the current scroll position.  These methods are virtual so that objects like
235     // textareas can scroll shadow content (but pretend that they are the objects that are
236     // scrolling).
237     virtual int scrollLeft() const;
238     virtual int scrollTop() const;
239     virtual int scrollWidth() const;
240     virtual int scrollHeight() const;
241     virtual void setScrollLeft(int);
242     virtual void setScrollTop(int);
243
244     LayoutUnit marginTop() const override { return m_marginBox.top(); }
245     LayoutUnit marginBottom() const override { return m_marginBox.bottom(); }
246     LayoutUnit marginLeft() const override { return m_marginBox.left(); }
247     LayoutUnit marginRight() const override { return m_marginBox.right(); }
248     void setMarginTop(LayoutUnit margin) { m_marginBox.setTop(margin); }
249     void setMarginBottom(LayoutUnit margin) { m_marginBox.setBottom(margin); }
250     void setMarginLeft(LayoutUnit margin) { m_marginBox.setLeft(margin); }
251     void setMarginRight(LayoutUnit margin) { m_marginBox.setRight(margin); }
252
253     LayoutUnit marginLogicalLeft() const { return m_marginBox.start(style().writingMode()); }
254     LayoutUnit marginLogicalRight() const { return m_marginBox.end(style().writingMode()); }
255     
256     LayoutUnit marginBefore(const RenderStyle* overrideStyle = nullptr) const final { return m_marginBox.before((overrideStyle ? overrideStyle : &style())->writingMode()); }
257     LayoutUnit marginAfter(const RenderStyle* overrideStyle = nullptr) const final { return m_marginBox.after((overrideStyle ? overrideStyle : &style())->writingMode()); }
258     LayoutUnit marginStart(const RenderStyle* overrideStyle = nullptr) const final
259     {
260         const RenderStyle* styleToUse = overrideStyle ? overrideStyle : &style();
261         return m_marginBox.start(styleToUse->writingMode(), styleToUse->direction());
262     }
263     LayoutUnit marginEnd(const RenderStyle* overrideStyle = nullptr) const final
264     {
265         const RenderStyle* styleToUse = overrideStyle ? overrideStyle : &style();
266         return m_marginBox.end(styleToUse->writingMode(), styleToUse->direction());
267     }
268     void setMarginBefore(LayoutUnit value, const RenderStyle* overrideStyle = nullptr) { m_marginBox.setBefore(value, (overrideStyle ? overrideStyle : &style())->writingMode()); }
269     void setMarginAfter(LayoutUnit value, const RenderStyle* overrideStyle = nullptr) { m_marginBox.setAfter(value, (overrideStyle ? overrideStyle : &style())->writingMode()); }
270     void setMarginStart(LayoutUnit value, const RenderStyle* overrideStyle = nullptr)
271     {
272         const RenderStyle* styleToUse = overrideStyle ? overrideStyle : &style();
273         m_marginBox.setStart(value, styleToUse->writingMode(), styleToUse->direction());
274     }
275     void setMarginEnd(LayoutUnit value, const RenderStyle* overrideStyle = nullptr)
276     {
277         const RenderStyle* styleToUse = overrideStyle ? overrideStyle : &style();
278         m_marginBox.setEnd(value, styleToUse->writingMode(), styleToUse->direction());
279     }
280
281     virtual bool isSelfCollapsingBlock() const { return false; }
282     virtual LayoutUnit collapsedMarginBefore() const { return marginBefore(); }
283     virtual LayoutUnit collapsedMarginAfter() const { return marginAfter(); }
284
285     void absoluteRects(Vector<IntRect>&, const LayoutPoint& accumulatedOffset) const override;
286     void absoluteQuads(Vector<FloatQuad>&, bool* wasFixed) const override;
287     
288     int reflectionOffset() const;
289     // Given a rect in the object's coordinate space, returns the corresponding rect in the reflection.
290     LayoutRect reflectedRect(const LayoutRect&) const;
291
292     void layout() override;
293     bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) override;
294
295     LayoutUnit minPreferredLogicalWidth() const override;
296     LayoutUnit maxPreferredLogicalWidth() const override;
297
298     // FIXME: We should rename these back to overrideLogicalHeight/Width and have them store
299     // the border-box height/width like the regular height/width accessors on RenderBox.
300     // Right now, these are different than contentHeight/contentWidth because they still
301     // include the scrollbar height/width.
302     LayoutUnit overrideLogicalContentWidth() const;
303     LayoutUnit overrideLogicalContentHeight() const;
304     bool hasOverrideLogicalContentHeight() const;
305     bool hasOverrideLogicalContentWidth() const;
306     void setOverrideLogicalContentHeight(LayoutUnit);
307     void setOverrideLogicalContentWidth(LayoutUnit);
308     void clearOverrideSize();
309     void clearOverrideLogicalContentHeight();
310     void clearOverrideLogicalContentWidth();
311
312 #if ENABLE(CSS_GRID_LAYOUT)
313     Optional<LayoutUnit> overrideContainingBlockContentLogicalWidth() const;
314     Optional<LayoutUnit> overrideContainingBlockContentLogicalHeight() const;
315     bool hasOverrideContainingBlockLogicalWidth() const;
316     bool hasOverrideContainingBlockLogicalHeight() const;
317     void setOverrideContainingBlockContentLogicalWidth(Optional<LayoutUnit>);
318     void setOverrideContainingBlockContentLogicalHeight(Optional<LayoutUnit>);
319     void clearContainingBlockOverrideSize();
320     void clearOverrideContainingBlockContentLogicalHeight();
321     LayoutUnit extraInlineOffset() const;
322     LayoutUnit extraBlockOffset() const;
323     void setExtraInlineOffset(LayoutUnit);
324     void setExtraBlockOffset(LayoutUnit);
325     void clearExtraInlineAndBlockOffests();
326 #endif
327
328     LayoutSize offsetFromContainer(RenderElement&, const LayoutPoint&, bool* offsetDependsOnPoint = nullptr) const override;
329     
330     LayoutUnit adjustBorderBoxLogicalWidthForBoxSizing(LayoutUnit width) const;
331     LayoutUnit adjustBorderBoxLogicalHeightForBoxSizing(LayoutUnit height) const;
332     LayoutUnit adjustContentBoxLogicalWidthForBoxSizing(LayoutUnit width) const;
333     LayoutUnit adjustContentBoxLogicalHeightForBoxSizing(Optional<LayoutUnit> height) const;
334
335     struct ComputedMarginValues {
336         ComputedMarginValues()
337             : m_before(0)
338             , m_after(0)
339             , m_start(0)
340             , m_end(0)
341         {
342         }
343         LayoutUnit m_before;
344         LayoutUnit m_after;
345         LayoutUnit m_start;
346         LayoutUnit m_end;
347     };
348     struct LogicalExtentComputedValues {
349         LogicalExtentComputedValues()
350             : m_extent(0)
351             , m_position(0)
352         {
353         }
354
355         LayoutUnit m_extent;
356         LayoutUnit m_position;
357         ComputedMarginValues m_margins;
358     };
359     // Resolve auto margins in the inline direction of the containing block so that objects can be pushed to the start, middle or end
360     // of the containing block.
361     void computeInlineDirectionMargins(const RenderBlock& containingBlock, LayoutUnit containerWidth, LayoutUnit childWidth, LayoutUnit& marginStart, LayoutUnit& marginEnd) const;
362
363     // Used to resolve margins in the containing block's block-flow direction.
364     void computeBlockDirectionMargins(const RenderBlock& containingBlock, LayoutUnit& marginBefore, LayoutUnit& marginAfter) const;
365     void computeAndSetBlockDirectionMargins(const RenderBlock& containingBlock);
366
367     enum RenderBoxRegionInfoFlags { CacheRenderBoxRegionInfo, DoNotCacheRenderBoxRegionInfo };
368     LayoutRect borderBoxRectInRegion(RenderRegion*, RenderBoxRegionInfoFlags = CacheRenderBoxRegionInfo) const;
369     LayoutRect clientBoxRectInRegion(RenderRegion*) const;
370     RenderRegion* clampToStartAndEndRegions(RenderRegion*) const;
371     bool hasRegionRangeInFlowThread() const;
372     virtual LayoutUnit offsetFromLogicalTopOfFirstPage() const;
373     
374     void positionLineBox(InlineElementBox&);
375
376     virtual std::unique_ptr<InlineElementBox> createInlineBox();
377     void dirtyLineBoxes(bool fullLayout);
378
379     // For inline replaced elements, this function returns the inline box that owns us.  Enables
380     // the replaced RenderObject to quickly determine what line it is contained on and to easily
381     // iterate over structures on the line.
382     InlineElementBox* inlineBoxWrapper() const { return m_inlineBoxWrapper; }
383     void setInlineBoxWrapper(InlineElementBox*);
384     void deleteLineBoxWrapper();
385
386     LayoutRect clippedOverflowRectForRepaint(const RenderLayerModelObject* repaintContainer) const override;
387     LayoutRect computeRectForRepaint(const LayoutRect&, const RenderLayerModelObject* repaintContainer, RepaintContext context = { false, false }) const override;
388     void repaintDuringLayoutIfMoved(const LayoutRect&);
389     virtual void repaintOverhangingFloats(bool paintAllDescendants);
390
391     LayoutUnit containingBlockLogicalWidthForContent() const override;
392     LayoutUnit containingBlockLogicalHeightForContent(AvailableLogicalHeightType) const;
393
394     LayoutUnit containingBlockLogicalWidthForContentInRegion(RenderRegion*) const;
395     LayoutUnit containingBlockAvailableLineWidthInRegion(RenderRegion*) const;
396     LayoutUnit perpendicularContainingBlockLogicalHeight() const;
397
398     virtual void updateLogicalWidth();
399     virtual void updateLogicalHeight();
400     virtual void computeLogicalHeight(LayoutUnit logicalHeight, LayoutUnit logicalTop, LogicalExtentComputedValues&) const;
401
402     RenderBoxRegionInfo* renderBoxRegionInfo(RenderRegion*, RenderBoxRegionInfoFlags = CacheRenderBoxRegionInfo) const;
403     void computeLogicalWidthInRegion(LogicalExtentComputedValues&, RenderRegion* = nullptr) const;
404
405     bool stretchesToViewport() const
406     {
407         return document().inQuirksMode() && style().logicalHeight().isAuto() && !isFloatingOrOutOfFlowPositioned() && (isDocumentElementRenderer() || isBody()) && !isInline();
408     }
409
410     virtual LayoutSize intrinsicSize() const { return LayoutSize(); }
411     LayoutUnit intrinsicLogicalWidth() const { return style().isHorizontalWritingMode() ? intrinsicSize().width() : intrinsicSize().height(); }
412     LayoutUnit intrinsicLogicalHeight() const { return style().isHorizontalWritingMode() ? intrinsicSize().height() : intrinsicSize().width(); }
413
414     // Whether or not the element shrinks to its intrinsic width (rather than filling the width
415     // of a containing block).  HTML4 buttons, <select>s, <input>s, legends, and floating/compact elements do this.
416     bool sizesLogicalWidthToFitContent(SizeType) const;
417
418     bool hasStretchedLogicalWidth() const;
419
420     LayoutUnit shrinkLogicalWidthToAvoidFloats(LayoutUnit childMarginStart, LayoutUnit childMarginEnd, const RenderBlock& cb, RenderRegion*) const;
421
422     LayoutUnit computeLogicalWidthInRegionUsing(SizeType, Length logicalWidth, LayoutUnit availableLogicalWidth, const RenderBlock& containingBlock, RenderRegion*) const;
423     Optional<LayoutUnit> computeLogicalHeightUsing(SizeType, const Length& height, Optional<LayoutUnit> intrinsicContentHeight) const;
424     Optional<LayoutUnit> computeContentLogicalHeight(SizeType, const Length& height, Optional<LayoutUnit> intrinsicContentHeight) const;
425     Optional<LayoutUnit> computeContentAndScrollbarLogicalHeightUsing(SizeType, const Length& height, Optional<LayoutUnit> intrinsicContentHeight) const;
426     LayoutUnit computeReplacedLogicalWidthUsing(SizeType, Length width) const;
427     LayoutUnit computeReplacedLogicalWidthRespectingMinMaxWidth(LayoutUnit logicalWidth, ShouldComputePreferred  = ComputeActual) const;
428     LayoutUnit computeReplacedLogicalHeightUsing(SizeType, Length height) const;
429     LayoutUnit computeReplacedLogicalHeightRespectingMinMaxHeight(LayoutUnit logicalHeight) const;
430
431     virtual LayoutUnit computeReplacedLogicalWidth(ShouldComputePreferred  = ComputeActual) const;
432     virtual LayoutUnit computeReplacedLogicalHeight() const;
433
434     bool hasDefiniteLogicalWidth() const;
435     static bool percentageLogicalHeightIsResolvableFromBlock(const RenderBlock& containingBlock, bool outOfFlowPositioned, bool scrollsOverflowY);
436     bool hasDefiniteLogicalHeight() const;
437     Optional<LayoutUnit> computePercentageLogicalHeight(const Length& height) const;
438
439     virtual LayoutUnit availableLogicalWidth() const { return contentLogicalWidth(); }
440     virtual LayoutUnit availableLogicalHeight(AvailableLogicalHeightType) const;
441     LayoutUnit availableLogicalHeightUsing(const Length&, AvailableLogicalHeightType) const;
442     
443     // There are a few cases where we need to refer specifically to the available physical width and available physical height.
444     // Relative positioning is one of those cases, since left/top offsets are physical.
445     LayoutUnit availableWidth() const { return style().isHorizontalWritingMode() ? availableLogicalWidth() : availableLogicalHeight(IncludeMarginBorderPadding); }
446     LayoutUnit availableHeight() const { return style().isHorizontalWritingMode() ? availableLogicalHeight(IncludeMarginBorderPadding) : availableLogicalWidth(); }
447
448     virtual int verticalScrollbarWidth() const;
449     int horizontalScrollbarHeight() const;
450     int intrinsicScrollbarLogicalWidth() const;
451     int scrollbarLogicalWidth() const { return style().isHorizontalWritingMode() ? verticalScrollbarWidth() : horizontalScrollbarHeight(); }
452     int scrollbarLogicalHeight() const { return style().isHorizontalWritingMode() ? horizontalScrollbarHeight() : verticalScrollbarWidth(); }
453     virtual bool scroll(ScrollDirection, ScrollGranularity, float multiplier = 1, Element** stopElement = nullptr, RenderBox* startBox = nullptr, const IntPoint& wheelEventAbsolutePoint = IntPoint());
454     virtual bool logicalScroll(ScrollLogicalDirection, ScrollGranularity, float multiplier = 1, Element** stopElement = nullptr);
455     WEBCORE_EXPORT bool canBeScrolledAndHasScrollableArea() const;
456     virtual bool canBeProgramaticallyScrolled() const;
457     virtual void autoscroll(const IntPoint&);
458     bool canAutoscroll() const;
459     IntSize calculateAutoscrollDirection(const IntPoint& windowPoint) const;
460     static RenderBox* findAutoscrollable(RenderObject*);
461     virtual void stopAutoscroll() { }
462     virtual void panScroll(const IntPoint&);
463
464     bool hasVerticalScrollbarWithAutoBehavior() const;
465     bool hasHorizontalScrollbarWithAutoBehavior() const;
466
467     bool scrollsOverflow() const { return scrollsOverflowX() || scrollsOverflowY(); }
468     bool scrollsOverflowX() const { return hasOverflowClip() && (style().overflowX() == OSCROLL || hasHorizontalScrollbarWithAutoBehavior()); }
469     bool scrollsOverflowY() const { return hasOverflowClip() && (style().overflowY() == OSCROLL || hasVerticalScrollbarWithAutoBehavior()); }
470
471     bool hasHorizontalOverflow() const { return scrollWidth() != roundToInt(clientWidth()); }
472     bool hasVerticalOverflow() const { return scrollHeight() != roundToInt(clientHeight()); }
473
474     bool hasScrollableOverflowX() const { return scrollsOverflowX() && hasHorizontalOverflow(); }
475     bool hasScrollableOverflowY() const { return scrollsOverflowY() && hasVerticalOverflow(); }
476
477     bool usesCompositedScrolling() const;
478     
479     bool hasUnsplittableScrollingOverflow() const;
480     bool isUnsplittableForPagination() const;
481
482     LayoutRect localCaretRect(InlineBox*, unsigned caretOffset, LayoutUnit* extraWidthToEndOfLine = nullptr) override;
483
484     virtual LayoutRect overflowClipRect(const LayoutPoint& location, RenderRegion*, OverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize, PaintPhase = PaintPhaseBlockBackground);
485     virtual LayoutRect overflowClipRectForChildLayers(const LayoutPoint& location, RenderRegion* region, OverlayScrollbarSizeRelevancy relevancy) { return overflowClipRect(location, region, relevancy); }
486     LayoutRect clipRect(const LayoutPoint& location, RenderRegion*);
487     virtual bool hasControlClip() const { return false; }
488     virtual LayoutRect controlClipRect(const LayoutPoint&) const { return LayoutRect(); }
489     bool pushContentsClip(PaintInfo&, const LayoutPoint& accumulatedOffset);
490     void popContentsClip(PaintInfo&, PaintPhase originalPhase, const LayoutPoint& accumulatedOffset);
491
492     virtual void paintObject(PaintInfo&, const LayoutPoint&) { ASSERT_NOT_REACHED(); }
493     virtual void paintBoxDecorations(PaintInfo&, const LayoutPoint&);
494     virtual void paintMask(PaintInfo&, const LayoutPoint&);
495     virtual void paintClippingMask(PaintInfo&, const LayoutPoint&);
496     void imageChanged(WrappedImagePtr, const IntRect* = nullptr) override;
497
498     // Called when a positioned object moves but doesn't necessarily change size.  A simplified layout is attempted
499     // that just updates the object's position. If the size does change, the object remains dirty.
500     bool tryLayoutDoingPositionedMovementOnly()
501     {
502         LayoutUnit oldWidth = width();
503         updateLogicalWidth();
504         // If we shrink to fit our width may have changed, so we still need full layout.
505         if (oldWidth != width())
506             return false;
507         updateLogicalHeight();
508         return true;
509     }
510
511     LayoutRect maskClipRect(const LayoutPoint& paintOffset);
512
513     VisiblePosition positionForPoint(const LayoutPoint&, const RenderRegion*) override;
514
515     void removeFloatingOrPositionedChildFromBlockLists();
516     
517     RenderLayer* enclosingFloatPaintingLayer() const;
518     
519     virtual Optional<int> firstLineBaseline() const { return Optional<int>(); }
520     virtual Optional<int> inlineBlockBaseline(LineDirectionMode) const { return Optional<int>(); } // Returns empty if we should skip this box when computing the baseline of an inline-block.
521
522     bool shrinkToAvoidFloats() const;
523     virtual bool avoidsFloats() const;
524
525     virtual void markForPaginationRelayoutIfNeeded() { }
526
527     bool isWritingModeRoot() const { return !parent() || parent()->style().writingMode() != style().writingMode(); }
528
529     bool isDeprecatedFlexItem() const { return !isInline() && !isFloatingOrOutOfFlowPositioned() && parent() && parent()->isDeprecatedFlexibleBox(); }
530     bool isFlexItemIncludingDeprecated() const { return !isInline() && !isFloatingOrOutOfFlowPositioned() && parent() && parent()->isFlexibleBoxIncludingDeprecated(); }
531     
532     LayoutUnit lineHeight(bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const override;
533     int baselinePosition(FontBaseline, bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const override;
534
535     LayoutUnit offsetLeft() const override;
536     LayoutUnit offsetTop() const override;
537
538     LayoutPoint flipForWritingModeForChild(const RenderBox* child, const LayoutPoint&) const;
539     LayoutUnit flipForWritingMode(LayoutUnit position) const; // The offset is in the block direction (y for horizontal writing modes, x for vertical writing modes).
540     LayoutPoint flipForWritingMode(const LayoutPoint&) const;
541     LayoutSize flipForWritingMode(const LayoutSize&) const;
542     void flipForWritingMode(LayoutRect&) const;
543     FloatPoint flipForWritingMode(const FloatPoint&) const;
544     void flipForWritingMode(FloatRect&) const;
545     // These represent your location relative to your container as a physical offset.
546     // In layout related methods you almost always want the logical location (e.g. x() and y()).
547     LayoutPoint topLeftLocation() const;
548     LayoutSize topLeftLocationOffset() const;
549     void applyTopLeftLocationOffset(LayoutPoint& point) const
550     {
551         // This is inlined for speed, since it is used by updateLayerPosition() during scrolling.
552         if (!document().view()->hasFlippedBlockRenderers())
553             point.move(m_frameRect.x(), m_frameRect.y());
554         else
555             applyTopLeftLocationOffsetWithFlipping(point);
556     }
557
558     LayoutRect logicalVisualOverflowRectForPropagation(const RenderStyle*) const;
559     LayoutRect visualOverflowRectForPropagation(const RenderStyle*) const;
560     LayoutRect logicalLayoutOverflowRectForPropagation(const RenderStyle*) const;
561     LayoutRect layoutOverflowRectForPropagation(const RenderStyle*) const;
562
563     bool hasRenderOverflow() const { return m_overflow; }    
564     bool hasVisualOverflow() const { return m_overflow && !borderBoxRect().contains(m_overflow->visualOverflowRect()); }
565
566     virtual bool needsPreferredWidthsRecalculation() const;
567     virtual void computeIntrinsicRatioInformation(FloatSize& /* intrinsicSize */, double& /* intrinsicRatio */) const { }
568
569     ScrollPosition scrollPosition() const;
570     LayoutSize cachedSizeForOverflowClip() const;
571
572     bool shouldApplyClipAndScrollPositionForRepaint(const RenderLayerModelObject* repaintContainer) const;
573     void applyCachedClipAndScrollPositionForRepaint(LayoutRect& paintRect) const;
574
575     virtual bool hasRelativeDimensions() const;
576     virtual bool hasRelativeLogicalHeight() const;
577     virtual bool hasRelativeLogicalWidth() const;
578
579     bool hasHorizontalLayoutOverflow() const
580     {
581         if (!m_overflow)
582             return false;
583
584         LayoutRect layoutOverflowRect = m_overflow->layoutOverflowRect();
585         flipForWritingMode(layoutOverflowRect);
586         return layoutOverflowRect.x() < x() || layoutOverflowRect.maxX() > x() + logicalWidth();
587     }
588
589     bool hasVerticalLayoutOverflow() const
590     {
591         if (!m_overflow)
592             return false;
593
594         LayoutRect layoutOverflowRect = m_overflow->layoutOverflowRect();
595         flipForWritingMode(layoutOverflowRect);
596         return layoutOverflowRect.y() < y() || layoutOverflowRect.maxY() > y() + logicalHeight();
597     }
598
599     virtual std::unique_ptr<RenderBox> createAnonymousBoxWithSameTypeAs(const RenderBox&) const
600     {
601         ASSERT_NOT_REACHED();
602         return nullptr;
603     }
604
605     ShapeOutsideInfo* shapeOutsideInfo() const
606     {
607         return ShapeOutsideInfo::isEnabledFor(*this) ? ShapeOutsideInfo::info(*this) : nullptr;
608     }
609
610     void markShapeOutsideDependentsForLayout()
611     {
612         if (isFloating())
613             removeFloatingOrPositionedChildFromBlockLists();
614     }
615
616     // True if this box can have a range in an outside fragmentation context.
617     bool canHaveOutsideRegionRange() const { return !isInFlowRenderFlowThread(); }
618     virtual bool needsLayoutAfterRegionRangeChange() const { return false; }
619
620     const RenderBox* findEnclosingScrollableContainer() const;
621
622 protected:
623     RenderBox(Element&, RenderStyle&&, BaseTypeFlags);
624     RenderBox(Document&, RenderStyle&&, BaseTypeFlags);
625
626     void styleWillChange(StyleDifference, const RenderStyle& newStyle) override;
627     void styleDidChange(StyleDifference, const RenderStyle* oldStyle) override;
628     void updateFromStyle() override;
629
630     void willBeRemovedFromTree() override;
631
632     bool createsNewFormattingContext() const;
633
634     // Returns false if it could not cheaply compute the extent (e.g. fixed background), in which case the returned rect may be incorrect.
635     bool getBackgroundPaintedExtent(const LayoutPoint& paintOffset, LayoutRect&) const;
636     virtual bool foregroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect, unsigned maxDepthToTest) const;
637     bool computeBackgroundIsKnownToBeObscured(const LayoutPoint& paintOffset) override;
638
639     void paintBackground(const PaintInfo&, const LayoutRect&, BackgroundBleedAvoidance = BackgroundBleedNone);
640     
641     void paintFillLayer(const PaintInfo&, const Color&, const FillLayer*, const LayoutRect&, BackgroundBleedAvoidance, CompositeOperator, RenderElement* backgroundObject, BaseBackgroundColorUsage = BaseBackgroundColorUse);
642     void paintFillLayers(const PaintInfo&, const Color&, const FillLayer*, const LayoutRect&, BackgroundBleedAvoidance = BackgroundBleedNone, CompositeOperator = CompositeSourceOver, RenderElement* backgroundObject = nullptr);
643
644     void paintMaskImages(const PaintInfo&, const LayoutRect&);
645
646     BackgroundBleedAvoidance determineBackgroundBleedAvoidance(GraphicsContext&) const;
647     bool backgroundHasOpaqueTopLayer() const;
648
649     void computePositionedLogicalWidth(LogicalExtentComputedValues&, RenderRegion* = nullptr) const;
650
651     LayoutUnit computeIntrinsicLogicalWidthUsing(Length logicalWidthLength, LayoutUnit availableLogicalWidth, LayoutUnit borderAndPadding) const;
652     virtual Optional<LayoutUnit> computeIntrinsicLogicalContentHeightUsing(Length logicalHeightLength, Optional<LayoutUnit> intrinsicContentHeight, LayoutUnit borderAndPadding) const;
653     
654     virtual bool shouldComputeSizeAsReplaced() const { return isReplaced() && !isInlineBlockOrInlineTable(); }
655
656     void mapLocalToContainer(const RenderLayerModelObject* repaintContainer, TransformState&, MapCoordinatesFlags, bool* wasFixed) const override;
657     const RenderObject* pushMappingToContainer(const RenderLayerModelObject*, RenderGeometryMap&) const override;
658     void mapAbsoluteToLocalPoint(MapCoordinatesFlags, TransformState&) const override;
659
660     void paintRootBoxFillLayers(const PaintInfo&);
661
662     RenderObject* splitAnonymousBoxesAroundChild(RenderObject* beforeChild);
663  
664 private:
665     void updateShapeOutsideInfoAfterStyleChange(const RenderStyle&, const RenderStyle* oldStyle);
666
667 #if ENABLE(CSS_GRID_LAYOUT)
668     bool isGridItem() const { return parent() && parent()->isRenderGrid(); }
669 #endif
670
671     bool scrollLayer(ScrollDirection, ScrollGranularity, float multiplier, Element** stopElement);
672
673     bool fixedElementLaysOutRelativeToFrame(const FrameView&) const;
674
675     bool includeVerticalScrollbarSize() const;
676     bool includeHorizontalScrollbarSize() const;
677
678     bool isScrollableOrRubberbandableBox() const override;
679
680     // Returns true if we did a full repaint
681     bool repaintLayerRectsForImage(WrappedImagePtr image, const FillLayer* layers, bool drawingBackground);
682
683     bool skipContainingBlockForPercentHeightCalculation(const RenderBox& containingBlock, bool isPerpendicularWritingMode) const;
684    
685     LayoutUnit containingBlockLogicalWidthForPositioned(const RenderBoxModelObject& containingBlock, RenderRegion* = nullptr, bool checkForPerpendicularWritingMode = true) const;
686     LayoutUnit containingBlockLogicalHeightForPositioned(const RenderBoxModelObject& containingBlock, bool checkForPerpendicularWritingMode = true) const;
687
688     LayoutUnit viewLogicalHeightForPercentages() const;
689
690     void computePositionedLogicalHeight(LogicalExtentComputedValues&) const;
691     void computePositionedLogicalWidthUsing(SizeType, Length logicalWidth, const RenderBoxModelObject& containerBlock, TextDirection containerDirection,
692                                             LayoutUnit containerLogicalWidth, LayoutUnit bordersPlusPadding,
693                                             Length logicalLeft, Length logicalRight, Length marginLogicalLeft, Length marginLogicalRight,
694                                             LogicalExtentComputedValues&) const;
695     void computePositionedLogicalHeightUsing(SizeType, Length logicalHeightLength, const RenderBoxModelObject& containerBlock,
696                                              LayoutUnit containerLogicalHeight, LayoutUnit bordersPlusPadding, LayoutUnit logicalHeight,
697                                              Length logicalTop, Length logicalBottom, Length marginLogicalTop, Length marginLogicalBottom,
698                                              LogicalExtentComputedValues&) const;
699
700     void computePositionedLogicalHeightReplaced(LogicalExtentComputedValues&) const;
701     void computePositionedLogicalWidthReplaced(LogicalExtentComputedValues&) const;
702
703     LayoutUnit fillAvailableMeasure(LayoutUnit availableLogicalWidth) const;
704     LayoutUnit fillAvailableMeasure(LayoutUnit availableLogicalWidth, LayoutUnit& marginStart, LayoutUnit& marginEnd) const;
705
706     virtual void computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const;
707
708     // This function calculates the minimum and maximum preferred widths for an object.
709     // These values are used in shrink-to-fit layout systems.
710     // These include tables, positioned objects, floats and flexible boxes.
711     virtual void computePreferredLogicalWidths() { setPreferredLogicalWidthsDirty(false); }
712
713     LayoutRect frameRectForStickyPositioning() const final { return frameRect(); }
714     
715     void applyTopLeftLocationOffsetWithFlipping(LayoutPoint&) const;
716
717 private:
718     // The width/height of the contents + borders + padding.  The x/y location is relative to our container (which is not always our parent).
719     LayoutRect m_frameRect;
720
721 protected:
722     LayoutBoxExtent m_marginBox;
723
724     // The preferred logical width of the element if it were to break its lines at every possible opportunity.
725     LayoutUnit m_minPreferredLogicalWidth;
726     
727     // The preferred logical width of the element if it never breaks any lines at all.
728     LayoutUnit m_maxPreferredLogicalWidth;
729
730     // For inline replaced elements, the inline box that owns us.
731     InlineElementBox* m_inlineBoxWrapper { nullptr };
732
733     // Our overflow information.
734     RefPtr<RenderOverflow> m_overflow;
735
736 private:
737     // Used to store state between styleWillChange and styleDidChange
738     static bool s_hadOverflowClip;
739 };
740
741 inline RenderBox* RenderBox::previousSiblingBox() const
742 {
743     return downcast<RenderBox>(previousSibling());
744 }
745
746 inline RenderBox* RenderBox::nextSiblingBox() const
747
748     return downcast<RenderBox>(nextSibling());
749 }
750
751 inline RenderBox* RenderBox::parentBox() const
752 {
753     return downcast<RenderBox>(parent());
754 }
755
756 inline RenderBox* RenderBox::firstChildBox() const
757 {
758     return downcast<RenderBox>(firstChild());
759 }
760
761 inline RenderBox* RenderBox::lastChildBox() const
762 {
763     return downcast<RenderBox>(lastChild());
764 }
765
766 inline void RenderBox::setInlineBoxWrapper(InlineElementBox* boxWrapper)
767 {
768     if (boxWrapper) {
769         ASSERT(!m_inlineBoxWrapper);
770         // m_inlineBoxWrapper should already be 0. Deleting it is a safeguard against security issues.
771         // Otherwise, there will two line box wrappers keeping the reference to this renderer, and
772         // only one will be notified when the renderer is getting destroyed. The second line box wrapper
773         // will keep a stale reference.
774         if (UNLIKELY(m_inlineBoxWrapper != nullptr))
775             deleteLineBoxWrapper();
776     }
777
778     m_inlineBoxWrapper = boxWrapper;
779 }
780
781 } // namespace WebCore
782
783 SPECIALIZE_TYPE_TRAITS_RENDER_OBJECT(RenderBox, isBox())
784
785 #endif // RenderBox_h