2baf9965e7701bb3675686017c1aa95fc92ca342
[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 "ColumnInfo.h"
27 #include "GapRects.h"
28 #include "RenderBox.h"
29 #include "TextRun.h"
30 #include <wtf/OwnPtr.h>
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*, 16> TrackedRendererListHashSet;
45 typedef WTF::HashMap<const RenderBlock*, OwnPtr<TrackedRendererListHashSet>> TrackedDescendantsMap;
46 typedef WTF::HashMap<const RenderBox*, OwnPtr<HashSet<RenderBlock*>>> TrackedContainerMap;
47
48 enum CaretType { CursorCaret, DragCaret };
49 enum ContainingBlockState { NewContainingBlock, SameContainingBlock };
50
51 enum TextRunFlag {
52     DefaultTextRunFlags = 0,
53     RespectDirection = 1 << 0,
54     RespectDirectionOverride = 1 << 1
55 };
56
57 typedef unsigned TextRunFlags;
58
59 class RenderBlock : public RenderBox {
60 public:
61     friend class LineLayoutState;
62
63 protected:
64     RenderBlock(Element&, PassRef<RenderStyle>, unsigned baseTypeFlags);
65     RenderBlock(Document&, PassRef<RenderStyle>, unsigned baseTypeFlags);
66     virtual ~RenderBlock();
67
68 public:
69     bool beingDestroyed() const { return m_beingDestroyed; }
70
71     // These two functions are overridden for inline-block.
72     virtual LayoutUnit lineHeight(bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const override final;
73     virtual int baselinePosition(FontBaseline, bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const override;
74
75     LayoutUnit minLineHeightForReplacedRenderer(bool isFirstLine, LayoutUnit replacedHeight) const;
76
77     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
78     virtual void deleteLines();
79
80     virtual void addChild(RenderObject* newChild, RenderObject* beforeChild = 0) override;
81     virtual void removeChild(RenderObject&) override;
82
83     virtual void layoutBlock(bool relayoutChildren, LayoutUnit pageLogicalHeight = 0);
84
85     void invalidateLineLayoutPath();
86
87     void insertPositionedObject(RenderBox&);
88     static void removePositionedObject(RenderBox&);
89     void removePositionedObjects(RenderBlock*, ContainingBlockState = SameContainingBlock);
90
91     TrackedRendererListHashSet* positionedObjects() const;
92     bool hasPositionedObjects() const
93     {
94         TrackedRendererListHashSet* objects = positionedObjects();
95         return objects && !objects->isEmpty();
96     }
97
98     void addPercentHeightDescendant(RenderBox&);
99     static void removePercentHeightDescendant(RenderBox&);
100     TrackedRendererListHashSet* percentHeightDescendants() const;
101     static bool hasPercentHeightContainerMap();
102     static bool hasPercentHeightDescendant(RenderBox&);
103     static void clearPercentHeightDescendantsFrom(RenderBox&);
104     static void removePercentHeightDescendantIfNeeded(RenderBox&);
105
106     void setHasMarginBeforeQuirk(bool b) { m_hasMarginBeforeQuirk = b; }
107     void setHasMarginAfterQuirk(bool b) { m_hasMarginAfterQuirk = b; }
108
109     bool hasMarginBeforeQuirk() const { return m_hasMarginBeforeQuirk; }
110     bool hasMarginAfterQuirk() const { return m_hasMarginAfterQuirk; }
111
112     bool hasMarginBeforeQuirk(const RenderBox& child) const;
113     bool hasMarginAfterQuirk(const RenderBox& child) const;
114
115     bool generatesLineBoxesForInlineChild(RenderObject*);
116
117     void markPositionedObjectsForLayout();
118     virtual void markForPaginationRelayoutIfNeeded() override final;
119     
120     // FIXME-BLOCKFLOW: Remove virtualizaion when all of the line layout code has been moved out of RenderBlock
121     virtual bool containsFloats() const { return false; }
122
123     // Versions that can compute line offsets with the region and page offset passed in. Used for speed to avoid having to
124     // compute the region all over again when you already know it.
125     LayoutUnit availableLogicalWidthForLineInRegion(LayoutUnit position, bool shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const
126     {
127         return std::max<LayoutUnit>(0, logicalRightOffsetForLineInRegion(position, shouldIndentText, region, logicalHeight)
128             - logicalLeftOffsetForLineInRegion(position, shouldIndentText, region, logicalHeight));
129     }
130     LayoutUnit logicalRightOffsetForLineInRegion(LayoutUnit position, bool shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const 
131     {
132         return logicalRightOffsetForLine(position, logicalRightOffsetForContent(region), shouldIndentText, logicalHeight);
133     }
134     LayoutUnit logicalLeftOffsetForLineInRegion(LayoutUnit position, bool shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const 
135     {
136         return logicalLeftOffsetForLine(position, logicalLeftOffsetForContent(region), shouldIndentText, logicalHeight);
137     }
138     LayoutUnit startOffsetForLineInRegion(LayoutUnit position, bool shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const
139     {
140         return style().isLeftToRightDirection() ? logicalLeftOffsetForLineInRegion(position, shouldIndentText, region, logicalHeight)
141             : logicalWidth() - logicalRightOffsetForLineInRegion(position, shouldIndentText, region, logicalHeight);
142     }
143     LayoutUnit endOffsetForLineInRegion(LayoutUnit position, bool shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const
144     {
145         return !style().isLeftToRightDirection() ? logicalLeftOffsetForLineInRegion(position, shouldIndentText, region, logicalHeight)
146             : logicalWidth() - logicalRightOffsetForLineInRegion(position, shouldIndentText, region, logicalHeight);
147     }
148
149     LayoutUnit availableLogicalWidthForLine(LayoutUnit position, bool shouldIndentText, LayoutUnit logicalHeight = 0) const
150     {
151         return availableLogicalWidthForLineInRegion(position, shouldIndentText, regionAtBlockOffset(position), logicalHeight);
152     }
153     LayoutUnit logicalRightOffsetForLine(LayoutUnit position, bool shouldIndentText, LayoutUnit logicalHeight = 0) const 
154     {
155         return logicalRightOffsetForLine(position, logicalRightOffsetForContent(position), shouldIndentText, logicalHeight);
156     }
157     LayoutUnit logicalLeftOffsetForLine(LayoutUnit position, bool shouldIndentText, LayoutUnit logicalHeight = 0) const 
158     {
159         return logicalLeftOffsetForLine(position, logicalLeftOffsetForContent(position), shouldIndentText, logicalHeight);
160     }
161     LayoutUnit pixelSnappedLogicalLeftOffsetForLine(LayoutUnit position, bool shouldIndentText, LayoutUnit logicalHeight = 0) const 
162     {
163         return roundToInt(logicalLeftOffsetForLine(position, shouldIndentText, logicalHeight));
164     }
165     LayoutUnit pixelSnappedLogicalRightOffsetForLine(LayoutUnit position, bool shouldIndentText, LayoutUnit logicalHeight = 0) const 
166     {
167         // FIXME: Multicolumn layouts break carrying over subpixel values to the logical right offset because the lines may be shifted
168         // by a subpixel value for all but the first column. This can lead to the actual pixel snapped width of the column being off
169         // by one pixel when rendered versus layed out, which can result in the line being clipped. For now, we have to floor.
170         // https://bugs.webkit.org/show_bug.cgi?id=105461
171         return floorToInt(logicalRightOffsetForLine(position, shouldIndentText, logicalHeight));
172     }
173     LayoutUnit startOffsetForLine(LayoutUnit position, bool shouldIndentText, LayoutUnit logicalHeight = 0) const
174     {
175         return style().isLeftToRightDirection() ? logicalLeftOffsetForLine(position, shouldIndentText, logicalHeight)
176             : logicalWidth() - logicalRightOffsetForLine(position, shouldIndentText, logicalHeight);
177     }
178     LayoutUnit endOffsetForLine(LayoutUnit position, bool shouldIndentText, LayoutUnit logicalHeight = 0) const
179     {
180         return !style().isLeftToRightDirection() ? logicalLeftOffsetForLine(position, shouldIndentText, logicalHeight)
181             : logicalWidth() - logicalRightOffsetForLine(position, shouldIndentText, logicalHeight);
182     }
183
184     LayoutUnit textIndentOffset() const;
185
186     virtual VisiblePosition positionForPoint(const LayoutPoint&) override;
187     
188     // Block flows subclass availableWidth to handle multi column layout (shrinking the width available to children when laying out.)
189     virtual LayoutUnit availableLogicalWidth() const override final;
190
191     LayoutPoint flipForWritingModeIncludingColumns(const LayoutPoint&) const;
192     void adjustStartEdgeForWritingModeIncludingColumns(LayoutRect&) const;
193
194     GapRects selectionGapRectsForRepaint(const RenderLayerModelObject* repaintContainer);
195     LayoutRect logicalLeftSelectionGap(RenderBlock& rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
196         RenderObject* selObj, LayoutUnit logicalLeft, LayoutUnit logicalTop, LayoutUnit logicalHeight, const LogicalSelectionOffsetCaches&, const PaintInfo*);
197     LayoutRect logicalRightSelectionGap(RenderBlock& rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
198         RenderObject* selObj, LayoutUnit logicalRight, LayoutUnit logicalTop, LayoutUnit logicalHeight, const LogicalSelectionOffsetCaches&, const PaintInfo*);
199     void getSelectionGapInfo(SelectionState, bool& leftGap, bool& rightGap);
200     RenderBlock* blockBeforeWithinSelectionRoot(LayoutSize& offset) const;
201
202     LayoutRect logicalRectToPhysicalRect(const LayoutPoint& physicalPosition, const LayoutRect& logicalRect);
203
204     void adjustRectForColumns(LayoutRect&) const;
205     virtual void adjustForColumns(LayoutSize&, const LayoutPoint&) const override final;
206     void adjustForColumnRect(LayoutSize& offset, const LayoutPoint& locationInContainer) const;
207
208     void addContinuationWithOutline(RenderInline*);
209     bool paintsContinuationOutline(RenderInline*);
210
211     virtual RenderBoxModelObject* virtualContinuation() const override final { return continuation(); }
212     bool isAnonymousBlockContinuation() const { return isAnonymousBlock() && continuation(); }
213     RenderInline* inlineElementContinuation() const;
214     RenderBlock* blockElementContinuation() const;
215
216     using RenderBoxModelObject::continuation;
217     using RenderBoxModelObject::setContinuation;
218
219     static RenderBlock* createAnonymousWithParentRendererAndDisplay(const RenderObject*, EDisplay = BLOCK);
220     static RenderBlock* createAnonymousColumnsWithParentRenderer(const RenderObject*);
221     static RenderBlock* createAnonymousColumnSpanWithParentRenderer(const RenderObject*);
222     RenderBlock* createAnonymousBlock(EDisplay display = BLOCK) const { return createAnonymousWithParentRendererAndDisplay(this, display); }
223     RenderBlock* createAnonymousColumnsBlock() const { return createAnonymousColumnsWithParentRenderer(this); }
224     RenderBlock* createAnonymousColumnSpanBlock() const { return createAnonymousColumnSpanWithParentRenderer(this); }
225     static void collapseAnonymousBoxChild(RenderBlock* parent, RenderBlock* child);
226
227     virtual RenderBox* createAnonymousBoxWithSameTypeAs(const RenderObject* parent) const override;
228
229     static bool shouldSkipCreatingRunsForObject(RenderObject* obj)
230     {
231         return obj->isFloating() || (obj->isOutOfFlowPositioned() && !obj->style().isOriginalDisplayInlineType() && !obj->container()->isRenderInline());
232     }
233
234     static TextRun constructTextRun(RenderObject* context, const Font&, const String&, const RenderStyle&,
235         TextRun::ExpansionBehavior = TextRun::AllowTrailingExpansion | TextRun::ForbidLeadingExpansion, TextRunFlags = DefaultTextRunFlags);
236
237     static TextRun constructTextRun(RenderObject* context, const Font&, const RenderText*, const RenderStyle&,
238         TextRun::ExpansionBehavior = TextRun::AllowTrailingExpansion | TextRun::ForbidLeadingExpansion);
239
240     static TextRun constructTextRun(RenderObject* context, const Font&, const RenderText*, unsigned offset, unsigned length, const RenderStyle&,
241         TextRun::ExpansionBehavior = TextRun::AllowTrailingExpansion | TextRun::ForbidLeadingExpansion);
242
243     static TextRun constructTextRun(RenderObject* context, const Font&, const RenderText*, unsigned offset, const RenderStyle&,
244         TextRun::ExpansionBehavior = TextRun::AllowTrailingExpansion | TextRun::ForbidLeadingExpansion);
245
246     static TextRun constructTextRun(RenderObject* context, const Font&, const LChar* characters, int length, const RenderStyle&,
247         TextRun::ExpansionBehavior = TextRun::AllowTrailingExpansion | TextRun::ForbidLeadingExpansion);
248
249     static TextRun constructTextRun(RenderObject* context, const Font&, const UChar* characters, int length, const RenderStyle&,
250         TextRun::ExpansionBehavior = TextRun::AllowTrailingExpansion | TextRun::ForbidLeadingExpansion);
251
252     ColumnInfo* columnInfo() const;
253     int columnGap() const;
254
255     // FIXME: Can devirtualize this and only have the RenderBlockFlow version once the old multi-column code is gone.
256     virtual void updateColumnProgressionFromStyle(RenderStyle*);
257     
258     LayoutUnit initialBlockOffsetForPainting() const;
259     LayoutUnit blockDeltaForPaintingNextColumn() const;
260
261     // These two functions take the ColumnInfo* to avoid repeated lookups of the info in the global HashMap.
262     unsigned columnCount(ColumnInfo*) const;
263     LayoutRect columnRectAt(ColumnInfo*, unsigned) const;
264
265     LayoutUnit paginationStrut() const;
266     void setPaginationStrut(LayoutUnit);
267
268     // The page logical offset is the object's offset from the top of the page in the page progression
269     // direction (so an x-offset in vertical text and a y-offset for horizontal text).
270     LayoutUnit pageLogicalOffset() const;
271     void setPageLogicalOffset(LayoutUnit);
272
273     // Accessors for logical width/height and margins in the containing block's block-flow direction.
274     enum ApplyLayoutDeltaMode { ApplyLayoutDelta, DoNotApplyLayoutDelta };
275     LayoutUnit logicalWidthForChild(const RenderBox& child) const { return isHorizontalWritingMode() ? child.width() : child.height(); }
276     LayoutUnit logicalHeightForChild(const RenderBox& child) const { return isHorizontalWritingMode() ? child.height() : child.width(); }
277     LayoutSize logicalSizeForChild(const RenderBox& child) const { return isHorizontalWritingMode() ? child.size() : child.size().transposedSize(); }
278     LayoutUnit logicalTopForChild(const RenderBox& child) const { return isHorizontalWritingMode() ? child.y() : child.x(); }
279     void setLogicalLeftForChild(RenderBox& child, LayoutUnit logicalLeft, ApplyLayoutDeltaMode = DoNotApplyLayoutDelta);
280     void setLogicalTopForChild(RenderBox& child, LayoutUnit logicalTop, ApplyLayoutDeltaMode = DoNotApplyLayoutDelta);
281     LayoutUnit marginBeforeForChild(const RenderBoxModelObject& child) const { return child.marginBefore(&style()); }
282     LayoutUnit marginAfterForChild(const RenderBoxModelObject& child) const { return child.marginAfter(&style()); }
283     LayoutUnit marginStartForChild(const RenderBoxModelObject& child) const { return child.marginStart(&style()); }
284     LayoutUnit marginEndForChild(const RenderBoxModelObject& child) const { return child.marginEnd(&style()); }
285     void setMarginStartForChild(RenderBox& child, LayoutUnit value) const { child.setMarginStart(value, &style()); }
286     void setMarginEndForChild(RenderBox& child, LayoutUnit value) const { child.setMarginEnd(value, &style()); }
287     void setMarginBeforeForChild(RenderBox& child, LayoutUnit value) const { child.setMarginBefore(value, &style()); }
288     void setMarginAfterForChild(RenderBox& child, LayoutUnit value) const { child.setMarginAfter(value, &style()); }
289     LayoutUnit collapsedMarginBeforeForChild(const RenderBox& child) const;
290     LayoutUnit collapsedMarginAfterForChild(const RenderBox& child) const;
291
292     virtual void updateFirstLetter();
293
294     virtual void scrollbarsChanged(bool /*horizontalScrollbarChanged*/, bool /*verticalScrollbarChanged*/) { }
295
296     LayoutUnit logicalLeftOffsetForContent(RenderRegion*) const;
297     LayoutUnit logicalRightOffsetForContent(RenderRegion*) const;
298     LayoutUnit availableLogicalWidthForContent(RenderRegion* region) const
299     { 
300         return std::max<LayoutUnit>(0, logicalRightOffsetForContent(region) - logicalLeftOffsetForContent(region));
301     }
302     LayoutUnit startOffsetForContent(RenderRegion* region) const
303     {
304         return style().isLeftToRightDirection() ? logicalLeftOffsetForContent(region) : logicalWidth() - logicalRightOffsetForContent(region);
305     }
306     LayoutUnit endOffsetForContent(RenderRegion* region) const
307     {
308         return !style().isLeftToRightDirection() ? logicalLeftOffsetForContent(region) : logicalWidth() - logicalRightOffsetForContent(region);
309     }
310     LayoutUnit logicalLeftOffsetForContent(LayoutUnit blockOffset) const
311     {
312         return logicalLeftOffsetForContent(regionAtBlockOffset(blockOffset));
313     }
314     LayoutUnit logicalRightOffsetForContent(LayoutUnit blockOffset) const
315     {
316         return logicalRightOffsetForContent(regionAtBlockOffset(blockOffset));
317     }
318     LayoutUnit availableLogicalWidthForContent(LayoutUnit blockOffset) const
319     {
320         return availableLogicalWidthForContent(regionAtBlockOffset(blockOffset));
321     }
322     LayoutUnit startOffsetForContent(LayoutUnit blockOffset) const
323     {
324         return startOffsetForContent(regionAtBlockOffset(blockOffset));
325     }
326     LayoutUnit endOffsetForContent(LayoutUnit blockOffset) const
327     {
328         return endOffsetForContent(regionAtBlockOffset(blockOffset));
329     }
330     LayoutUnit logicalLeftOffsetForContent() const { return isHorizontalWritingMode() ? borderLeft() + paddingLeft() : borderTop() + paddingTop(); }
331     LayoutUnit logicalRightOffsetForContent() const { return logicalLeftOffsetForContent() + availableLogicalWidth(); }
332     LayoutUnit startOffsetForContent() const { return style().isLeftToRightDirection() ? logicalLeftOffsetForContent() : logicalWidth() - logicalRightOffsetForContent(); }
333     LayoutUnit endOffsetForContent() const { return !style().isLeftToRightDirection() ? logicalLeftOffsetForContent() : logicalWidth() - logicalRightOffsetForContent(); }
334
335     LayoutUnit logicalLeftSelectionOffset(RenderBlock& rootBlock, LayoutUnit position, const LogicalSelectionOffsetCaches&);
336     LayoutUnit logicalRightSelectionOffset(RenderBlock& rootBlock, LayoutUnit position, const LogicalSelectionOffsetCaches&);
337
338     LayoutUnit computeStartPositionDeltaForChildAvoidingFloats(const RenderBox& child, LayoutUnit childMarginStart, RenderRegion* = 0);
339
340 #ifndef NDEBUG
341     void checkPositionedObjectsNeedLayout();
342     virtual void showLineTreeAndMark(const InlineBox* = nullptr, const char* = nullptr, const InlineBox* = nullptr, const char* = nullptr, const RenderObject* = nullptr) const;
343 #endif
344
345
346 #if ENABLE(CSS_SHAPES)
347     virtual void imageChanged(WrappedImagePtr, const IntRect* = 0) override;
348 #endif
349
350     virtual void updateHitTestResult(HitTestResult&, const LayoutPoint&) override;
351
352     virtual bool canHaveChildren() const override { return true; }
353
354 protected:
355     virtual void willBeDestroyed() override;
356
357     virtual void layout() override;
358
359     void layoutPositionedObjects(bool relayoutChildren, bool fixedPositionObjectsOnly = false);
360     void markFixedPositionObjectForLayoutIfNeeded(RenderObject& child);
361
362     LayoutUnit marginIntrinsicLogicalWidthForChild(RenderBox&) const;
363
364     virtual void paint(PaintInfo&, const LayoutPoint&) override;
365     virtual void paintObject(PaintInfo&, const LayoutPoint&) override;
366     virtual void paintChildren(PaintInfo& forSelf, const LayoutPoint&, PaintInfo& forChild, bool usePrintRect);
367     bool paintChild(RenderBox&, PaintInfo& forSelf, const LayoutPoint&, PaintInfo& forChild, bool usePrintRect);
368    
369     LayoutUnit logicalRightOffsetForLine(LayoutUnit logicalTop, LayoutUnit fixedOffset, bool applyTextIndent, LayoutUnit logicalHeight = 0) const
370     {
371         return adjustLogicalRightOffsetForLine(logicalRightFloatOffsetForLine(logicalTop, fixedOffset, logicalHeight), applyTextIndent);
372     }
373     LayoutUnit logicalLeftOffsetForLine(LayoutUnit logicalTop, LayoutUnit fixedOffset, bool applyTextIndent, LayoutUnit logicalHeight = 0) const
374     {
375         return adjustLogicalLeftOffsetForLine(logicalLeftFloatOffsetForLine(logicalTop, fixedOffset, logicalHeight), applyTextIndent);
376     }
377
378     virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) override;
379
380     virtual void computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const override;
381     virtual void computePreferredLogicalWidths() override;
382     void adjustIntrinsicLogicalWidthsForColumns(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const;
383
384     virtual int firstLineBaseline() const override;
385     virtual int inlineBlockBaseline(LineDirectionMode) const override;
386
387     // Delay update scrollbar until finishDelayRepaint() will be
388     // called. This function is used when a flexbox is laying out its
389     // descendant. If multiple calls are made to startDelayRepaint(),
390     // finishDelayRepaint() will do nothing until finishDelayRepaint()
391     // is called the same number of times.
392     static void startDelayUpdateScrollInfo();
393     static void finishDelayUpdateScrollInfo();
394
395     void updateScrollInfoAfterLayout();
396     void removeFromDelayedUpdateScrollInfoSet();
397
398     virtual void styleWillChange(StyleDifference, const RenderStyle& newStyle) override;
399     virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle) override;
400
401     virtual bool hasLineIfEmpty() const;
402     
403     bool simplifiedLayout();
404     virtual void simplifiedNormalFlowLayout();
405
406     // FIXME: Can de-virtualize this once old columns go away.
407     virtual void setComputedColumnCountAndWidth(int, LayoutUnit);
408
409     bool childBoxIsUnsplittableForFragmentation(const RenderBox& child) const;
410
411 public:
412     virtual void computeOverflow(LayoutUnit oldClientAfterEdge, bool recomputeFloats = false);
413     void clearLayoutOverflow();
414     
415     bool isTopLayoutOverflowAllowed() const override;
416     bool isLeftLayoutOverflowAllowed() const override;
417
418     // FIXME: Can devirtualize once old column code is gone.
419     virtual void computeLineGridPaginationOrigin(LayoutState&) const;
420
421 protected:
422     virtual void addOverflowFromChildren();
423     // FIXME-BLOCKFLOW: Remove virtualization when all callers have moved to RenderBlockFlow
424     virtual void addOverflowFromInlineChildren() { }
425     void addOverflowFromBlockChildren();
426     void addOverflowFromPositionedObjects();
427     void addVisualOverflowFromTheme();
428
429     virtual void addFocusRingRects(Vector<IntRect>&, const LayoutPoint& additionalOffset, const RenderLayerModelObject* paintContainer = 0) override;
430     virtual void addFocusRingRectsForInlineChildren(Vector<IntRect>&, const LayoutPoint& additionalOffset, const RenderLayerModelObject* paintContainer);
431
432     void computeRegionRangeForBoxChild(const RenderBox&) const;
433
434     void estimateRegionRangeForBoxChild(const RenderBox&) const;
435     bool updateRegionRangeForBoxChild(const RenderBox&) const;
436
437     void updateBlockChildDirtyBitsBeforeLayout(bool relayoutChildren, RenderBox&);
438
439     void preparePaginationBeforeBlockLayout(bool&);
440
441 private:
442     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
443     virtual LayoutUnit logicalRightFloatOffsetForLine(LayoutUnit, LayoutUnit fixedOffset, LayoutUnit) const { return fixedOffset; };
444     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
445     virtual LayoutUnit logicalLeftFloatOffsetForLine(LayoutUnit, LayoutUnit fixedOffset, LayoutUnit) const { return fixedOffset; }
446     LayoutUnit adjustLogicalRightOffsetForLine(LayoutUnit offsetFromFloats, bool applyTextIndent) const;
447     LayoutUnit adjustLogicalLeftOffsetForLine(LayoutUnit offsetFromFloats, bool applyTextIndent) const;
448
449     virtual const char* renderName() const override;
450
451     virtual bool isInlineBlockOrInlineTable() const override final { return isInline() && isReplaced(); }
452
453     void makeChildrenNonInline(RenderObject* insertionPoint = nullptr);
454     virtual void removeLeftoverAnonymousBlock(RenderBlock* child);
455
456     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
457     virtual void moveAllChildrenIncludingFloatsTo(RenderBlock* toBlock, bool fullRemoveInsert) { moveAllChildrenTo(toBlock, fullRemoveInsert); }
458
459     void addChildToContinuation(RenderObject* newChild, RenderObject* beforeChild);
460     virtual void addChildIgnoringContinuation(RenderObject* newChild, RenderObject* beforeChild) override;
461     void addChildToAnonymousColumnBlocks(RenderObject* newChild, RenderObject* beforeChild);
462
463     void addChildIgnoringAnonymousColumnBlocks(RenderObject* newChild, RenderObject* beforeChild = 0);
464     
465     virtual bool isSelfCollapsingBlock() const override final;
466     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
467     virtual bool hasLines() const { return false; }
468
469     void insertIntoTrackedRendererMaps(RenderBox& descendant, TrackedDescendantsMap*&, TrackedContainerMap*&);
470     static void removeFromTrackedRendererMaps(RenderBox& descendant, TrackedDescendantsMap*&, TrackedContainerMap*&);
471
472     void createFirstLetterRenderer(RenderObject* firstLetterBlock, RenderText* currentTextChild);
473     void updateFirstLetterStyle(RenderObject* firstLetterBlock, RenderObject* firstLetterContainer);
474
475     Node* nodeForHitTest() const;
476
477     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
478     virtual void paintFloats(PaintInfo&, const LayoutPoint&, bool) { }
479     virtual void paintInlineChildren(PaintInfo&, const LayoutPoint&) { }
480     void paintContents(PaintInfo&, const LayoutPoint&);
481     void paintColumnContents(PaintInfo&, const LayoutPoint&, bool paintFloats = false);
482     void paintColumnRules(PaintInfo&, const LayoutPoint&);
483     void paintSelection(PaintInfo&, const LayoutPoint&);
484     void paintCaret(PaintInfo&, const LayoutPoint&, CaretType);
485
486     virtual bool avoidsFloats() const override;
487
488     bool hitTestColumns(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction);
489     virtual bool hitTestContents(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction);
490     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
491     virtual bool hitTestFloats(const HitTestRequest&, HitTestResult&, const HitTestLocation&, const LayoutPoint&) { return false; }
492     virtual bool hitTestInlineChildren(const HitTestRequest&, HitTestResult&, const HitTestLocation&, const LayoutPoint&, HitTestAction) { return false; }
493
494     virtual bool isPointInOverflowControl(HitTestResult&, const LayoutPoint& locationInContainer, const LayoutPoint& accumulatedOffset);
495
496     // FIXME: Make this method const so we can remove the const_cast in computeIntrinsicLogicalWidths.
497     void computeInlinePreferredLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth);
498     void computeBlockPreferredLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const;
499
500     // Obtains the nearest enclosing block (including this block) that contributes a first-line style to our inline
501     // children.
502     virtual RenderBlock* firstLineBlock() const override;
503
504     virtual LayoutRect rectWithOutlineForRepaint(const RenderLayerModelObject* repaintContainer, LayoutUnit outlineWidth) const override final;
505     virtual const RenderStyle& outlineStyleForRepaint() const override final;
506     
507     virtual RenderElement* hoverAncestor() const override final;
508     virtual void updateDragState(bool dragOn) override final;
509     virtual void childBecameNonInline(RenderObject* child) override final;
510
511     virtual LayoutRect selectionRectForRepaint(const RenderLayerModelObject* repaintContainer, bool /*clipToVisibleContent*/) override final
512     {
513         return selectionGapRectsForRepaint(repaintContainer);
514     }
515     virtual bool shouldPaintSelectionGaps() const override final;
516     bool isSelectionRoot() const;
517     GapRects selectionGaps(RenderBlock& rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
518         LayoutUnit& lastLogicalTop, LayoutUnit& lastLogicalLeft, LayoutUnit& lastLogicalRight, const LogicalSelectionOffsetCaches&, const PaintInfo* = 0);
519     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
520     virtual GapRects inlineSelectionGaps(RenderBlock& rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
521         LayoutUnit& lastLogicalTop, LayoutUnit& lastLogicalLeft, LayoutUnit& lastLogicalRight, const LogicalSelectionOffsetCaches&, const PaintInfo*);
522     GapRects blockSelectionGaps(RenderBlock& rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
523         LayoutUnit& lastLogicalTop, LayoutUnit& lastLogicalLeft, LayoutUnit& lastLogicalRight, const LogicalSelectionOffsetCaches&, const PaintInfo*);
524     LayoutRect blockSelectionGap(RenderBlock& rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
525         LayoutUnit lastLogicalTop, LayoutUnit lastLogicalLeft, LayoutUnit lastLogicalRight, LayoutUnit logicalBottom, const LogicalSelectionOffsetCaches&, const PaintInfo*);
526
527     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
528     virtual void clipOutFloatingObjects(RenderBlock&, const PaintInfo*, const LayoutPoint&, const LayoutSize&) { };
529     friend class LogicalSelectionOffsetCaches;
530
531     virtual void absoluteRects(Vector<IntRect>&, const LayoutPoint& accumulatedOffset) const override;
532     virtual void absoluteQuads(Vector<FloatQuad>&, bool* wasFixed) const override;
533
534     // FIXME: Can de-virtualize once old columns go away.
535     virtual LayoutUnit computedColumnWidth() const;
536     virtual unsigned computedColumnCount() const;
537
538     void paintContinuationOutlines(PaintInfo&, const LayoutPoint&);
539
540     virtual LayoutRect localCaretRect(InlineBox*, int caretOffset, LayoutUnit* extraWidthToEndOfLine = 0) override final;
541
542     void adjustPointToColumnContents(LayoutPoint&) const;
543     
544     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
545     virtual VisiblePosition positionForPointWithInlineChildren(const LayoutPoint&);
546
547     virtual void computeColumnCountAndWidth();
548     void makeChildrenAnonymousColumnBlocks(RenderObject* beforeChild, RenderBlock* newBlockBox, RenderObject* newChild);
549
550     bool expandsToEncloseOverhangingFloats() const;
551
552     void splitBlocks(RenderBlock* fromBlock, RenderBlock* toBlock, RenderBlock* middleBlock,
553                      RenderObject* beforeChild, RenderBoxModelObject* oldCont);
554     void splitFlow(RenderObject* beforeChild, RenderBlock* newBlockBox,
555                    RenderObject* newChild, RenderBoxModelObject* oldCont);
556     RenderPtr<RenderBlock> clone() const;
557     RenderBlock* continuationBefore(RenderObject* beforeChild);
558     RenderBlock* containingColumnsBlock(bool allowAnonymousColumnBlock = true);
559     RenderBlock* columnsBlockForSpanningElement(RenderObject* newChild);
560
561 private:
562     bool hasRareData() const;
563     
564 protected:
565     void dirtyForLayoutFromPercentageHeightDescendants();
566     
567     virtual ColumnInfo::PaginationUnit paginationUnit() const;
568
569 protected:
570     // Adjust from painting offsets to the local coords of this renderer
571     void offsetForContents(LayoutPoint&) const;
572
573     virtual bool requiresColumns(int computedColumnCount) const;
574
575     bool updateLogicalWidthAndColumnWidth();
576
577     virtual bool canCollapseAnonymousBlockChild() const { return true; }
578
579 public:
580     virtual LayoutUnit offsetFromLogicalTopOfFirstPage() const override;
581     RenderRegion* regionAtBlockOffset(LayoutUnit) const;
582
583     // 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
584     // RenderBlock yet.
585     friend class RenderBlockFlow;
586     // FIXME-BLOCKFLOW: Remove this when the line layout stuff has all moved out of RenderBlock
587     friend class LineBreaker;
588
589     mutable signed m_lineHeight : 25;
590     unsigned m_hasMarginBeforeQuirk : 1; // Note these quirk values can't be put in RenderBlockRareData since they are set too frequently.
591     unsigned m_hasMarginAfterQuirk : 1;
592     unsigned m_beingDestroyed : 1;
593     unsigned m_hasMarkupTruncation : 1;
594     unsigned m_hasBorderOrPaddingLogicalWidthChanged : 1;
595     enum LineLayoutPath { UndeterminedPath, SimpleLinesPath, LineBoxesPath, ForceLineBoxesPath };
596     unsigned m_lineLayoutPath : 2;
597     
598     // RenderRubyBase objects need to be able to split and merge, moving their children around
599     // (calling moveChildTo, moveAllChildrenTo, and makeChildrenNonInline).
600     friend class RenderRubyBase;
601
602 private:
603     // Used to store state between styleWillChange and styleDidChange
604     static bool s_canPropagateFloatIntoSibling;
605 };
606
607 RENDER_OBJECT_TYPE_CASTS(RenderBlock, isRenderBlock())
608
609 LayoutUnit blockDirectionOffset(RenderBlock& rootBlock, const LayoutSize& offsetFromRootBlock);
610 LayoutUnit inlineDirectionOffset(RenderBlock& rootBlock, const LayoutSize& offsetFromRootBlock);
611 VisiblePosition positionForPointRespectingEditingBoundaries(RenderBlock&, RenderBox&, const LayoutPoint&);
612
613 } // namespace WebCore
614
615 #endif // RenderBlock_h