RenderFlowThread's containing block cache should be invalidated before calling styleD...
[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 #ifndef RenderBlock_h
24 #define RenderBlock_h
25
26 #include "GapRects.h"
27 #include "LineWidth.h"
28 #include "RenderBox.h"
29 #include "TextRun.h"
30 #include <memory>
31 #include <wtf/ListHashSet.h>
32
33 namespace WebCore {
34
35 class LayoutState;
36 class LineLayoutState;
37 class LogicalSelectionOffsetCaches;
38 class RenderInline;
39 class RenderText;
40
41 struct BidiRun;
42 struct PaintInfo;
43
44 typedef WTF::ListHashSet<RenderBox*> TrackedRendererListHashSet;
45
46 enum CaretType { CursorCaret, DragCaret };
47 enum ContainingBlockState { NewContainingBlock, SameContainingBlock };
48
49 enum TextRunFlag {
50     DefaultTextRunFlags = 0,
51     RespectDirection = 1 << 0,
52     RespectDirectionOverride = 1 << 1
53 };
54
55 typedef unsigned TextRunFlags;
56
57 class RenderBlock : public RenderBox {
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(RenderObject* newChild, RenderObject* beforeChild = 0) override;
77     void removeChild(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     static bool hasPercentHeightContainerMap();
98     static bool hasPercentHeightDescendant(RenderBox&);
99     static void clearPercentHeightDescendantsFrom(RenderBox&);
100     static void removePercentHeightDescendantIfNeeded(RenderBox&);
101
102     void setHasMarginBeforeQuirk(bool b) { setRenderBlockHasMarginBeforeQuirk(b); }
103     void setHasMarginAfterQuirk(bool b) { setRenderBlockHasMarginAfterQuirk(b); }
104     void setShouldForceRelayoutChildren(bool b) { setRenderBlockShouldForceRelayoutChildren(b); }
105
106     bool hasMarginBeforeQuirk() const { return renderBlockHasMarginBeforeQuirk(); }
107     bool hasMarginAfterQuirk() const { return renderBlockHasMarginAfterQuirk(); }
108     bool hasBorderOrPaddingLogicalWidthChanged() const { return renderBlockShouldForceRelayoutChildren(); }
109
110     bool hasMarginBeforeQuirk(const RenderBox& child) const;
111     bool hasMarginAfterQuirk(const RenderBox& child) const;
112
113     bool generatesLineBoxesForInlineChild(RenderObject*);
114
115     void markPositionedObjectsForLayout();
116     void markForPaginationRelayoutIfNeeded() override;
117     
118     // FIXME-BLOCKFLOW: Remove virtualizaion when all of the line layout code has been moved out of RenderBlock
119     virtual bool containsFloats() const { return false; }
120
121     // Versions that can compute line offsets with the region and page offset passed in. Used for speed to avoid having to
122     // compute the region all over again when you already know it.
123     LayoutUnit availableLogicalWidthForLineInRegion(LayoutUnit position, IndentTextOrNot shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const
124     {
125         return std::max<LayoutUnit>(0, logicalRightOffsetForLineInRegion(position, shouldIndentText, region, logicalHeight)
126             - logicalLeftOffsetForLineInRegion(position, shouldIndentText, region, logicalHeight));
127     }
128     LayoutUnit logicalRightOffsetForLineInRegion(LayoutUnit position, IndentTextOrNot shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const
129     {
130         return logicalRightOffsetForLine(position, logicalRightOffsetForContent(region), shouldIndentText, logicalHeight);
131     }
132     LayoutUnit logicalLeftOffsetForLineInRegion(LayoutUnit position, IndentTextOrNot shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const
133     {
134         return logicalLeftOffsetForLine(position, logicalLeftOffsetForContent(region), shouldIndentText, logicalHeight);
135     }
136     LayoutUnit startOffsetForLineInRegion(LayoutUnit position, IndentTextOrNot shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const
137     {
138         return style().isLeftToRightDirection() ? logicalLeftOffsetForLineInRegion(position, shouldIndentText, region, logicalHeight)
139             : logicalWidth() - logicalRightOffsetForLineInRegion(position, shouldIndentText, region, logicalHeight);
140     }
141     LayoutUnit endOffsetForLineInRegion(LayoutUnit position, IndentTextOrNot shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const
142     {
143         return !style().isLeftToRightDirection() ? logicalLeftOffsetForLineInRegion(position, shouldIndentText, region, logicalHeight)
144             : logicalWidth() - logicalRightOffsetForLineInRegion(position, shouldIndentText, region, logicalHeight);
145     }
146
147     LayoutUnit availableLogicalWidthForLine(LayoutUnit position, IndentTextOrNot shouldIndentText, LayoutUnit logicalHeight = 0) const
148     {
149         return availableLogicalWidthForLineInRegion(position, shouldIndentText, regionAtBlockOffset(position), logicalHeight);
150     }
151     LayoutUnit logicalRightOffsetForLine(LayoutUnit position, IndentTextOrNot shouldIndentText, LayoutUnit logicalHeight = 0) const
152     {
153         return logicalRightOffsetForLine(position, logicalRightOffsetForContent(position), shouldIndentText, logicalHeight);
154     }
155     LayoutUnit logicalLeftOffsetForLine(LayoutUnit position, IndentTextOrNot shouldIndentText, LayoutUnit logicalHeight = 0) const
156     {
157         return logicalLeftOffsetForLine(position, logicalLeftOffsetForContent(position), shouldIndentText, logicalHeight);
158     }
159     LayoutUnit startOffsetForLine(LayoutUnit position, IndentTextOrNot shouldIndentText, LayoutUnit logicalHeight = 0) const
160     {
161         return style().isLeftToRightDirection() ? logicalLeftOffsetForLine(position, shouldIndentText, logicalHeight)
162             : logicalWidth() - logicalRightOffsetForLine(position, shouldIndentText, logicalHeight);
163     }
164     LayoutUnit endOffsetForLine(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
170     LayoutUnit textIndentOffset() const;
171
172     VisiblePosition positionForPoint(const LayoutPoint&, const RenderRegion*) override;
173
174     GapRects selectionGapRectsForRepaint(const RenderLayerModelObject* repaintContainer);
175     LayoutRect logicalLeftSelectionGap(RenderBlock& rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
176         RenderBoxModelObject* selObj, LayoutUnit logicalLeft, LayoutUnit logicalTop, LayoutUnit logicalHeight, const LogicalSelectionOffsetCaches&, const PaintInfo*);
177     LayoutRect logicalRightSelectionGap(RenderBlock& rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
178         RenderBoxModelObject* selObj, LayoutUnit logicalRight, LayoutUnit logicalTop, LayoutUnit logicalHeight, const LogicalSelectionOffsetCaches&, const PaintInfo*);
179     void getSelectionGapInfo(SelectionState, bool& leftGap, bool& rightGap);
180     RenderBlock* blockBeforeWithinSelectionRoot(LayoutSize& offset) const;
181
182     LayoutRect logicalRectToPhysicalRect(const LayoutPoint& physicalPosition, const LayoutRect& logicalRect);
183
184     void addContinuationWithOutline(RenderInline*);
185     bool paintsContinuationOutline(RenderInline*);
186
187     RenderBoxModelObject* virtualContinuation() const final { return continuation(); }
188     bool isAnonymousBlockContinuation() const { return isAnonymousBlock() && continuation(); }
189     WEBCORE_EXPORT RenderInline* inlineElementContinuation() const;
190     RenderBlock* blockElementContinuation() const;
191
192     using RenderBoxModelObject::continuation;
193     using RenderBoxModelObject::setContinuation;
194
195     static std::unique_ptr<RenderBlock> createAnonymousWithParentRendererAndDisplay(const RenderBox& parent, EDisplay = BLOCK);
196     RenderBlock* createAnonymousBlock(EDisplay = BLOCK) const;
197     static void dropAnonymousBoxChild(RenderBlock& parent, RenderBlock& child);
198
199     std::unique_ptr<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     // Accessors for logical width/height and margins in the containing block's block-flow direction.
230     enum ApplyLayoutDeltaMode { ApplyLayoutDelta, DoNotApplyLayoutDelta };
231     LayoutUnit logicalWidthForChild(const RenderBox& child) const { return isHorizontalWritingMode() ? child.width() : child.height(); }
232     LayoutUnit logicalHeightForChild(const RenderBox& child) const { return isHorizontalWritingMode() ? child.height() : child.width(); }
233     LayoutSize logicalSizeForChild(const RenderBox& child) const { return isHorizontalWritingMode() ? child.size() : child.size().transposedSize(); }
234     LayoutUnit logicalTopForChild(const RenderBox& child) const { return isHorizontalWritingMode() ? child.y() : child.x(); }
235     void setLogicalLeftForChild(RenderBox& child, LayoutUnit logicalLeft, ApplyLayoutDeltaMode = DoNotApplyLayoutDelta);
236     void setLogicalTopForChild(RenderBox& child, LayoutUnit logicalTop, ApplyLayoutDeltaMode = DoNotApplyLayoutDelta);
237     LayoutUnit marginBeforeForChild(const RenderBoxModelObject& child) const { return child.marginBefore(&style()); }
238     LayoutUnit marginAfterForChild(const RenderBoxModelObject& child) const { return child.marginAfter(&style()); }
239     LayoutUnit marginStartForChild(const RenderBoxModelObject& child) const { return child.marginStart(&style()); }
240     LayoutUnit marginEndForChild(const RenderBoxModelObject& child) const { return child.marginEnd(&style()); }
241     void setMarginStartForChild(RenderBox& child, LayoutUnit value) const { child.setMarginStart(value, &style()); }
242     void setMarginEndForChild(RenderBox& child, LayoutUnit value) const { child.setMarginEnd(value, &style()); }
243     void setMarginBeforeForChild(RenderBox& child, LayoutUnit value) const { child.setMarginBefore(value, &style()); }
244     void setMarginAfterForChild(RenderBox& child, LayoutUnit value) const { child.setMarginAfter(value, &style()); }
245     LayoutUnit collapsedMarginBeforeForChild(const RenderBox& child) const;
246     LayoutUnit collapsedMarginAfterForChild(const RenderBox& child) const;
247
248     enum class RenderTreeMutationIsAllowed { Yes, No };
249     virtual void updateFirstLetter(RenderTreeMutationIsAllowed = RenderTreeMutationIsAllowed::Yes);
250     void getFirstLetter(RenderObject*& firstLetter, RenderElement*& firstLetterContainer, RenderObject* skipObject = nullptr);
251
252     virtual void scrollbarsChanged(bool /*horizontalScrollbarChanged*/, bool /*verticalScrollbarChanged*/) { }
253
254     LayoutUnit logicalLeftOffsetForContent(RenderRegion*) const;
255     LayoutUnit logicalRightOffsetForContent(RenderRegion*) const;
256     LayoutUnit availableLogicalWidthForContent(RenderRegion* region) const
257     { 
258         return std::max<LayoutUnit>(0, logicalRightOffsetForContent(region) - logicalLeftOffsetForContent(region));
259     }
260     LayoutUnit startOffsetForContent(RenderRegion* region) const
261     {
262         return style().isLeftToRightDirection() ? logicalLeftOffsetForContent(region) : logicalWidth() - logicalRightOffsetForContent(region);
263     }
264     LayoutUnit endOffsetForContent(RenderRegion* region) const
265     {
266         return !style().isLeftToRightDirection() ? logicalLeftOffsetForContent(region) : logicalWidth() - logicalRightOffsetForContent(region);
267     }
268     LayoutUnit logicalLeftOffsetForContent(LayoutUnit blockOffset) const
269     {
270         return logicalLeftOffsetForContent(regionAtBlockOffset(blockOffset));
271     }
272     LayoutUnit logicalRightOffsetForContent(LayoutUnit blockOffset) const
273     {
274         return logicalRightOffsetForContent(regionAtBlockOffset(blockOffset));
275     }
276     LayoutUnit availableLogicalWidthForContent(LayoutUnit blockOffset) const
277     {
278         return availableLogicalWidthForContent(regionAtBlockOffset(blockOffset));
279     }
280     LayoutUnit startOffsetForContent(LayoutUnit blockOffset) const
281     {
282         return startOffsetForContent(regionAtBlockOffset(blockOffset));
283     }
284     LayoutUnit endOffsetForContent(LayoutUnit blockOffset) const
285     {
286         return endOffsetForContent(regionAtBlockOffset(blockOffset));
287     }
288     LayoutUnit logicalLeftOffsetForContent() const { return isHorizontalWritingMode() ? borderLeft() + paddingLeft() : borderTop() + paddingTop(); }
289     LayoutUnit logicalRightOffsetForContent() const { return logicalLeftOffsetForContent() + availableLogicalWidth(); }
290     LayoutUnit startOffsetForContent() const { return style().isLeftToRightDirection() ? logicalLeftOffsetForContent() : logicalWidth() - logicalRightOffsetForContent(); }
291     LayoutUnit endOffsetForContent() const { return !style().isLeftToRightDirection() ? logicalLeftOffsetForContent() : logicalWidth() - logicalRightOffsetForContent(); }
292
293     LayoutUnit logicalLeftSelectionOffset(RenderBlock& rootBlock, LayoutUnit position, const LogicalSelectionOffsetCaches&);
294     LayoutUnit logicalRightSelectionOffset(RenderBlock& rootBlock, LayoutUnit position, const LogicalSelectionOffsetCaches&);
295
296     LayoutUnit computeStartPositionDeltaForChildAvoidingFloats(const RenderBox& child, LayoutUnit childMarginStart, RenderRegion* = 0);
297
298 #ifndef NDEBUG
299     void checkPositionedObjectsNeedLayout();
300 #endif
301
302     void updateHitTestResult(HitTestResult&, const LayoutPoint&) override;
303
304     bool canHaveChildren() const override { return true; }
305     virtual bool canDropAnonymousBlockChild() const { return true; }
306
307     RenderFlowThread* cachedFlowThreadContainingBlock() const;
308     void setCachedFlowThreadContainingBlockNeedsUpdate();
309     virtual bool cachedFlowThreadContainingBlockNeedsUpdate() const;
310     void resetFlowThreadContainingBlockAndChildInfoIncludingDescendants();
311
312 protected:
313     RenderFlowThread* locateFlowThreadContainingBlock() const override;
314     void willBeDestroyed() override;
315
316     void layout() override;
317
318     void layoutPositionedObjects(bool relayoutChildren, bool fixedPositionObjectsOnly = false);
319     virtual void layoutPositionedObject(RenderBox&, bool relayoutChildren, bool fixedPositionObjectsOnly);
320     
321     void markFixedPositionObjectForLayoutIfNeeded(RenderBox& child);
322
323     LayoutUnit marginIntrinsicLogicalWidthForChild(RenderBox&) const;
324
325     void paint(PaintInfo&, const LayoutPoint&) override;
326     void paintObject(PaintInfo&, const LayoutPoint&) override;
327     virtual void paintChildren(PaintInfo& forSelf, const LayoutPoint&, PaintInfo& forChild, bool usePrintRect);
328     enum PaintBlockType { PaintAsBlock, PaintAsInlineBlock };
329     bool paintChild(RenderBox&, PaintInfo& forSelf, const LayoutPoint&, PaintInfo& forChild, bool usePrintRect, PaintBlockType paintType = PaintAsBlock);
330    
331     LayoutUnit logicalRightOffsetForLine(LayoutUnit logicalTop, LayoutUnit fixedOffset, bool applyTextIndent, LayoutUnit logicalHeight = 0) const
332     {
333         return adjustLogicalRightOffsetForLine(logicalRightFloatOffsetForLine(logicalTop, fixedOffset, logicalHeight), applyTextIndent);
334     }
335     LayoutUnit logicalLeftOffsetForLine(LayoutUnit logicalTop, LayoutUnit fixedOffset, bool applyTextIndent, LayoutUnit logicalHeight = 0) const
336     {
337         return adjustLogicalLeftOffsetForLine(logicalLeftFloatOffsetForLine(logicalTop, fixedOffset, logicalHeight), applyTextIndent);
338     }
339
340     bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) override;
341
342     void computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const override;
343     void computePreferredLogicalWidths() override;
344     
345     Optional<int> firstLineBaseline() const override;
346     Optional<int> inlineBlockBaseline(LineDirectionMode) const override;
347
348     // Delay updating scrollbars until endAndCommitUpdateScrollInfoAfterLayoutTransaction() is called. These functions are used
349     // when a flexbox is laying out its descendants. If multiple calls are made to beginUpdateScrollInfoAfterLayoutTransaction()
350     // then endAndCommitUpdateScrollInfoAfterLayoutTransaction() will do nothing until it is called the same number of times.
351     void beginUpdateScrollInfoAfterLayoutTransaction();
352     void endAndCommitUpdateScrollInfoAfterLayoutTransaction();
353
354     void removeFromUpdateScrollInfoAfterLayoutTransaction();
355
356     void updateScrollInfoAfterLayout();
357
358     void styleWillChange(StyleDifference, const RenderStyle& newStyle) override;
359     void styleDidChange(StyleDifference, const RenderStyle* oldStyle) override;
360
361     virtual bool hasLineIfEmpty() const;
362     
363     virtual bool canPerformSimplifiedLayout() const;
364     bool simplifiedLayout();
365     virtual void simplifiedNormalFlowLayout();
366
367     bool childBoxIsUnsplittableForFragmentation(const RenderBox& child) const;
368
369 public:
370     virtual void computeOverflow(LayoutUnit oldClientAfterEdge, bool recomputeFloats = false);
371     void clearLayoutOverflow();
372     
373     // Adjust from painting offsets to the local coords of this renderer
374     void offsetForContents(LayoutPoint&) const;
375     // Obtains the nearest enclosing block (including this block) that contributes a first-line style to our inline
376     // children.
377     RenderBlock* firstLineBlock() const override;
378
379 protected:
380     virtual void addOverflowFromChildren();
381     // FIXME-BLOCKFLOW: Remove virtualization when all callers have moved to RenderBlockFlow
382     virtual void addOverflowFromInlineChildren() { }
383     void addOverflowFromBlockChildren();
384     void addOverflowFromPositionedObjects();
385     void addVisualOverflowFromTheme();
386
387     void addFocusRingRects(Vector<LayoutRect>&, const LayoutPoint& additionalOffset, const RenderLayerModelObject* paintContainer = 0) override;
388     virtual void addFocusRingRectsForInlineChildren(Vector<LayoutRect>&, const LayoutPoint& additionalOffset, const RenderLayerModelObject* paintContainer);
389
390     void computeRegionRangeForBoxChild(const RenderBox&) const;
391
392     void estimateRegionRangeForBoxChild(const RenderBox&) const;
393     bool updateRegionRangeForBoxChild(const RenderBox&) const;
394
395     void updateBlockChildDirtyBitsBeforeLayout(bool relayoutChildren, RenderBox&);
396
397     void preparePaginationBeforeBlockLayout(bool&);
398
399 private:
400     static std::unique_ptr<RenderBlock> createAnonymousBlockWithStyleAndDisplay(Document&, const RenderStyle&, EDisplay);
401
402     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
403     virtual LayoutUnit logicalRightFloatOffsetForLine(LayoutUnit, LayoutUnit fixedOffset, LayoutUnit) const { return fixedOffset; };
404     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
405     virtual LayoutUnit logicalLeftFloatOffsetForLine(LayoutUnit, LayoutUnit fixedOffset, LayoutUnit) const { return fixedOffset; }
406     LayoutUnit adjustLogicalRightOffsetForLine(LayoutUnit offsetFromFloats, bool applyTextIndent) const;
407     LayoutUnit adjustLogicalLeftOffsetForLine(LayoutUnit offsetFromFloats, bool applyTextIndent) const;
408
409     const char* renderName() const override;
410
411     bool isInlineBlockOrInlineTable() const final { return isInline() && isReplaced(); }
412
413     void makeChildrenNonInline(RenderObject* insertionPoint = nullptr);
414     virtual void removeLeftoverAnonymousBlock(RenderBlock* child);
415
416     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
417     virtual void moveAllChildrenIncludingFloatsTo(RenderBlock& toBlock, bool fullRemoveInsert) { moveAllChildrenTo(&toBlock, fullRemoveInsert); }
418
419     void addChildToContinuation(RenderObject* newChild, RenderObject* beforeChild);
420     void addChildIgnoringContinuation(RenderObject* newChild, RenderObject* beforeChild) override;
421
422     bool isSelfCollapsingBlock() const override;
423     virtual bool childrenPreventSelfCollapsing() const;
424     
425     void createFirstLetterRenderer(RenderElement* firstLetterBlock, RenderText* currentTextChild);
426     void updateFirstLetterStyle(RenderElement* firstLetterBlock, RenderObject* firstLetterContainer);
427
428     Node* nodeForHitTest() const;
429
430     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
431     virtual void paintFloats(PaintInfo&, const LayoutPoint&, bool) { }
432     virtual void paintInlineChildren(PaintInfo&, const LayoutPoint&) { }
433     void paintContents(PaintInfo&, const LayoutPoint&);
434     virtual void paintColumnRules(PaintInfo&, const LayoutPoint&) { };
435     void paintSelection(PaintInfo&, const LayoutPoint&);
436     void paintCaret(PaintInfo&, const LayoutPoint&, CaretType);
437
438     bool avoidsFloats() const override;
439
440     virtual bool hitTestContents(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction);
441     // FIXME-BLOCKFLOW: Remove virtualization when all callers have moved to RenderBlockFlow
442     virtual bool hitTestFloats(const HitTestRequest&, HitTestResult&, const HitTestLocation&, const LayoutPoint&) { return false; }
443     virtual bool hitTestInlineChildren(const HitTestRequest&, HitTestResult&, const HitTestLocation&, const LayoutPoint&, HitTestAction) { return false; }
444
445     virtual bool isPointInOverflowControl(HitTestResult&, const LayoutPoint& locationInContainer, const LayoutPoint& accumulatedOffset);
446
447     void computeBlockPreferredLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const;
448
449     LayoutRect rectWithOutlineForRepaint(const RenderLayerModelObject* repaintContainer, LayoutUnit outlineWidth) const final;
450     const RenderStyle& outlineStyleForRepaint() const final;
451
452     RenderElement* hoverAncestor() const final;
453     void updateDragState(bool dragOn) final;
454     void childBecameNonInline(RenderElement&) final;
455
456     LayoutRect selectionRectForRepaint(const RenderLayerModelObject* repaintContainer, bool /*clipToVisibleContent*/) final
457     {
458         return selectionGapRectsForRepaint(repaintContainer);
459     }
460     bool shouldPaintSelectionGaps() const final;
461     bool isSelectionRoot() const;
462     GapRects selectionGaps(RenderBlock& rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
463         LayoutUnit& lastLogicalTop, LayoutUnit& lastLogicalLeft, LayoutUnit& lastLogicalRight, const LogicalSelectionOffsetCaches&, const PaintInfo* = 0);
464     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
465     virtual GapRects inlineSelectionGaps(RenderBlock& rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
466         LayoutUnit& lastLogicalTop, LayoutUnit& lastLogicalLeft, LayoutUnit& lastLogicalRight, const LogicalSelectionOffsetCaches&, const PaintInfo*);
467     GapRects blockSelectionGaps(RenderBlock& rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
468         LayoutUnit& lastLogicalTop, LayoutUnit& lastLogicalLeft, LayoutUnit& lastLogicalRight, const LogicalSelectionOffsetCaches&, const PaintInfo*);
469     LayoutRect blockSelectionGap(RenderBlock& rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
470         LayoutUnit lastLogicalTop, LayoutUnit lastLogicalLeft, LayoutUnit lastLogicalRight, LayoutUnit logicalBottom, const LogicalSelectionOffsetCaches&, const PaintInfo*);
471
472     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
473     virtual void clipOutFloatingObjects(RenderBlock&, const PaintInfo*, const LayoutPoint&, const LayoutSize&) { };
474     friend class LogicalSelectionOffsetCaches;
475
476     void absoluteRects(Vector<IntRect>&, const LayoutPoint& accumulatedOffset) const override;
477     void absoluteQuads(Vector<FloatQuad>&, bool* wasFixed) const override;
478
479     void paintContinuationOutlines(PaintInfo&, const LayoutPoint&);
480
481     LayoutRect localCaretRect(InlineBox*, unsigned caretOffset, LayoutUnit* extraWidthToEndOfLine = 0) final;
482     
483     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
484     virtual VisiblePosition positionForPointWithInlineChildren(const LayoutPoint&, const RenderRegion*);
485
486     RenderPtr<RenderBlock> clone() const;
487     RenderBlock* continuationBefore(RenderObject* beforeChild);
488
489     RenderFlowThread* updateCachedFlowThreadContainingBlock(RenderFlowThread*) const;
490
491     void removePositionedObjectsIfNeeded(const RenderStyle& oldStyle, const RenderStyle& newStyle);
492
493 private:
494     bool hasRareData() const;
495     
496 protected:
497     void dirtyForLayoutFromPercentageHeightDescendants();
498
499 protected:
500     bool recomputeLogicalWidth();
501     
502 public:
503     LayoutUnit offsetFromLogicalTopOfFirstPage() const override;
504     RenderRegion* regionAtBlockOffset(LayoutUnit) const;
505
506     // 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
507     // RenderBlock yet.
508     friend class RenderBlockFlow;
509     // FIXME-BLOCKFLOW: Remove this when the line layout stuff has all moved out of RenderBlock
510     friend class LineBreaker;
511
512     // RenderRubyBase objects need to be able to split and merge, moving their children around
513     // (calling moveChildTo, moveAllChildrenTo, and makeChildrenNonInline).
514     friend class RenderRubyBase;
515
516 private:
517     // Used to store state between styleWillChange and styleDidChange
518     static bool s_canPropagateFloatIntoSibling;
519 };
520
521 LayoutUnit blockDirectionOffset(RenderBlock& rootBlock, const LayoutSize& offsetFromRootBlock);
522 LayoutUnit inlineDirectionOffset(RenderBlock& rootBlock, const LayoutSize& offsetFromRootBlock);
523 VisiblePosition positionForPointRespectingEditingBoundaries(RenderBlock&, RenderBox&, const LayoutPoint&);
524
525 inline std::unique_ptr<RenderBlock> RenderBlock::createAnonymousWithParentRendererAndDisplay(const RenderBox& parent, EDisplay display)
526 {
527     return createAnonymousBlockWithStyleAndDisplay(parent.document(), parent.style(), display);
528 }
529
530 inline std::unique_ptr<RenderBox> RenderBlock::createAnonymousBoxWithSameTypeAs(const RenderBox& renderer) const
531 {
532     return createAnonymousBlockWithStyleAndDisplay(document(), renderer.style(), style().display());
533 }
534
535 inline RenderBlock* RenderBlock::createAnonymousBlock(EDisplay display) const
536 {
537     return createAnonymousBlockWithStyleAndDisplay(document(), style(), display).release();
538 }
539
540 } // namespace WebCore
541
542 SPECIALIZE_TYPE_TRAITS_RENDER_OBJECT(RenderBlock, isRenderBlock())
543
544 #endif // RenderBlock_h