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