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