Enable fieldsets to be flexboxes, grids and multicolumn.
[WebKit-https.git] / Source / WebCore / rendering / RenderBlock.h
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  *           (C) 2007 David Smith (catfish.man@gmail.com)
5  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Library General Public
9  * License as published by the Free Software Foundation; either
10  * version 2 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Library General Public License for more details.
16  *
17  * You should have received a copy of the GNU Library General Public License
18  * along with this library; see the file COPYING.LIB.  If not, write to
19  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20  * Boston, MA 02110-1301, USA.
21  */
22
23 #pragma once
24
25 #include "GapRects.h"
26 #include "LineWidth.h"
27 #include "RenderBox.h"
28 #include "TextRun.h"
29 #include <memory>
30 #include <wtf/ListHashSet.h>
31
32 namespace WebCore {
33
34 class LayoutState;
35 class LineLayoutState;
36 class LogicalSelectionOffsetCaches;
37 class RenderInline;
38 class RenderText;
39
40 struct BidiRun;
41 struct PaintInfo;
42
43 typedef WTF::ListHashSet<RenderBox*> TrackedRendererListHashSet;
44
45 enum CaretType { CursorCaret, DragCaret };
46 enum ContainingBlockState { NewContainingBlock, SameContainingBlock };
47
48 enum TextRunFlag {
49     DefaultTextRunFlags = 0,
50     RespectDirection = 1 << 0,
51     RespectDirectionOverride = 1 << 1
52 };
53
54 typedef unsigned TextRunFlags;
55
56 class RenderBlock : public RenderBox {
57 public:
58     friend class LineLayoutState;
59     virtual ~RenderBlock();
60
61 protected:
62     RenderBlock(Element&, RenderStyle&&, BaseTypeFlags);
63     RenderBlock(Document&, RenderStyle&&, BaseTypeFlags);
64
65 public:
66     // These two functions are overridden for inline-block.
67     LayoutUnit lineHeight(bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const final;
68     int baselinePosition(FontBaseline, bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const override;
69
70     LayoutUnit minLineHeightForReplacedRenderer(bool isFirstLine, LayoutUnit replacedHeight) const;
71
72     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
73     virtual void deleteLines();
74
75     void addChild(RenderObject* newChild, RenderObject* beforeChild = 0) override;
76     void removeChild(RenderObject&) override;
77
78     virtual void layoutBlock(bool relayoutChildren, LayoutUnit pageLogicalHeight = 0);
79
80     virtual void invalidateLineLayoutPath() { }
81
82     void insertPositionedObject(RenderBox&);
83     static void removePositionedObject(const RenderBox&);
84     void removePositionedObjects(const RenderBlock*, ContainingBlockState = SameContainingBlock);
85
86     TrackedRendererListHashSet* positionedObjects() const;
87     bool hasPositionedObjects() const
88     {
89         TrackedRendererListHashSet* objects = positionedObjects();
90         return objects && !objects->isEmpty();
91     }
92
93     void addPercentHeightDescendant(RenderBox&);
94     static void removePercentHeightDescendant(RenderBox&);
95     TrackedRendererListHashSet* percentHeightDescendants() const;
96     bool hasPercentHeightDescendants() const
97     {
98         TrackedRendererListHashSet* objects = percentHeightDescendants();
99         return objects && !objects->isEmpty();
100     }
101     static bool hasPercentHeightContainerMap();
102     static bool hasPercentHeightDescendant(RenderBox&);
103     static void clearPercentHeightDescendantsFrom(RenderBox&);
104     static void removePercentHeightDescendantIfNeeded(RenderBox&);
105
106     void setHasMarginBeforeQuirk(bool b) { setRenderBlockHasMarginBeforeQuirk(b); }
107     void setHasMarginAfterQuirk(bool b) { setRenderBlockHasMarginAfterQuirk(b); }
108     void setShouldForceRelayoutChildren(bool b) { setRenderBlockShouldForceRelayoutChildren(b); }
109
110     bool hasMarginBeforeQuirk() const { return renderBlockHasMarginBeforeQuirk(); }
111     bool hasMarginAfterQuirk() const { return renderBlockHasMarginAfterQuirk(); }
112     bool hasBorderOrPaddingLogicalWidthChanged() const { return renderBlockShouldForceRelayoutChildren(); }
113
114     bool hasMarginBeforeQuirk(const RenderBox& child) const;
115     bool hasMarginAfterQuirk(const RenderBox& child) const;
116
117     bool generatesLineBoxesForInlineChild(RenderObject*);
118
119     void markPositionedObjectsForLayout();
120     void markForPaginationRelayoutIfNeeded() override;
121     
122     // FIXME-BLOCKFLOW: Remove virtualizaion when all of the line layout code has been moved out of RenderBlock
123     virtual bool containsFloats() const { return false; }
124
125     // Versions that can compute line offsets with the region and page offset passed in. Used for speed to avoid having to
126     // compute the region all over again when you already know it.
127     LayoutUnit availableLogicalWidthForLineInRegion(LayoutUnit position, IndentTextOrNot shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const
128     {
129         return std::max<LayoutUnit>(0, logicalRightOffsetForLineInRegion(position, shouldIndentText, region, logicalHeight)
130             - logicalLeftOffsetForLineInRegion(position, shouldIndentText, region, logicalHeight));
131     }
132     LayoutUnit logicalRightOffsetForLineInRegion(LayoutUnit position, IndentTextOrNot shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const
133     {
134         return logicalRightOffsetForLine(position, logicalRightOffsetForContent(region), shouldIndentText, logicalHeight);
135     }
136     LayoutUnit logicalLeftOffsetForLineInRegion(LayoutUnit position, IndentTextOrNot shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const
137     {
138         return logicalLeftOffsetForLine(position, logicalLeftOffsetForContent(region), shouldIndentText, logicalHeight);
139     }
140     LayoutUnit startOffsetForLineInRegion(LayoutUnit position, IndentTextOrNot shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const
141     {
142         return style().isLeftToRightDirection() ? logicalLeftOffsetForLineInRegion(position, shouldIndentText, region, logicalHeight)
143             : logicalWidth() - logicalRightOffsetForLineInRegion(position, shouldIndentText, region, logicalHeight);
144     }
145     LayoutUnit endOffsetForLineInRegion(LayoutUnit position, IndentTextOrNot shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const
146     {
147         return !style().isLeftToRightDirection() ? logicalLeftOffsetForLineInRegion(position, shouldIndentText, region, logicalHeight)
148             : logicalWidth() - logicalRightOffsetForLineInRegion(position, shouldIndentText, region, logicalHeight);
149     }
150
151     LayoutUnit availableLogicalWidthForLine(LayoutUnit position, IndentTextOrNot shouldIndentText, LayoutUnit logicalHeight = 0) const
152     {
153         return availableLogicalWidthForLineInRegion(position, shouldIndentText, regionAtBlockOffset(position), logicalHeight);
154     }
155     LayoutUnit logicalRightOffsetForLine(LayoutUnit position, IndentTextOrNot shouldIndentText, LayoutUnit logicalHeight = 0) const
156     {
157         return logicalRightOffsetForLine(position, logicalRightOffsetForContent(position), shouldIndentText, logicalHeight);
158     }
159     LayoutUnit logicalLeftOffsetForLine(LayoutUnit position, IndentTextOrNot shouldIndentText, LayoutUnit logicalHeight = 0) const
160     {
161         return logicalLeftOffsetForLine(position, logicalLeftOffsetForContent(position), shouldIndentText, logicalHeight);
162     }
163     LayoutUnit startOffsetForLine(LayoutUnit position, IndentTextOrNot shouldIndentText, LayoutUnit logicalHeight = 0) const
164     {
165         return style().isLeftToRightDirection() ? logicalLeftOffsetForLine(position, shouldIndentText, logicalHeight)
166             : logicalWidth() - logicalRightOffsetForLine(position, shouldIndentText, logicalHeight);
167     }
168     LayoutUnit endOffsetForLine(LayoutUnit position, IndentTextOrNot shouldIndentText, LayoutUnit logicalHeight = 0) const
169     {
170         return !style().isLeftToRightDirection() ? logicalLeftOffsetForLine(position, shouldIndentText, logicalHeight)
171             : logicalWidth() - logicalRightOffsetForLine(position, shouldIndentText, logicalHeight);
172     }
173
174     LayoutUnit textIndentOffset() const;
175
176     VisiblePosition positionForPoint(const LayoutPoint&, const RenderRegion*) override;
177
178     GapRects selectionGapRectsForRepaint(const RenderLayerModelObject* repaintContainer);
179     LayoutRect logicalLeftSelectionGap(RenderBlock& rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
180         RenderBoxModelObject* selObj, LayoutUnit logicalLeft, LayoutUnit logicalTop, LayoutUnit logicalHeight, const LogicalSelectionOffsetCaches&, const PaintInfo*);
181     LayoutRect logicalRightSelectionGap(RenderBlock& rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
182         RenderBoxModelObject* selObj, LayoutUnit logicalRight, LayoutUnit logicalTop, LayoutUnit logicalHeight, const LogicalSelectionOffsetCaches&, const PaintInfo*);
183     void getSelectionGapInfo(SelectionState, bool& leftGap, bool& rightGap);
184     bool isSelectionRoot() const;
185
186     LayoutRect logicalRectToPhysicalRect(const LayoutPoint& physicalPosition, const LayoutRect& logicalRect);
187
188     void addContinuationWithOutline(RenderInline*);
189     bool paintsContinuationOutline(RenderInline*);
190
191     RenderBoxModelObject* virtualContinuation() const final { return continuation(); }
192     bool isAnonymousBlockContinuation() const { return isAnonymousBlock() && continuation(); }
193     WEBCORE_EXPORT RenderInline* inlineElementContinuation() const;
194     RenderBlock* blockElementContinuation() const;
195
196     using RenderBoxModelObject::continuation;
197     using RenderBoxModelObject::setContinuation;
198
199     static std::unique_ptr<RenderBlock> createAnonymousWithParentRendererAndDisplay(const RenderBox& parent, EDisplay = BLOCK);
200     RenderBlock* createAnonymousBlock(EDisplay = BLOCK) const;
201     static void dropAnonymousBoxChild(RenderBlock& parent, RenderBlock& child);
202
203     std::unique_ptr<RenderBox> createAnonymousBoxWithSameTypeAs(const RenderBox&) const override;
204
205     static bool shouldSkipCreatingRunsForObject(RenderObject& obj)
206     {
207         return obj.isFloating() || (obj.isOutOfFlowPositioned() && !obj.style().isOriginalDisplayInlineType() && !obj.container()->isRenderInline());
208     }
209
210     static TextRun constructTextRun(StringView, const RenderStyle&,
211         ExpansionBehavior = DefaultExpansion, TextRunFlags = DefaultTextRunFlags);
212     static TextRun constructTextRun(const String&, const RenderStyle&,
213         ExpansionBehavior = DefaultExpansion, TextRunFlags = DefaultTextRunFlags);
214     static TextRun constructTextRun(const AtomicString&, const RenderStyle&,
215         ExpansionBehavior = DefaultExpansion, TextRunFlags = DefaultTextRunFlags);
216     static TextRun constructTextRun(const RenderText&, const RenderStyle&,
217         ExpansionBehavior = DefaultExpansion);
218     static TextRun constructTextRun(const RenderText&, unsigned offset, unsigned length, const RenderStyle&,
219         ExpansionBehavior = DefaultExpansion);
220     static TextRun constructTextRun(const LChar* characters, unsigned length, const RenderStyle&,
221         ExpansionBehavior = DefaultExpansion);
222     static TextRun constructTextRun(const UChar* characters, unsigned length, const RenderStyle&,
223         ExpansionBehavior = DefaultExpansion);
224     
225     LayoutUnit paginationStrut() const;
226     void setPaginationStrut(LayoutUnit);
227
228     // The page logical offset is the object's offset from the top of the page in the page progression
229     // direction (so an x-offset in vertical text and a y-offset for horizontal text).
230     LayoutUnit pageLogicalOffset() const;
231     void setPageLogicalOffset(LayoutUnit);
232
233     // Fieldset legends that are taller than the fieldset border add in intrinsic border
234     // in order to ensure that content gets properly pushed down across all layout systems
235     // (flexbox, block, etc.)
236     LayoutUnit intrinsicBorderForFieldset() const;
237     void setIntrinsicBorderForFieldset(LayoutUnit);
238     LayoutUnit borderTop() const override;
239     LayoutUnit borderBottom() const override;
240     LayoutUnit borderLeft() const override;
241     LayoutUnit borderRight() const override;
242     LayoutUnit borderBefore() const override;
243     LayoutUnit adjustBorderBoxLogicalHeightForBoxSizing(LayoutUnit height) const override;
244     LayoutUnit adjustContentBoxLogicalHeightForBoxSizing(std::optional<LayoutUnit> height) const override;
245     void paintExcludedChildrenInBorder(PaintInfo&, const LayoutPoint&);
246     
247     // Accessors for logical width/height and margins in the containing block's block-flow direction.
248     enum ApplyLayoutDeltaMode { ApplyLayoutDelta, DoNotApplyLayoutDelta };
249     LayoutUnit logicalWidthForChild(const RenderBox& child) const { return isHorizontalWritingMode() ? child.width() : child.height(); }
250     LayoutUnit logicalHeightForChild(const RenderBox& child) const { return isHorizontalWritingMode() ? child.height() : child.width(); }
251     LayoutSize logicalSizeForChild(const RenderBox& child) const { return isHorizontalWritingMode() ? child.size() : child.size().transposedSize(); }
252     LayoutUnit logicalTopForChild(const RenderBox& child) const { return isHorizontalWritingMode() ? child.y() : child.x(); }
253     void setLogicalLeftForChild(RenderBox& child, LayoutUnit logicalLeft, ApplyLayoutDeltaMode = DoNotApplyLayoutDelta);
254     void setLogicalTopForChild(RenderBox& child, LayoutUnit logicalTop, ApplyLayoutDeltaMode = DoNotApplyLayoutDelta);
255     LayoutUnit marginBeforeForChild(const RenderBoxModelObject& child) const { return child.marginBefore(&style()); }
256     LayoutUnit marginAfterForChild(const RenderBoxModelObject& child) const { return child.marginAfter(&style()); }
257     LayoutUnit marginStartForChild(const RenderBoxModelObject& child) const { return child.marginStart(&style()); }
258     LayoutUnit marginEndForChild(const RenderBoxModelObject& child) const { return child.marginEnd(&style()); }
259     void setMarginStartForChild(RenderBox& child, LayoutUnit value) const { child.setMarginStart(value, &style()); }
260     void setMarginEndForChild(RenderBox& child, LayoutUnit value) const { child.setMarginEnd(value, &style()); }
261     void setMarginBeforeForChild(RenderBox& child, LayoutUnit value) const { child.setMarginBefore(value, &style()); }
262     void setMarginAfterForChild(RenderBox& child, LayoutUnit value) const { child.setMarginAfter(value, &style()); }
263     LayoutUnit collapsedMarginBeforeForChild(const RenderBox& child) const;
264     LayoutUnit collapsedMarginAfterForChild(const RenderBox& child) const;
265
266     enum class RenderTreeMutationIsAllowed { Yes, No };
267     virtual void updateFirstLetter(RenderTreeMutationIsAllowed = RenderTreeMutationIsAllowed::Yes);
268     void getFirstLetter(RenderObject*& firstLetter, RenderElement*& firstLetterContainer, RenderObject* skipObject = nullptr);
269
270     virtual void scrollbarsChanged(bool /*horizontalScrollbarChanged*/, bool /*verticalScrollbarChanged*/) { }
271
272     LayoutUnit logicalLeftOffsetForContent(RenderRegion*) const;
273     LayoutUnit logicalRightOffsetForContent(RenderRegion*) const;
274     LayoutUnit availableLogicalWidthForContent(RenderRegion* region) const
275     { 
276         return std::max<LayoutUnit>(0, logicalRightOffsetForContent(region) - logicalLeftOffsetForContent(region));
277     }
278     LayoutUnit startOffsetForContent(RenderRegion* region) const
279     {
280         return style().isLeftToRightDirection() ? logicalLeftOffsetForContent(region) : logicalWidth() - logicalRightOffsetForContent(region);
281     }
282     LayoutUnit endOffsetForContent(RenderRegion* region) const
283     {
284         return !style().isLeftToRightDirection() ? logicalLeftOffsetForContent(region) : logicalWidth() - logicalRightOffsetForContent(region);
285     }
286     LayoutUnit logicalLeftOffsetForContent(LayoutUnit blockOffset) const
287     {
288         return logicalLeftOffsetForContent(regionAtBlockOffset(blockOffset));
289     }
290     LayoutUnit logicalRightOffsetForContent(LayoutUnit blockOffset) const
291     {
292         return logicalRightOffsetForContent(regionAtBlockOffset(blockOffset));
293     }
294     LayoutUnit availableLogicalWidthForContent(LayoutUnit blockOffset) const
295     {
296         return availableLogicalWidthForContent(regionAtBlockOffset(blockOffset));
297     }
298     LayoutUnit startOffsetForContent(LayoutUnit blockOffset) const
299     {
300         return startOffsetForContent(regionAtBlockOffset(blockOffset));
301     }
302     LayoutUnit endOffsetForContent(LayoutUnit blockOffset) const
303     {
304         return endOffsetForContent(regionAtBlockOffset(blockOffset));
305     }
306     LayoutUnit logicalLeftOffsetForContent() const { return isHorizontalWritingMode() ? borderLeft() + paddingLeft() : borderTop() + paddingTop(); }
307     LayoutUnit logicalRightOffsetForContent() const { return logicalLeftOffsetForContent() + availableLogicalWidth(); }
308     LayoutUnit startOffsetForContent() const { return style().isLeftToRightDirection() ? logicalLeftOffsetForContent() : logicalWidth() - logicalRightOffsetForContent(); }
309     LayoutUnit endOffsetForContent() const { return !style().isLeftToRightDirection() ? logicalLeftOffsetForContent() : logicalWidth() - logicalRightOffsetForContent(); }
310
311     LayoutUnit logicalLeftSelectionOffset(RenderBlock& rootBlock, LayoutUnit position, const LogicalSelectionOffsetCaches&);
312     LayoutUnit logicalRightSelectionOffset(RenderBlock& rootBlock, LayoutUnit position, const LogicalSelectionOffsetCaches&);
313
314     LayoutUnit computeStartPositionDeltaForChildAvoidingFloats(const RenderBox& child, LayoutUnit childMarginStart, RenderRegion* = 0);
315
316 #ifndef NDEBUG
317     void checkPositionedObjectsNeedLayout();
318 #endif
319
320     void updateHitTestResult(HitTestResult&, const LayoutPoint&) override;
321
322     bool canHaveChildren() const override { return true; }
323     virtual bool canDropAnonymousBlockChild() const { return true; }
324
325     RenderFlowThread* cachedFlowThreadContainingBlock() const;
326     void setCachedFlowThreadContainingBlockNeedsUpdate();
327     virtual bool cachedFlowThreadContainingBlockNeedsUpdate() const;
328     void resetFlowThreadContainingBlockAndChildInfoIncludingDescendants();
329
330     std::optional<LayoutUnit> availableLogicalHeightForPercentageComputation() const;
331     bool hasDefiniteLogicalHeight() const;
332     
333 protected:
334     RenderFlowThread* locateFlowThreadContainingBlock() const override;
335     void willBeDestroyed() override;
336
337     void layout() override;
338
339     void layoutPositionedObjects(bool relayoutChildren, bool fixedPositionObjectsOnly = false);
340     virtual void layoutPositionedObject(RenderBox&, bool relayoutChildren, bool fixedPositionObjectsOnly);
341     
342     void markFixedPositionObjectForLayoutIfNeeded(RenderBox& child);
343
344     LayoutUnit marginIntrinsicLogicalWidthForChild(RenderBox&) const;
345
346     void paint(PaintInfo&, const LayoutPoint&) override;
347     void paintObject(PaintInfo&, const LayoutPoint&) override;
348     virtual void paintChildren(PaintInfo& forSelf, const LayoutPoint&, PaintInfo& forChild, bool usePrintRect);
349     enum PaintBlockType { PaintAsBlock, PaintAsInlineBlock };
350     bool paintChild(RenderBox&, PaintInfo& forSelf, const LayoutPoint&, PaintInfo& forChild, bool usePrintRect, PaintBlockType paintType = PaintAsBlock);
351    
352     LayoutUnit logicalRightOffsetForLine(LayoutUnit logicalTop, LayoutUnit fixedOffset, bool applyTextIndent, LayoutUnit logicalHeight = 0) const
353     {
354         return adjustLogicalRightOffsetForLine(logicalRightFloatOffsetForLine(logicalTop, fixedOffset, logicalHeight), applyTextIndent);
355     }
356     LayoutUnit logicalLeftOffsetForLine(LayoutUnit logicalTop, LayoutUnit fixedOffset, bool applyTextIndent, LayoutUnit logicalHeight = 0) const
357     {
358         return adjustLogicalLeftOffsetForLine(logicalLeftFloatOffsetForLine(logicalTop, fixedOffset, logicalHeight), applyTextIndent);
359     }
360
361     bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) override;
362
363     void computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const override;
364     void computePreferredLogicalWidths() override;
365     
366     std::optional<int> firstLineBaseline() const override;
367     std::optional<int> inlineBlockBaseline(LineDirectionMode) const override;
368
369     // Delay updating scrollbars until endAndCommitUpdateScrollInfoAfterLayoutTransaction() is called. These functions are used
370     // when a flexbox is laying out its descendants. If multiple calls are made to beginUpdateScrollInfoAfterLayoutTransaction()
371     // then endAndCommitUpdateScrollInfoAfterLayoutTransaction() will do nothing until it is called the same number of times.
372     void beginUpdateScrollInfoAfterLayoutTransaction();
373     void endAndCommitUpdateScrollInfoAfterLayoutTransaction();
374
375     void removeFromUpdateScrollInfoAfterLayoutTransaction();
376
377     void updateScrollInfoAfterLayout();
378
379     void styleWillChange(StyleDifference, const RenderStyle& newStyle) override;
380     void styleDidChange(StyleDifference, const RenderStyle* oldStyle) override;
381
382     virtual bool hasLineIfEmpty() const;
383     
384     virtual bool canPerformSimplifiedLayout() const;
385     bool simplifiedLayout();
386     virtual void simplifiedNormalFlowLayout();
387
388     bool childBoxIsUnsplittableForFragmentation(const RenderBox& child) const;
389
390 public:
391     virtual void computeOverflow(LayoutUnit oldClientAfterEdge, bool recomputeFloats = false);
392     void clearLayoutOverflow();
393     
394     // Adjust from painting offsets to the local coords of this renderer
395     void offsetForContents(LayoutPoint&) const;
396     // Obtains the nearest enclosing block (including this block) that contributes a first-line style to our inline
397     // children.
398     RenderBlock* firstLineBlock() const override;
399
400     enum FieldsetFindLegendOption { FieldsetIgnoreFloatingOrOutOfFlow, FieldsetIncludeFloatingOrOutOfFlow };
401     RenderBox* findFieldsetLegend(FieldsetFindLegendOption = FieldsetIgnoreFloatingOrOutOfFlow) const;
402     virtual void layoutExcludedChildren(bool /*relayoutChildren*/);
403     virtual bool computePreferredWidthsForExcludedChildren(LayoutUnit&, LayoutUnit&) const;
404     
405     void adjustBorderBoxRectForPainting(LayoutRect&) override;
406     LayoutRect paintRectToClipOutFromBorder(const LayoutRect&) override;
407     
408 protected:
409     virtual void addOverflowFromChildren();
410     // FIXME-BLOCKFLOW: Remove virtualization when all callers have moved to RenderBlockFlow
411     virtual void addOverflowFromInlineChildren() { }
412     void addOverflowFromBlockChildren();
413     void addOverflowFromPositionedObjects();
414     void addVisualOverflowFromTheme();
415
416     void addFocusRingRects(Vector<LayoutRect>&, const LayoutPoint& additionalOffset, const RenderLayerModelObject* paintContainer = 0) override;
417     virtual void addFocusRingRectsForInlineChildren(Vector<LayoutRect>&, const LayoutPoint& additionalOffset, const RenderLayerModelObject* paintContainer);
418
419     void computeRegionRangeForBoxChild(const RenderBox&) const;
420
421     void estimateRegionRangeForBoxChild(const RenderBox&) const;
422     bool updateRegionRangeForBoxChild(const RenderBox&) const;
423
424     void updateBlockChildDirtyBitsBeforeLayout(bool relayoutChildren, RenderBox&);
425
426     void preparePaginationBeforeBlockLayout(bool&);
427
428     void computeChildPreferredLogicalWidths(RenderObject&, LayoutUnit& minPreferredLogicalWidth, LayoutUnit& maxPreferredLogicalWidth) const;
429
430 private:
431     static std::unique_ptr<RenderBlock> createAnonymousBlockWithStyleAndDisplay(Document&, const RenderStyle&, EDisplay);
432
433     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
434     virtual LayoutUnit logicalRightFloatOffsetForLine(LayoutUnit, LayoutUnit fixedOffset, LayoutUnit) const { return fixedOffset; };
435     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
436     virtual LayoutUnit logicalLeftFloatOffsetForLine(LayoutUnit, LayoutUnit fixedOffset, LayoutUnit) const { return fixedOffset; }
437     LayoutUnit adjustLogicalRightOffsetForLine(LayoutUnit offsetFromFloats, bool applyTextIndent) const;
438     LayoutUnit adjustLogicalLeftOffsetForLine(LayoutUnit offsetFromFloats, bool applyTextIndent) const;
439
440     const char* renderName() const override;
441
442     bool isInlineBlockOrInlineTable() const final { return isInline() && isReplaced(); }
443
444     void makeChildrenNonInline(RenderObject* insertionPoint = nullptr);
445     virtual void removeLeftoverAnonymousBlock(RenderBlock* child);
446
447     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
448     virtual void moveAllChildrenIncludingFloatsTo(RenderBlock& toBlock, bool fullRemoveInsert) { moveAllChildrenTo(&toBlock, fullRemoveInsert); }
449
450     void addChildToContinuation(RenderObject* newChild, RenderObject* beforeChild);
451     void addChildIgnoringContinuation(RenderObject* newChild, RenderObject* beforeChild) override;
452
453     bool isSelfCollapsingBlock() const override;
454     virtual bool childrenPreventSelfCollapsing() const;
455     
456     void createFirstLetterRenderer(RenderElement* firstLetterBlock, RenderText* currentTextChild);
457     void updateFirstLetterStyle(RenderElement* firstLetterBlock, RenderObject* firstLetterContainer);
458
459     Node* nodeForHitTest() const;
460
461     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
462     virtual void paintFloats(PaintInfo&, const LayoutPoint&, bool) { }
463     virtual void paintInlineChildren(PaintInfo&, const LayoutPoint&) { }
464     void paintContents(PaintInfo&, const LayoutPoint&);
465     virtual void paintColumnRules(PaintInfo&, const LayoutPoint&) { };
466     void paintSelection(PaintInfo&, const LayoutPoint&);
467     void paintCaret(PaintInfo&, const LayoutPoint&, CaretType);
468
469     bool avoidsFloats() const override;
470
471     virtual bool hitTestContents(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction);
472     // FIXME-BLOCKFLOW: Remove virtualization when all callers have moved to RenderBlockFlow
473     virtual bool hitTestFloats(const HitTestRequest&, HitTestResult&, const HitTestLocation&, const LayoutPoint&) { return false; }
474     virtual bool hitTestInlineChildren(const HitTestRequest&, HitTestResult&, const HitTestLocation&, const LayoutPoint&, HitTestAction) { return false; }
475
476     virtual bool isPointInOverflowControl(HitTestResult&, const LayoutPoint& locationInContainer, const LayoutPoint& accumulatedOffset);
477
478     void computeBlockPreferredLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const;
479     
480     LayoutRect rectWithOutlineForRepaint(const RenderLayerModelObject* repaintContainer, LayoutUnit outlineWidth) const final;
481     const RenderStyle& outlineStyleForRepaint() const final;
482
483     RenderElement* hoverAncestor() const final;
484     void updateDragState(bool dragOn) final;
485     void childBecameNonInline(RenderElement&) final;
486
487     LayoutRect selectionRectForRepaint(const RenderLayerModelObject* repaintContainer, bool /*clipToVisibleContent*/) final
488     {
489         return selectionGapRectsForRepaint(repaintContainer);
490     }
491     bool shouldPaintSelectionGaps() const final;
492     GapRects selectionGaps(RenderBlock& rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
493         LayoutUnit& lastLogicalTop, LayoutUnit& lastLogicalLeft, LayoutUnit& lastLogicalRight, const LogicalSelectionOffsetCaches&, const PaintInfo* = 0);
494     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
495     virtual GapRects inlineSelectionGaps(RenderBlock& rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
496         LayoutUnit& lastLogicalTop, LayoutUnit& lastLogicalLeft, LayoutUnit& lastLogicalRight, const LogicalSelectionOffsetCaches&, const PaintInfo*);
497     GapRects blockSelectionGaps(RenderBlock& rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
498         LayoutUnit& lastLogicalTop, LayoutUnit& lastLogicalLeft, LayoutUnit& lastLogicalRight, const LogicalSelectionOffsetCaches&, const PaintInfo*);
499     LayoutRect blockSelectionGap(RenderBlock& rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
500         LayoutUnit lastLogicalTop, LayoutUnit lastLogicalLeft, LayoutUnit lastLogicalRight, LayoutUnit logicalBottom, const LogicalSelectionOffsetCaches&, const PaintInfo*);
501
502     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
503     virtual void clipOutFloatingObjects(RenderBlock&, const PaintInfo*, const LayoutPoint&, const LayoutSize&) { };
504     friend class LogicalSelectionOffsetCaches;
505
506     void absoluteRects(Vector<IntRect>&, const LayoutPoint& accumulatedOffset) const override;
507     void absoluteQuads(Vector<FloatQuad>&, bool* wasFixed) const override;
508
509     void paintContinuationOutlines(PaintInfo&, const LayoutPoint&);
510
511     LayoutRect localCaretRect(InlineBox*, unsigned caretOffset, LayoutUnit* extraWidthToEndOfLine = 0) final;
512     
513     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
514     virtual VisiblePosition positionForPointWithInlineChildren(const LayoutPoint&, const RenderRegion*);
515
516     RenderPtr<RenderBlock> clone() const;
517     RenderBlock* continuationBefore(RenderObject* beforeChild);
518
519     RenderFlowThread* updateCachedFlowThreadContainingBlock(RenderFlowThread*) const;
520
521     void removePositionedObjectsIfNeeded(const RenderStyle& oldStyle, const RenderStyle& newStyle);
522
523 private:
524     bool hasRareData() const;
525     
526 protected:
527     void dirtyForLayoutFromPercentageHeightDescendants();
528
529 protected:
530     bool recomputeLogicalWidth();
531     
532 public:
533     LayoutUnit offsetFromLogicalTopOfFirstPage() const override;
534     RenderRegion* regionAtBlockOffset(LayoutUnit) const;
535
536     // FIXME: This is temporary to allow us to move code from RenderBlock into RenderBlockFlow that accesses member variables that we haven't moved out of
537     // RenderBlock yet.
538     friend class RenderBlockFlow;
539     // FIXME-BLOCKFLOW: Remove this when the line layout stuff has all moved out of RenderBlock
540     friend class LineBreaker;
541
542     // RenderRubyBase objects need to be able to split and merge, moving their children around
543     // (calling moveChildTo, moveAllChildrenTo, and makeChildrenNonInline).
544     friend class RenderRubyBase;
545
546 private:
547     // Used to store state between styleWillChange and styleDidChange
548     static bool s_canPropagateFloatIntoSibling;
549 };
550
551 LayoutUnit blockDirectionOffset(RenderBlock& rootBlock, const LayoutSize& offsetFromRootBlock);
552 LayoutUnit inlineDirectionOffset(RenderBlock& rootBlock, const LayoutSize& offsetFromRootBlock);
553 VisiblePosition positionForPointRespectingEditingBoundaries(RenderBlock&, RenderBox&, const LayoutPoint&);
554
555 inline std::unique_ptr<RenderBlock> RenderBlock::createAnonymousWithParentRendererAndDisplay(const RenderBox& parent, EDisplay display)
556 {
557     return createAnonymousBlockWithStyleAndDisplay(parent.document(), parent.style(), display);
558 }
559
560 inline std::unique_ptr<RenderBox> RenderBlock::createAnonymousBoxWithSameTypeAs(const RenderBox& renderer) const
561 {
562     return createAnonymousBlockWithStyleAndDisplay(document(), renderer.style(), style().display());
563 }
564
565 inline RenderBlock* RenderBlock::createAnonymousBlock(EDisplay display) const
566 {
567     return createAnonymousBlockWithStyleAndDisplay(document(), style(), display).release();
568 }
569
570 } // namespace WebCore
571
572 SPECIALIZE_TYPE_TRAITS_RENDER_OBJECT(RenderBlock, isRenderBlock())