51922536823b720fa26f41bca2a26dbea49d91c5
[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 "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*, 16> TrackedRendererListHashSet;
44 typedef WTF::HashMap<const RenderBlock*, std::unique_ptr<TrackedRendererListHashSet>> TrackedDescendantsMap;
45 typedef WTF::HashMap<const RenderBox*, std::unique_ptr<HashSet<RenderBlock*>>> TrackedContainerMap;
46
47 enum CaretType { CursorCaret, DragCaret };
48 enum ContainingBlockState { NewContainingBlock, SameContainingBlock };
49
50 enum TextRunFlag {
51     DefaultTextRunFlags = 0,
52     RespectDirection = 1 << 0,
53     RespectDirectionOverride = 1 << 1
54 };
55
56 typedef unsigned TextRunFlags;
57
58 class RenderBlock : public RenderBox {
59 public:
60     friend class LineLayoutState;
61
62 protected:
63     RenderBlock(Element&, PassRef<RenderStyle>, unsigned baseTypeFlags);
64     RenderBlock(Document&, PassRef<RenderStyle>, unsigned baseTypeFlags);
65     virtual ~RenderBlock();
66
67 public:
68     // These two functions are overridden for inline-block.
69     virtual LayoutUnit lineHeight(bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const override final;
70     virtual int baselinePosition(FontBaseline, bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const override;
71
72     LayoutUnit minLineHeightForReplacedRenderer(bool isFirstLine, LayoutUnit replacedHeight) const;
73
74     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
75     virtual void deleteLines();
76
77     virtual void addChild(RenderObject* newChild, RenderObject* beforeChild = 0) override;
78     virtual RenderObject* removeChild(RenderObject&) override;
79
80     virtual void layoutBlock(bool relayoutChildren, LayoutUnit pageLogicalHeight = 0);
81
82     virtual void invalidateLineLayoutPath() { }
83
84     void insertPositionedObject(RenderBox&);
85     static void removePositionedObject(RenderBox&);
86     void removePositionedObjects(RenderBlock*, ContainingBlockState = SameContainingBlock);
87
88     TrackedRendererListHashSet* positionedObjects() const;
89     bool hasPositionedObjects() const
90     {
91         TrackedRendererListHashSet* objects = positionedObjects();
92         return objects && !objects->isEmpty();
93     }
94
95     void addPercentHeightDescendant(RenderBox&);
96     static void removePercentHeightDescendant(RenderBox&);
97     TrackedRendererListHashSet* percentHeightDescendants() const;
98     static bool hasPercentHeightContainerMap();
99     static bool hasPercentHeightDescendant(RenderBox&);
100     static void clearPercentHeightDescendantsFrom(RenderBox&);
101     static void removePercentHeightDescendantIfNeeded(RenderBox&);
102
103     void setHasMarginBeforeQuirk(bool b) { m_hasMarginBeforeQuirk = b; }
104     void setHasMarginAfterQuirk(bool b) { m_hasMarginAfterQuirk = b; }
105
106     bool hasMarginBeforeQuirk() const { return m_hasMarginBeforeQuirk; }
107     bool hasMarginAfterQuirk() const { return m_hasMarginAfterQuirk; }
108
109     bool hasMarginBeforeQuirk(const RenderBox& child) const;
110     bool hasMarginAfterQuirk(const RenderBox& child) const;
111
112     bool generatesLineBoxesForInlineChild(RenderObject*);
113
114     void markPositionedObjectsForLayout();
115     virtual void markForPaginationRelayoutIfNeeded() override final;
116     
117     // FIXME-BLOCKFLOW: Remove virtualizaion when all of the line layout code has been moved out of RenderBlock
118     virtual bool containsFloats() const { return false; }
119
120     // Versions that can compute line offsets with the region and page offset passed in. Used for speed to avoid having to
121     // compute the region all over again when you already know it.
122     LayoutUnit availableLogicalWidthForLineInRegion(LayoutUnit position, bool shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const
123     {
124         return std::max<LayoutUnit>(0, logicalRightOffsetForLineInRegion(position, shouldIndentText, region, logicalHeight)
125             - logicalLeftOffsetForLineInRegion(position, shouldIndentText, region, logicalHeight));
126     }
127     LayoutUnit logicalRightOffsetForLineInRegion(LayoutUnit position, bool shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const 
128     {
129         return logicalRightOffsetForLine(position, logicalRightOffsetForContent(region), shouldIndentText, logicalHeight);
130     }
131     LayoutUnit logicalLeftOffsetForLineInRegion(LayoutUnit position, bool shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const 
132     {
133         return logicalLeftOffsetForLine(position, logicalLeftOffsetForContent(region), shouldIndentText, logicalHeight);
134     }
135     LayoutUnit startOffsetForLineInRegion(LayoutUnit position, bool shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const
136     {
137         return style().isLeftToRightDirection() ? logicalLeftOffsetForLineInRegion(position, shouldIndentText, region, logicalHeight)
138             : logicalWidth() - logicalRightOffsetForLineInRegion(position, shouldIndentText, region, logicalHeight);
139     }
140     LayoutUnit endOffsetForLineInRegion(LayoutUnit position, bool shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const
141     {
142         return !style().isLeftToRightDirection() ? logicalLeftOffsetForLineInRegion(position, shouldIndentText, region, logicalHeight)
143             : logicalWidth() - logicalRightOffsetForLineInRegion(position, shouldIndentText, region, logicalHeight);
144     }
145
146     LayoutUnit availableLogicalWidthForLine(LayoutUnit position, bool shouldIndentText, LayoutUnit logicalHeight = 0) const
147     {
148         return availableLogicalWidthForLineInRegion(position, shouldIndentText, regionAtBlockOffset(position), logicalHeight);
149     }
150     LayoutUnit logicalRightOffsetForLine(LayoutUnit position, bool shouldIndentText, LayoutUnit logicalHeight = 0) const 
151     {
152         return logicalRightOffsetForLine(position, logicalRightOffsetForContent(position), shouldIndentText, logicalHeight);
153     }
154     LayoutUnit logicalLeftOffsetForLine(LayoutUnit position, bool shouldIndentText, LayoutUnit logicalHeight = 0) const 
155     {
156         return logicalLeftOffsetForLine(position, logicalLeftOffsetForContent(position), shouldIndentText, logicalHeight);
157     }
158     LayoutUnit startOffsetForLine(LayoutUnit position, bool shouldIndentText, LayoutUnit logicalHeight = 0) const
159     {
160         return style().isLeftToRightDirection() ? logicalLeftOffsetForLine(position, shouldIndentText, logicalHeight)
161             : logicalWidth() - logicalRightOffsetForLine(position, shouldIndentText, logicalHeight);
162     }
163     LayoutUnit endOffsetForLine(LayoutUnit position, bool shouldIndentText, LayoutUnit logicalHeight = 0) const
164     {
165         return !style().isLeftToRightDirection() ? logicalLeftOffsetForLine(position, shouldIndentText, logicalHeight)
166             : logicalWidth() - logicalRightOffsetForLine(position, shouldIndentText, logicalHeight);
167     }
168
169     LayoutUnit textIndentOffset() const;
170
171     virtual VisiblePosition positionForPoint(const LayoutPoint&, const RenderRegion*) override;
172
173     GapRects selectionGapRectsForRepaint(const RenderLayerModelObject* repaintContainer);
174     LayoutRect logicalLeftSelectionGap(RenderBlock& rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
175         RenderObject* selObj, LayoutUnit logicalLeft, LayoutUnit logicalTop, LayoutUnit logicalHeight, const LogicalSelectionOffsetCaches&, const PaintInfo*);
176     LayoutRect logicalRightSelectionGap(RenderBlock& rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
177         RenderObject* selObj, LayoutUnit logicalRight, LayoutUnit logicalTop, LayoutUnit logicalHeight, const LogicalSelectionOffsetCaches&, const PaintInfo*);
178     void getSelectionGapInfo(SelectionState, bool& leftGap, bool& rightGap);
179     RenderBlock* blockBeforeWithinSelectionRoot(LayoutSize& offset) const;
180
181     LayoutRect logicalRectToPhysicalRect(const LayoutPoint& physicalPosition, const LayoutRect& logicalRect);
182
183     void addContinuationWithOutline(RenderInline*);
184     bool paintsContinuationOutline(RenderInline*);
185
186     virtual RenderBoxModelObject* virtualContinuation() const override final { return continuation(); }
187     bool isAnonymousBlockContinuation() const { return isAnonymousBlock() && continuation(); }
188     WEBCORE_EXPORT RenderInline* inlineElementContinuation() const;
189     RenderBlock* blockElementContinuation() const;
190
191     using RenderBoxModelObject::continuation;
192     using RenderBoxModelObject::setContinuation;
193
194     static RenderBlock* createAnonymousWithParentRendererAndDisplay(const RenderObject*, EDisplay = BLOCK);
195     RenderBlock* createAnonymousBlock(EDisplay display = BLOCK) const { return createAnonymousWithParentRendererAndDisplay(this, display); }
196     static void collapseAnonymousBoxChild(RenderBlock& parent, RenderBlock* child);
197
198     virtual RenderBox* createAnonymousBoxWithSameTypeAs(const RenderObject* parent) const override;
199
200     static bool shouldSkipCreatingRunsForObject(RenderObject* obj)
201     {
202         return obj->isFloating() || (obj->isOutOfFlowPositioned() && !obj->style().isOriginalDisplayInlineType() && !obj->container()->isRenderInline());
203     }
204
205     static TextRun constructTextRun(RenderObject* context, const Font&, const String&, const RenderStyle&,
206         TextRun::ExpansionBehavior = TextRun::AllowTrailingExpansion | TextRun::ForbidLeadingExpansion, TextRunFlags = DefaultTextRunFlags);
207
208     static TextRun constructTextRun(RenderObject* context, const Font&, const RenderText*, const RenderStyle&,
209         TextRun::ExpansionBehavior = TextRun::AllowTrailingExpansion | TextRun::ForbidLeadingExpansion);
210
211     static TextRun constructTextRun(RenderObject* context, const Font&, const RenderText*, unsigned offset, unsigned length, const RenderStyle&,
212         TextRun::ExpansionBehavior = TextRun::AllowTrailingExpansion | TextRun::ForbidLeadingExpansion);
213
214     static TextRun constructTextRun(RenderObject* context, const Font&, const RenderText*, unsigned offset, const RenderStyle&,
215         TextRun::ExpansionBehavior = TextRun::AllowTrailingExpansion | TextRun::ForbidLeadingExpansion);
216
217     static TextRun constructTextRun(RenderObject* context, const Font&, const LChar* characters, int length, const RenderStyle&,
218         TextRun::ExpansionBehavior = TextRun::AllowTrailingExpansion | TextRun::ForbidLeadingExpansion);
219
220     static TextRun constructTextRun(RenderObject* context, const Font&, const UChar* characters, int length, const RenderStyle&,
221         TextRun::ExpansionBehavior = TextRun::AllowTrailingExpansion | TextRun::ForbidLeadingExpansion);
222     
223     LayoutUnit paginationStrut() const;
224     void setPaginationStrut(LayoutUnit);
225
226     // The page logical offset is the object's offset from the top of the page in the page progression
227     // direction (so an x-offset in vertical text and a y-offset for horizontal text).
228     LayoutUnit pageLogicalOffset() const;
229     void setPageLogicalOffset(LayoutUnit);
230
231     // Accessors for logical width/height and margins in the containing block's block-flow direction.
232     enum ApplyLayoutDeltaMode { ApplyLayoutDelta, DoNotApplyLayoutDelta };
233     LayoutUnit logicalWidthForChild(const RenderBox& child) const { return isHorizontalWritingMode() ? child.width() : child.height(); }
234     LayoutUnit logicalHeightForChild(const RenderBox& child) const { return isHorizontalWritingMode() ? child.height() : child.width(); }
235     LayoutSize logicalSizeForChild(const RenderBox& child) const { return isHorizontalWritingMode() ? child.size() : child.size().transposedSize(); }
236     LayoutUnit logicalTopForChild(const RenderBox& child) const { return isHorizontalWritingMode() ? child.y() : child.x(); }
237     void setLogicalLeftForChild(RenderBox& child, LayoutUnit logicalLeft, ApplyLayoutDeltaMode = DoNotApplyLayoutDelta);
238     void setLogicalTopForChild(RenderBox& child, LayoutUnit logicalTop, ApplyLayoutDeltaMode = DoNotApplyLayoutDelta);
239     LayoutUnit marginBeforeForChild(const RenderBoxModelObject& child) const { return child.marginBefore(&style()); }
240     LayoutUnit marginAfterForChild(const RenderBoxModelObject& child) const { return child.marginAfter(&style()); }
241     LayoutUnit marginStartForChild(const RenderBoxModelObject& child) const { return child.marginStart(&style()); }
242     LayoutUnit marginEndForChild(const RenderBoxModelObject& child) const { return child.marginEnd(&style()); }
243     void setMarginStartForChild(RenderBox& child, LayoutUnit value) const { child.setMarginStart(value, &style()); }
244     void setMarginEndForChild(RenderBox& child, LayoutUnit value) const { child.setMarginEnd(value, &style()); }
245     void setMarginBeforeForChild(RenderBox& child, LayoutUnit value) const { child.setMarginBefore(value, &style()); }
246     void setMarginAfterForChild(RenderBox& child, LayoutUnit value) const { child.setMarginAfter(value, &style()); }
247     LayoutUnit collapsedMarginBeforeForChild(const RenderBox& child) const;
248     LayoutUnit collapsedMarginAfterForChild(const RenderBox& child) const;
249
250     virtual void updateFirstLetter();
251     void getFirstLetter(RenderObject*& firstLetter, RenderElement*& firstLetterContainer, RenderObject* skipObject = nullptr);
252
253     virtual void scrollbarsChanged(bool /*horizontalScrollbarChanged*/, bool /*verticalScrollbarChanged*/) { }
254
255     LayoutUnit logicalLeftOffsetForContent(RenderRegion*) const;
256     LayoutUnit logicalRightOffsetForContent(RenderRegion*) const;
257     LayoutUnit availableLogicalWidthForContent(RenderRegion* region) const
258     { 
259         return std::max<LayoutUnit>(0, logicalRightOffsetForContent(region) - logicalLeftOffsetForContent(region));
260     }
261     LayoutUnit startOffsetForContent(RenderRegion* region) const
262     {
263         return style().isLeftToRightDirection() ? logicalLeftOffsetForContent(region) : logicalWidth() - logicalRightOffsetForContent(region);
264     }
265     LayoutUnit endOffsetForContent(RenderRegion* region) const
266     {
267         return !style().isLeftToRightDirection() ? logicalLeftOffsetForContent(region) : logicalWidth() - logicalRightOffsetForContent(region);
268     }
269     LayoutUnit logicalLeftOffsetForContent(LayoutUnit blockOffset) const
270     {
271         return logicalLeftOffsetForContent(regionAtBlockOffset(blockOffset));
272     }
273     LayoutUnit logicalRightOffsetForContent(LayoutUnit blockOffset) const
274     {
275         return logicalRightOffsetForContent(regionAtBlockOffset(blockOffset));
276     }
277     LayoutUnit availableLogicalWidthForContent(LayoutUnit blockOffset) const
278     {
279         return availableLogicalWidthForContent(regionAtBlockOffset(blockOffset));
280     }
281     LayoutUnit startOffsetForContent(LayoutUnit blockOffset) const
282     {
283         return startOffsetForContent(regionAtBlockOffset(blockOffset));
284     }
285     LayoutUnit endOffsetForContent(LayoutUnit blockOffset) const
286     {
287         return endOffsetForContent(regionAtBlockOffset(blockOffset));
288     }
289     LayoutUnit logicalLeftOffsetForContent() const { return isHorizontalWritingMode() ? borderLeft() + paddingLeft() : borderTop() + paddingTop(); }
290     LayoutUnit logicalRightOffsetForContent() const { return logicalLeftOffsetForContent() + availableLogicalWidth(); }
291     LayoutUnit startOffsetForContent() const { return style().isLeftToRightDirection() ? logicalLeftOffsetForContent() : logicalWidth() - logicalRightOffsetForContent(); }
292     LayoutUnit endOffsetForContent() const { return !style().isLeftToRightDirection() ? logicalLeftOffsetForContent() : logicalWidth() - logicalRightOffsetForContent(); }
293
294     LayoutUnit logicalLeftSelectionOffset(RenderBlock& rootBlock, LayoutUnit position, const LogicalSelectionOffsetCaches&);
295     LayoutUnit logicalRightSelectionOffset(RenderBlock& rootBlock, LayoutUnit position, const LogicalSelectionOffsetCaches&);
296
297     LayoutUnit computeStartPositionDeltaForChildAvoidingFloats(const RenderBox& child, LayoutUnit childMarginStart, RenderRegion* = 0);
298
299 #ifndef NDEBUG
300     void checkPositionedObjectsNeedLayout();
301 #endif
302
303
304 #if ENABLE(CSS_SHAPES)
305     virtual void imageChanged(WrappedImagePtr, const IntRect* = 0) override;
306 #endif
307
308     virtual void updateHitTestResult(HitTestResult&, const LayoutPoint&) override;
309
310     virtual bool canHaveChildren() const override { return true; }
311     virtual bool canCollapseAnonymousBlockChild() const { return true; }
312
313     RenderFlowThread* cachedFlowThreadContainingBlock() const;
314     void setCachedFlowThreadContainingBlockNeedsUpdate();
315     virtual bool cachedFlowThreadContainingBlockNeedsUpdate() const;
316
317 protected:
318     virtual RenderFlowThread* locateFlowThreadContainingBlock() const override;
319     virtual void willBeDestroyed() override;
320
321     virtual void layout() override;
322
323     void layoutPositionedObjects(bool relayoutChildren, bool fixedPositionObjectsOnly = false);
324     void markFixedPositionObjectForLayoutIfNeeded(RenderObject& child);
325
326     LayoutUnit marginIntrinsicLogicalWidthForChild(RenderBox&) const;
327
328     virtual void paint(PaintInfo&, const LayoutPoint&) override;
329     virtual void paintObject(PaintInfo&, const LayoutPoint&) override;
330     virtual void paintChildren(PaintInfo& forSelf, const LayoutPoint&, PaintInfo& forChild, bool usePrintRect);
331     bool paintChild(RenderBox&, PaintInfo& forSelf, const LayoutPoint&, PaintInfo& forChild, bool usePrintRect);
332    
333     LayoutUnit logicalRightOffsetForLine(LayoutUnit logicalTop, LayoutUnit fixedOffset, bool applyTextIndent, LayoutUnit logicalHeight = 0) const
334     {
335         return adjustLogicalRightOffsetForLine(logicalRightFloatOffsetForLine(logicalTop, fixedOffset, logicalHeight), applyTextIndent);
336     }
337     LayoutUnit logicalLeftOffsetForLine(LayoutUnit logicalTop, LayoutUnit fixedOffset, bool applyTextIndent, LayoutUnit logicalHeight = 0) const
338     {
339         return adjustLogicalLeftOffsetForLine(logicalLeftFloatOffsetForLine(logicalTop, fixedOffset, logicalHeight), applyTextIndent);
340     }
341
342     virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) override;
343
344     virtual void computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const override;
345     virtual void computePreferredLogicalWidths() override;
346     
347     virtual int firstLineBaseline() const override;
348     virtual int inlineBlockBaseline(LineDirectionMode) const override;
349
350     // Delay updating scrollbars until endAndCommitUpdateScrollInfoAfterLayoutTransaction() is called. These functions are used
351     // when a flexbox is laying out its descendants. If multiple calls are made to beginUpdateScrollInfoAfterLayoutTransaction()
352     // then endAndCommitUpdateScrollInfoAfterLayoutTransaction() will do nothing until it is called the same number of times.
353     void beginUpdateScrollInfoAfterLayoutTransaction();
354     void endAndCommitUpdateScrollInfoAfterLayoutTransaction();
355
356     void removeFromUpdateScrollInfoAfterLayoutTransaction();
357
358     void updateScrollInfoAfterLayout();
359
360     virtual void styleWillChange(StyleDifference, const RenderStyle& newStyle) override;
361     virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle) override;
362
363     virtual bool hasLineIfEmpty() const;
364     
365     bool simplifiedLayout();
366     virtual void simplifiedNormalFlowLayout();
367
368     bool childBoxIsUnsplittableForFragmentation(const RenderBox& child) const;
369
370 public:
371     virtual void computeOverflow(LayoutUnit oldClientAfterEdge, bool recomputeFloats = false);
372     void clearLayoutOverflow();
373     
374     // Adjust from painting offsets to the local coords of this renderer
375     void offsetForContents(LayoutPoint&) const;
376
377 protected:
378     virtual void addOverflowFromChildren();
379     // FIXME-BLOCKFLOW: Remove virtualization when all callers have moved to RenderBlockFlow
380     virtual void addOverflowFromInlineChildren() { }
381     void addOverflowFromBlockChildren();
382     void addOverflowFromPositionedObjects();
383     void addVisualOverflowFromTheme();
384
385     virtual void addFocusRingRects(Vector<IntRect>&, const LayoutPoint& additionalOffset, const RenderLayerModelObject* paintContainer = 0) override;
386     virtual void addFocusRingRectsForInlineChildren(Vector<IntRect>&, const LayoutPoint& additionalOffset, const RenderLayerModelObject* paintContainer);
387
388     void computeRegionRangeForBoxChild(const RenderBox&) const;
389
390     void estimateRegionRangeForBoxChild(const RenderBox&) const;
391     bool updateRegionRangeForBoxChild(const RenderBox&) const;
392
393     void updateBlockChildDirtyBitsBeforeLayout(bool relayoutChildren, RenderBox&);
394
395     void preparePaginationBeforeBlockLayout(bool&);
396
397 private:
398     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
399     virtual LayoutUnit logicalRightFloatOffsetForLine(LayoutUnit, LayoutUnit fixedOffset, LayoutUnit) const { return fixedOffset; };
400     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
401     virtual LayoutUnit logicalLeftFloatOffsetForLine(LayoutUnit, LayoutUnit fixedOffset, LayoutUnit) const { return fixedOffset; }
402     LayoutUnit adjustLogicalRightOffsetForLine(LayoutUnit offsetFromFloats, bool applyTextIndent) const;
403     LayoutUnit adjustLogicalLeftOffsetForLine(LayoutUnit offsetFromFloats, bool applyTextIndent) const;
404
405     virtual const char* renderName() const override;
406
407     virtual bool isInlineBlockOrInlineTable() const override final { return isInline() && isReplaced(); }
408
409     void makeChildrenNonInline(RenderObject* insertionPoint = nullptr);
410     virtual void removeLeftoverAnonymousBlock(RenderBlock* child);
411
412     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
413     virtual void moveAllChildrenIncludingFloatsTo(RenderBlock& toBlock, bool fullRemoveInsert) { moveAllChildrenTo(&toBlock, fullRemoveInsert); }
414
415     void addChildToContinuation(RenderObject* newChild, RenderObject* beforeChild);
416     virtual void addChildIgnoringContinuation(RenderObject* newChild, RenderObject* beforeChild) override;
417
418     virtual bool isSelfCollapsingBlock() const override final;
419     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
420     virtual bool hasLines() const { return false; }
421
422     void insertIntoTrackedRendererMaps(RenderBox& descendant, TrackedDescendantsMap*&, TrackedContainerMap*&);
423     static void removeFromTrackedRendererMaps(RenderBox& descendant, TrackedDescendantsMap*&, TrackedContainerMap*&);
424
425     void createFirstLetterRenderer(RenderObject* firstLetterBlock, RenderText* currentTextChild);
426     void updateFirstLetterStyle(RenderObject* 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     virtual 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     // Obtains the nearest enclosing block (including this block) that contributes a first-line style to our inline
450     // children.
451     virtual RenderBlock* firstLineBlock() const override;
452
453     virtual LayoutRect rectWithOutlineForRepaint(const RenderLayerModelObject* repaintContainer, LayoutUnit outlineWidth) const override final;
454     virtual const RenderStyle& outlineStyleForRepaint() const override final;
455
456     virtual RenderElement* hoverAncestor() const override final;
457     virtual void updateDragState(bool dragOn) override final;
458     virtual void childBecameNonInline(RenderElement&) override final;
459
460     virtual LayoutRect selectionRectForRepaint(const RenderLayerModelObject* repaintContainer, bool /*clipToVisibleContent*/) override final
461     {
462         return selectionGapRectsForRepaint(repaintContainer);
463     }
464     virtual bool shouldPaintSelectionGaps() const override final;
465     bool isSelectionRoot() const;
466     GapRects selectionGaps(RenderBlock& rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
467         LayoutUnit& lastLogicalTop, LayoutUnit& lastLogicalLeft, LayoutUnit& lastLogicalRight, const LogicalSelectionOffsetCaches&, const PaintInfo* = 0);
468     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
469     virtual GapRects inlineSelectionGaps(RenderBlock& rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
470         LayoutUnit& lastLogicalTop, LayoutUnit& lastLogicalLeft, LayoutUnit& lastLogicalRight, const LogicalSelectionOffsetCaches&, const PaintInfo*);
471     GapRects blockSelectionGaps(RenderBlock& rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
472         LayoutUnit& lastLogicalTop, LayoutUnit& lastLogicalLeft, LayoutUnit& lastLogicalRight, const LogicalSelectionOffsetCaches&, const PaintInfo*);
473     LayoutRect blockSelectionGap(RenderBlock& rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
474         LayoutUnit lastLogicalTop, LayoutUnit lastLogicalLeft, LayoutUnit lastLogicalRight, LayoutUnit logicalBottom, const LogicalSelectionOffsetCaches&, const PaintInfo*);
475
476     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
477     virtual void clipOutFloatingObjects(RenderBlock&, const PaintInfo*, const LayoutPoint&, const LayoutSize&) { };
478     friend class LogicalSelectionOffsetCaches;
479
480     virtual void absoluteRects(Vector<IntRect>&, const LayoutPoint& accumulatedOffset) const override;
481     virtual void absoluteQuads(Vector<FloatQuad>&, bool* wasFixed) const override;
482
483     void paintContinuationOutlines(PaintInfo&, const LayoutPoint&);
484
485     virtual LayoutRect localCaretRect(InlineBox*, int caretOffset, LayoutUnit* extraWidthToEndOfLine = 0) override final;
486     
487     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
488     virtual VisiblePosition positionForPointWithInlineChildren(const LayoutPoint&, const RenderRegion*);
489
490     bool expandsToEncloseOverhangingFloats() const;
491
492     RenderPtr<RenderBlock> clone() const;
493     RenderBlock* continuationBefore(RenderObject* beforeChild);
494
495     RenderFlowThread* updateCachedFlowThreadContainingBlock(RenderFlowThread*) const;
496
497 private:
498     bool hasRareData() const;
499     
500 protected:
501     void dirtyForLayoutFromPercentageHeightDescendants();
502
503 protected:
504     bool recomputeLogicalWidth();
505     
506 public:
507     virtual LayoutUnit offsetFromLogicalTopOfFirstPage() const override;
508     RenderRegion* regionAtBlockOffset(LayoutUnit) const;
509
510     // 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
511     // RenderBlock yet.
512     friend class RenderBlockFlow;
513     // FIXME-BLOCKFLOW: Remove this when the line layout stuff has all moved out of RenderBlock
514     friend class LineBreaker;
515
516     mutable signed m_lineHeight : 25;
517     unsigned m_hasMarginBeforeQuirk : 1; // Note these quirk values can't be put in RenderBlockRareData since they are set too frequently.
518     unsigned m_hasMarginAfterQuirk : 1;
519     unsigned m_hasMarkupTruncation : 1;
520     unsigned m_hasBorderOrPaddingLogicalWidthChanged : 1;
521     enum LineLayoutPath { UndeterminedPath, SimpleLinesPath, LineBoxesPath, ForceLineBoxesPath };
522     unsigned m_lineLayoutPath : 2;
523     
524     // RenderRubyBase objects need to be able to split and merge, moving their children around
525     // (calling moveChildTo, moveAllChildrenTo, and makeChildrenNonInline).
526     friend class RenderRubyBase;
527
528 private:
529     // Used to store state between styleWillChange and styleDidChange
530     static bool s_canPropagateFloatIntoSibling;
531 };
532
533 LayoutUnit blockDirectionOffset(RenderBlock& rootBlock, const LayoutSize& offsetFromRootBlock);
534 LayoutUnit inlineDirectionOffset(RenderBlock& rootBlock, const LayoutSize& offsetFromRootBlock);
535 VisiblePosition positionForPointRespectingEditingBoundaries(RenderBlock&, RenderBox&, const LayoutPoint&);
536
537 } // namespace WebCore
538
539 SPECIALIZE_TYPE_TRAITS_RENDER_OBJECT(RenderBlock, isRenderBlock())
540
541 #endif // RenderBlock_h