CTTE: EllipsisBox::renderer() should return RenderBlock&.
[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 "FloatingObjects.h"
28 #include "GapRects.h"
29 #include "PODIntervalTree.h"
30 #include "RenderBox.h"
31 #include "RenderLineBoxList.h"
32 #include "RootInlineBox.h"
33 #include "TextBreakIterator.h"
34 #include "TextRun.h"
35 #include <wtf/OwnPtr.h>
36 #include <wtf/ListHashSet.h>
37
38 #if ENABLE(CSS_SHAPES)
39 #include "ShapeInsideInfo.h"
40 #include "ShapeValue.h"
41 #endif
42
43 namespace WebCore {
44
45 class BidiContext;
46 class InlineIterator;
47 class LayoutStateMaintainer;
48 class LineLayoutState;
49 class LineWidth;
50 class LogicalSelectionOffsetCaches;
51 class RenderInline;
52 class RenderText;
53
54 struct BidiRun;
55 struct PaintInfo;
56 class LineInfo;
57 class RenderRubyRun;
58 #if ENABLE(CSS_SHAPES)
59 class BasicShape;
60 #endif
61 class TextLayout;
62 class WordMeasurement;
63
64 template <class Iterator, class Run> class BidiResolver;
65 template <class Run> class BidiRunList;
66 template <class Iterator> struct MidpointState;
67 typedef BidiResolver<InlineIterator, BidiRun> InlineBidiResolver;
68 typedef MidpointState<InlineIterator> LineMidpointState;
69 typedef WTF::ListHashSet<RenderBox*, 16> TrackedRendererListHashSet;
70 typedef WTF::HashMap<const RenderBlock*, OwnPtr<TrackedRendererListHashSet> > TrackedDescendantsMap;
71 typedef WTF::HashMap<const RenderBox*, OwnPtr<HashSet<RenderBlock*> > > TrackedContainerMap;
72 typedef Vector<WordMeasurement, 64> WordMeasurements;
73
74 enum CaretType { CursorCaret, DragCaret };
75 enum ContainingBlockState { NewContainingBlock, SameContainingBlock };
76
77 #if ENABLE(IOS_TEXT_AUTOSIZING)
78 enum LineCount {
79     NOT_SET = 0, NO_LINE = 1, ONE_LINE = 2, MULTI_LINE = 3
80 };
81 #endif
82
83 enum TextRunFlag {
84     DefaultTextRunFlags = 0,
85     RespectDirection = 1 << 0,
86     RespectDirectionOverride = 1 << 1
87 };
88
89 typedef unsigned TextRunFlags;
90
91 class RenderBlock : public RenderBox {
92 public:
93     friend class LineLayoutState;
94 #ifndef NDEBUG
95     // Used by the PODIntervalTree for debugging the FloatingObject.
96     template <class> friend struct ValueToString;
97 #endif
98
99 protected:
100     explicit RenderBlock(Element*);
101     virtual ~RenderBlock();
102
103 public:
104     static RenderBlock* createAnonymous(Document&);
105
106     RenderObject* firstChild() const { return m_children.firstChild(); }
107     RenderObject* lastChild() const { return m_children.lastChild(); }
108
109     virtual const RenderObjectChildList* children() const OVERRIDE FINAL { return &m_children; }
110     virtual RenderObjectChildList* children() OVERRIDE FINAL { return &m_children; }
111
112     bool beingDestroyed() const { return m_beingDestroyed; }
113
114     // These two functions are overridden for inline-block.
115     virtual LayoutUnit lineHeight(bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const OVERRIDE FINAL;
116     virtual int baselinePosition(FontBaseline, bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const OVERRIDE;
117
118     RenderLineBoxList& lineBoxes() { return m_lineBoxes; }
119     const RenderLineBoxList& lineBoxes() const { return m_lineBoxes; }
120
121     InlineFlowBox* firstLineBox() const { return m_lineBoxes.firstLineBox(); }
122     InlineFlowBox* lastLineBox() const { return m_lineBoxes.lastLineBox(); }
123
124     void deleteLineBoxTree();
125
126     virtual void addChild(RenderObject* newChild, RenderObject* beforeChild = 0);
127     virtual void removeChild(RenderObject*);
128
129     virtual void layoutBlock(bool relayoutChildren, LayoutUnit pageLogicalHeight = 0);
130
131     void insertPositionedObject(RenderBox*);
132     static void removePositionedObject(RenderBox*);
133     void removePositionedObjects(RenderBlock*, ContainingBlockState = SameContainingBlock);
134
135     void removeFloatingObjects();
136
137     TrackedRendererListHashSet* positionedObjects() const;
138     bool hasPositionedObjects() const
139     {
140         TrackedRendererListHashSet* objects = positionedObjects();
141         return objects && !objects->isEmpty();
142     }
143
144     void addPercentHeightDescendant(RenderBox*);
145     static void removePercentHeightDescendant(RenderBox*);
146     TrackedRendererListHashSet* percentHeightDescendants() const;
147     static bool hasPercentHeightContainerMap();
148     static bool hasPercentHeightDescendant(RenderBox*);
149     static void clearPercentHeightDescendantsFrom(RenderBox*);
150     static void removePercentHeightDescendantIfNeeded(RenderBox*);
151
152     void setHasMarkupTruncation(bool b) { m_hasMarkupTruncation = b; }
153     bool hasMarkupTruncation() const { return m_hasMarkupTruncation; }
154
155     void setHasMarginBeforeQuirk(bool b) { m_hasMarginBeforeQuirk = b; }
156     void setHasMarginAfterQuirk(bool b) { m_hasMarginAfterQuirk = b; }
157
158     bool hasMarginBeforeQuirk() const { return m_hasMarginBeforeQuirk; }
159     bool hasMarginAfterQuirk() const { return m_hasMarginAfterQuirk; }
160
161     bool hasMarginBeforeQuirk(const RenderBox* child) const;
162     bool hasMarginAfterQuirk(const RenderBox* child) const;
163
164     RootInlineBox* createAndAppendRootInlineBox();
165
166     bool generatesLineBoxesForInlineChild(RenderObject*);
167
168     void updateFloatingObjectsPaintingContainer(RenderBox* floatToUpdate);
169
170     void markAllDescendantsWithFloatsForLayout(RenderBox* floatToRemove = 0, bool inLayout = true);
171     void markSiblingsWithFloatsForLayout(RenderBox* floatToRemove = 0);
172     void markPositionedObjectsForLayout();
173     virtual void markForPaginationRelayoutIfNeeded() OVERRIDE FINAL;
174     
175     bool containsFloats() const { return m_floatingObjects && !m_floatingObjects->set().isEmpty(); }
176     bool containsFloat(RenderBox*) const;
177
178     // Versions that can compute line offsets with the region and page offset passed in. Used for speed to avoid having to
179     // compute the region all over again when you already know it.
180     LayoutUnit availableLogicalWidthForLine(LayoutUnit position, bool shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const
181     {
182         return max<LayoutUnit>(0, logicalRightOffsetForLine(position, shouldIndentText, region, logicalHeight)
183             - logicalLeftOffsetForLine(position, shouldIndentText, region, logicalHeight));
184     }
185     LayoutUnit logicalRightOffsetForLine(LayoutUnit position, bool shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const 
186     {
187         return logicalRightOffsetForLine(position, logicalRightOffsetForContent(region), shouldIndentText, 0, logicalHeight);
188     }
189     LayoutUnit logicalLeftOffsetForLine(LayoutUnit position, bool shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const 
190     {
191         return logicalLeftOffsetForLine(position, logicalLeftOffsetForContent(region), shouldIndentText, 0, logicalHeight);
192     }
193     LayoutUnit startOffsetForLine(LayoutUnit position, bool shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const
194     {
195         return style()->isLeftToRightDirection() ? logicalLeftOffsetForLine(position, shouldIndentText, region, logicalHeight)
196             : logicalWidth() - logicalRightOffsetForLine(position, shouldIndentText, region, logicalHeight);
197     }
198     LayoutUnit endOffsetForLine(LayoutUnit position, bool shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const
199     {
200         return !style()->isLeftToRightDirection() ? logicalLeftOffsetForLine(position, shouldIndentText, region, logicalHeight)
201             : logicalWidth() - logicalRightOffsetForLine(position, shouldIndentText, region, logicalHeight);
202     }
203
204     LayoutUnit availableLogicalWidthForLine(LayoutUnit position, bool shouldIndentText, LayoutUnit logicalHeight = 0) const
205     {
206         return availableLogicalWidthForLine(position, shouldIndentText, regionAtBlockOffset(position), logicalHeight);
207     }
208     LayoutUnit logicalRightOffsetForLine(LayoutUnit position, bool shouldIndentText, LayoutUnit logicalHeight = 0) const 
209     {
210         return logicalRightOffsetForLine(position, logicalRightOffsetForContent(position), shouldIndentText, 0, logicalHeight);
211     }
212     LayoutUnit logicalLeftOffsetForLine(LayoutUnit position, bool shouldIndentText, LayoutUnit logicalHeight = 0) const 
213     {
214         return logicalLeftOffsetForLine(position, logicalLeftOffsetForContent(position), shouldIndentText, 0, logicalHeight);
215     }
216     LayoutUnit pixelSnappedLogicalLeftOffsetForLine(LayoutUnit position, bool shouldIndentText, LayoutUnit logicalHeight = 0) const 
217     {
218         return roundToInt(logicalLeftOffsetForLine(position, shouldIndentText, logicalHeight));
219     }
220     LayoutUnit pixelSnappedLogicalRightOffsetForLine(LayoutUnit position, bool shouldIndentText, LayoutUnit logicalHeight = 0) const 
221     {
222         // FIXME: Multicolumn layouts break carrying over subpixel values to the logical right offset because the lines may be shifted
223         // by a subpixel value for all but the first column. This can lead to the actual pixel snapped width of the column being off
224         // by one pixel when rendered versus layed out, which can result in the line being clipped. For now, we have to floor.
225         // https://bugs.webkit.org/show_bug.cgi?id=105461
226         return floorToInt(logicalRightOffsetForLine(position, shouldIndentText, logicalHeight));
227     }
228     LayoutUnit startOffsetForLine(LayoutUnit position, bool shouldIndentText, LayoutUnit logicalHeight = 0) const
229     {
230         return style()->isLeftToRightDirection() ? logicalLeftOffsetForLine(position, shouldIndentText, logicalHeight)
231             : logicalWidth() - logicalRightOffsetForLine(position, shouldIndentText, logicalHeight);
232     }
233     LayoutUnit endOffsetForLine(LayoutUnit position, bool shouldIndentText, LayoutUnit logicalHeight = 0) const
234     {
235         return !style()->isLeftToRightDirection() ? logicalLeftOffsetForLine(position, shouldIndentText, logicalHeight)
236             : logicalWidth() - logicalRightOffsetForLine(position, shouldIndentText, logicalHeight);
237     }
238
239     LayoutUnit startAlignedOffsetForLine(LayoutUnit position, bool shouldIndentText);
240     LayoutUnit textIndentOffset() const;
241
242     virtual VisiblePosition positionForPoint(const LayoutPoint&);
243     
244     // Block flows subclass availableWidth to handle multi column layout (shrinking the width available to children when laying out.)
245     virtual LayoutUnit availableLogicalWidth() const OVERRIDE FINAL;
246
247     LayoutPoint flipForWritingModeIncludingColumns(const LayoutPoint&) const;
248     void adjustStartEdgeForWritingModeIncludingColumns(LayoutRect&) const;
249
250     RootInlineBox* firstRootBox() const { return static_cast<RootInlineBox*>(firstLineBox()); }
251     RootInlineBox* lastRootBox() const { return static_cast<RootInlineBox*>(lastLineBox()); }
252
253     bool containsNonZeroBidiLevel() const;
254
255     GapRects selectionGapRectsForRepaint(const RenderLayerModelObject* repaintContainer);
256     LayoutRect logicalLeftSelectionGap(RenderBlock* rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
257         RenderObject* selObj, LayoutUnit logicalLeft, LayoutUnit logicalTop, LayoutUnit logicalHeight, const LogicalSelectionOffsetCaches&, const PaintInfo*);
258     LayoutRect logicalRightSelectionGap(RenderBlock* rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
259         RenderObject* selObj, LayoutUnit logicalRight, LayoutUnit logicalTop, LayoutUnit logicalHeight, const LogicalSelectionOffsetCaches&, const PaintInfo*);
260     void getSelectionGapInfo(SelectionState, bool& leftGap, bool& rightGap);
261     RenderBlock* blockBeforeWithinSelectionRoot(LayoutSize& offset) const;
262
263     LayoutRect logicalRectToPhysicalRect(const LayoutPoint& physicalPosition, const LayoutRect& logicalRect);
264
265     // Helper methods for computing line counts and heights for line counts.
266     RootInlineBox* lineAtIndex(int) const;
267     int lineCount(const RootInlineBox* = 0, bool* = 0) const;
268     int heightForLineCount(int);
269     void clearTruncation();
270
271     void adjustRectForColumns(LayoutRect&) const;
272     virtual void adjustForColumns(LayoutSize&, const LayoutPoint&) const OVERRIDE FINAL;
273     void adjustForColumnRect(LayoutSize& offset, const LayoutPoint& locationInContainer) const;
274
275     void addContinuationWithOutline(RenderInline*);
276     bool paintsContinuationOutline(RenderInline*);
277
278     virtual RenderBoxModelObject* virtualContinuation() const OVERRIDE FINAL { return continuation(); }
279     bool isAnonymousBlockContinuation() const { return continuation() && isAnonymousBlock(); }
280     RenderInline* inlineElementContinuation() const;
281     RenderBlock* blockElementContinuation() const;
282
283     using RenderBoxModelObject::continuation;
284     using RenderBoxModelObject::setContinuation;
285
286     static RenderBlock* createAnonymousWithParentRendererAndDisplay(const RenderObject*, EDisplay = BLOCK);
287     static RenderBlock* createAnonymousColumnsWithParentRenderer(const RenderObject*);
288     static RenderBlock* createAnonymousColumnSpanWithParentRenderer(const RenderObject*);
289     RenderBlock* createAnonymousBlock(EDisplay display = BLOCK) const { return createAnonymousWithParentRendererAndDisplay(this, display); }
290     RenderBlock* createAnonymousColumnsBlock() const { return createAnonymousColumnsWithParentRenderer(this); }
291     RenderBlock* createAnonymousColumnSpanBlock() const { return createAnonymousColumnSpanWithParentRenderer(this); }
292     static void collapseAnonymousBoxChild(RenderBlock* parent, RenderObject* child);
293
294     virtual RenderBox* createAnonymousBoxWithSameTypeAs(const RenderObject* parent) const OVERRIDE;
295
296     static bool shouldSkipCreatingRunsForObject(RenderObject* obj)
297     {
298         return obj->isFloating() || (obj->isOutOfFlowPositioned() && !obj->style()->isOriginalDisplayInlineType() && !obj->container()->isRenderInline());
299     }
300     
301     static void appendRunsForObject(BidiRunList<BidiRun>&, int start, int end, RenderObject*, InlineBidiResolver&);
302
303     static TextRun constructTextRun(RenderObject* context, const Font& font, const String& string, RenderStyle* style,
304         TextRun::ExpansionBehavior = TextRun::AllowTrailingExpansion | TextRun::ForbidLeadingExpansion, TextRunFlags = DefaultTextRunFlags);
305
306     static TextRun constructTextRun(RenderObject* context, const Font& font, const RenderText* text, RenderStyle* style,
307         TextRun::ExpansionBehavior = TextRun::AllowTrailingExpansion | TextRun::ForbidLeadingExpansion);
308
309     static TextRun constructTextRun(RenderObject* context, const Font& font, const RenderText* text, unsigned offset, unsigned length, RenderStyle* style,
310         TextRun::ExpansionBehavior = TextRun::AllowTrailingExpansion | TextRun::ForbidLeadingExpansion);
311
312     static TextRun constructTextRun(RenderObject* context, const Font& font, const RenderText* text, unsigned offset, RenderStyle* style,
313         TextRun::ExpansionBehavior = TextRun::AllowTrailingExpansion | TextRun::ForbidLeadingExpansion);
314
315 #if ENABLE(8BIT_TEXTRUN)
316     static TextRun constructTextRun(RenderObject* context, const Font& font, const LChar* characters, int length, RenderStyle* style,
317         TextRun::ExpansionBehavior = TextRun::AllowTrailingExpansion | TextRun::ForbidLeadingExpansion);
318 #endif
319
320     static TextRun constructTextRun(RenderObject* context, const Font& font, const UChar* characters, int length, RenderStyle* style,
321         TextRun::ExpansionBehavior = TextRun::AllowTrailingExpansion | TextRun::ForbidLeadingExpansion);
322
323     ColumnInfo* columnInfo() const;
324     int columnGap() const;
325
326     void updateColumnInfoFromStyle(RenderStyle*);
327     
328     LayoutUnit initialBlockOffsetForPainting() const;
329     LayoutUnit blockDeltaForPaintingNextColumn() const;
330
331     // These two functions take the ColumnInfo* to avoid repeated lookups of the info in the global HashMap.
332     unsigned columnCount(ColumnInfo*) const;
333     LayoutRect columnRectAt(ColumnInfo*, unsigned) const;
334
335     LayoutUnit paginationStrut() const { return m_rareData ? m_rareData->m_paginationStrut : LayoutUnit(); }
336     void setPaginationStrut(LayoutUnit);
337
338     // The page logical offset is the object's offset from the top of the page in the page progression
339     // direction (so an x-offset in vertical text and a y-offset for horizontal text).
340     LayoutUnit pageLogicalOffset() const { return m_rareData ? m_rareData->m_pageLogicalOffset : LayoutUnit(); }
341     void setPageLogicalOffset(LayoutUnit);
342
343     RootInlineBox* lineGridBox() const { return m_rareData ? m_rareData->m_lineGridBox : 0; }
344     void setLineGridBox(RootInlineBox* box)
345     {
346         if (!m_rareData)
347             m_rareData = adoptPtr(new RenderBlockRareData());
348         if (m_rareData->m_lineGridBox)
349             m_rareData->m_lineGridBox->destroy(renderArena());
350         m_rareData->m_lineGridBox = box;
351     }
352     void layoutLineGridBox();
353
354     // Accessors for logical width/height and margins in the containing block's block-flow direction.
355     enum ApplyLayoutDeltaMode { ApplyLayoutDelta, DoNotApplyLayoutDelta };
356     LayoutUnit logicalWidthForChild(const RenderBox* child) const { return isHorizontalWritingMode() ? child->width() : child->height(); }
357     LayoutUnit logicalHeightForChild(const RenderBox* child) const { return isHorizontalWritingMode() ? child->height() : child->width(); }
358     LayoutUnit logicalTopForChild(const RenderBox* child) const { return isHorizontalWritingMode() ? child->y() : child->x(); }
359     void setLogicalLeftForChild(RenderBox* child, LayoutUnit logicalLeft, ApplyLayoutDeltaMode = DoNotApplyLayoutDelta);
360     void setLogicalTopForChild(RenderBox* child, LayoutUnit logicalTop, ApplyLayoutDeltaMode = DoNotApplyLayoutDelta);
361     LayoutUnit marginBeforeForChild(const RenderBoxModelObject* child) const { return child->marginBefore(style()); }
362     LayoutUnit marginAfterForChild(const RenderBoxModelObject* child) const { return child->marginAfter(style()); }
363     LayoutUnit marginStartForChild(const RenderBoxModelObject* child) const { return child->marginStart(style()); }
364     LayoutUnit marginEndForChild(const RenderBoxModelObject* child) const { return child->marginEnd(style()); }
365     void setMarginStartForChild(RenderBox* child, LayoutUnit value) const { child->setMarginStart(value, style()); }
366     void setMarginEndForChild(RenderBox* child, LayoutUnit value) const { child->setMarginEnd(value, style()); }
367     void setMarginBeforeForChild(RenderBox* child, LayoutUnit value) const { child->setMarginBefore(value, style()); }
368     void setMarginAfterForChild(RenderBox* child, LayoutUnit value) const { child->setMarginAfter(value, style()); }
369     LayoutUnit collapsedMarginBeforeForChild(const RenderBox* child) const;
370     LayoutUnit collapsedMarginAfterForChild(const RenderBox* child) const;
371
372     void updateLogicalWidthForAlignment(const ETextAlign&, BidiRun* trailingSpaceRun, float& logicalLeft, float& totalLogicalWidth, float& availableLogicalWidth, int expansionOpportunityCount);
373
374     virtual void updateFirstLetter();
375
376     virtual void scrollbarsChanged(bool /*horizontalScrollbarChanged*/, bool /*verticalScrollbarChanged*/) { };
377
378     LayoutUnit logicalLeftOffsetForContent(RenderRegion*) const;
379     LayoutUnit logicalRightOffsetForContent(RenderRegion*) const;
380     LayoutUnit availableLogicalWidthForContent(RenderRegion* region) const
381     { 
382         return max<LayoutUnit>(0, logicalRightOffsetForContent(region) - logicalLeftOffsetForContent(region)); }
383     LayoutUnit startOffsetForContent(RenderRegion* region) const
384     {
385         return style()->isLeftToRightDirection() ? logicalLeftOffsetForContent(region) : logicalWidth() - logicalRightOffsetForContent(region);
386     }
387     LayoutUnit endOffsetForContent(RenderRegion* region) const
388     {
389         return !style()->isLeftToRightDirection() ? logicalLeftOffsetForContent(region) : logicalWidth() - logicalRightOffsetForContent(region);
390     }
391     LayoutUnit logicalLeftOffsetForContent(LayoutUnit blockOffset) const
392     {
393         return logicalLeftOffsetForContent(regionAtBlockOffset(blockOffset));
394     }
395     LayoutUnit logicalRightOffsetForContent(LayoutUnit blockOffset) const
396     {
397         return logicalRightOffsetForContent(regionAtBlockOffset(blockOffset));
398     }
399     LayoutUnit availableLogicalWidthForContent(LayoutUnit blockOffset) const
400     {
401         return availableLogicalWidthForContent(regionAtBlockOffset(blockOffset));
402     }
403     LayoutUnit startOffsetForContent(LayoutUnit blockOffset) const
404     {
405         return startOffsetForContent(regionAtBlockOffset(blockOffset));
406     }
407     LayoutUnit endOffsetForContent(LayoutUnit blockOffset) const
408     {
409         return endOffsetForContent(regionAtBlockOffset(blockOffset));
410     }
411     LayoutUnit logicalLeftOffsetForContent() const { return isHorizontalWritingMode() ? borderLeft() + paddingLeft() : borderTop() + paddingTop(); }
412     LayoutUnit logicalRightOffsetForContent() const { return logicalLeftOffsetForContent() + availableLogicalWidth(); }
413     LayoutUnit startOffsetForContent() const { return style()->isLeftToRightDirection() ? logicalLeftOffsetForContent() : logicalWidth() - logicalRightOffsetForContent(); }
414     LayoutUnit endOffsetForContent() const { return !style()->isLeftToRightDirection() ? logicalLeftOffsetForContent() : logicalWidth() - logicalRightOffsetForContent(); }
415     
416     void setStaticInlinePositionForChild(RenderBox*, LayoutUnit blockOffset, LayoutUnit inlinePosition);
417     void updateStaticInlinePositionForChild(RenderBox*, LayoutUnit logicalTop);
418
419     LayoutUnit computeStartPositionDeltaForChildAvoidingFloats(const RenderBox* child, LayoutUnit childMarginStart, RenderRegion* = 0);
420
421     void placeRunInIfNeeded(RenderObject* newChild);
422     bool runInIsPlacedIntoSiblingBlock(RenderObject* runIn);
423
424 #ifndef NDEBUG
425     void checkPositionedObjectsNeedLayout();
426     void showLineTreeAndMark(const InlineBox* = 0, const char* = 0, const InlineBox* = 0, const char* = 0, const RenderObject* = 0) const;
427 #endif
428
429 #if ENABLE(IOS_TEXT_AUTOSIZING)
430     int immediateLineCount();
431     void adjustComputedFontSizes(float size, float visibleWidth);
432     void resetComputedFontSize()
433     {
434         m_widthForTextAutosizing = -1;
435         m_lineCountForTextAutosizing = NOT_SET;
436     }
437 #endif
438
439 #if ENABLE(CSS_SHAPES)
440     ShapeInsideInfo* ensureShapeInsideInfo()
441     {
442         if (!m_rareData || !m_rareData->m_shapeInsideInfo)
443             setShapeInsideInfo(ShapeInsideInfo::createInfo(this));
444         return m_rareData->m_shapeInsideInfo.get();
445     }
446
447     ShapeInsideInfo* shapeInsideInfo() const
448     {
449         if (!m_rareData || !m_rareData->m_shapeInsideInfo)
450             return 0;
451         return ShapeInsideInfo::isEnabledFor(this) ? m_rareData->m_shapeInsideInfo.get() : 0;
452     }
453     void setShapeInsideInfo(PassOwnPtr<ShapeInsideInfo> value)
454     {
455         if (!m_rareData)
456             m_rareData = adoptPtr(new RenderBlockRareData());
457         m_rareData->m_shapeInsideInfo = value;
458     }
459     void markShapeInsideDescendantsForLayout();
460     ShapeInsideInfo* layoutShapeInsideInfo() const;
461     bool allowsShapeInsideInfoSharing() const { return !isInline() && !isFloating(); }
462     virtual void imageChanged(WrappedImagePtr, const IntRect* = 0) OVERRIDE;
463 #endif
464
465     virtual void updateHitTestResult(HitTestResult&, const LayoutPoint&) OVERRIDE;
466
467 protected:
468     virtual void willBeDestroyed();
469
470     virtual void layout();
471
472     void layoutPositionedObjects(bool relayoutChildren, bool fixedPositionObjectsOnly = false);
473     void markFixedPositionObjectForLayoutIfNeeded(RenderObject* child);
474
475     virtual void paint(PaintInfo&, const LayoutPoint&);
476     virtual void paintObject(PaintInfo&, const LayoutPoint&);
477     virtual void paintChildren(PaintInfo& forSelf, const LayoutPoint&, PaintInfo& forChild, bool usePrintRect);
478     bool paintChild(RenderBox*, PaintInfo& forSelf, const LayoutPoint&, PaintInfo& forChild, bool usePrintRect);
479    
480     LayoutUnit logicalRightOffsetForLine(LayoutUnit logicalTop, LayoutUnit fixedOffset, bool applyTextIndent, LayoutUnit* heightRemaining = 0, LayoutUnit logicalHeight = 0) const
481     {
482         return adjustLogicalRightOffsetForLine(logicalRightFloatOffsetForLine(logicalTop, fixedOffset, heightRemaining, logicalHeight, ShapeOutsideFloatShapeOffset), applyTextIndent);
483     }
484     LayoutUnit logicalLeftOffsetForLine(LayoutUnit logicalTop, LayoutUnit fixedOffset, bool applyTextIndent, LayoutUnit* heightRemaining = 0, LayoutUnit logicalHeight = 0) const
485     {
486         return adjustLogicalLeftOffsetForLine(logicalLeftFloatOffsetForLine(logicalTop, fixedOffset, heightRemaining, logicalHeight, ShapeOutsideFloatShapeOffset), applyTextIndent);
487     }
488     LayoutUnit logicalRightOffsetForLineIgnoringShapeOutside(LayoutUnit logicalTop, LayoutUnit fixedOffset, bool applyTextIndent, LayoutUnit* heightRemaining = 0, LayoutUnit logicalHeight = 0) const
489     {
490         return adjustLogicalRightOffsetForLine(logicalRightFloatOffsetForLine(logicalTop, fixedOffset, heightRemaining, logicalHeight, ShapeOutsideFloatMarginBoxOffset), applyTextIndent);
491     }
492     LayoutUnit logicalLeftOffsetForLineIgnoringShapeOutside(LayoutUnit logicalTop, LayoutUnit fixedOffset, bool applyTextIndent, LayoutUnit* heightRemaining = 0, LayoutUnit logicalHeight = 0) const
493     {
494         return adjustLogicalLeftOffsetForLine(logicalLeftFloatOffsetForLine(logicalTop, fixedOffset, heightRemaining, logicalHeight, ShapeOutsideFloatMarginBoxOffset), applyTextIndent);
495     }
496
497     virtual ETextAlign textAlignmentForLine(bool endsWithSoftBreak) const;
498     virtual void adjustInlineDirectionLineBounds(int /* expansionOpportunityCount */, float& /* logicalLeft */, float& /* logicalWidth */) const { }
499
500     virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) OVERRIDE;
501
502     virtual void computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const OVERRIDE;
503     virtual void computePreferredLogicalWidths() OVERRIDE;
504     void adjustIntrinsicLogicalWidthsForColumns(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const;
505
506     virtual int firstLineBoxBaseline() const;
507     virtual int inlineBlockBaseline(LineDirectionMode) const OVERRIDE;
508     int lastLineBoxBaseline(LineDirectionMode) const;
509
510     // Delay update scrollbar until finishDelayRepaint() will be
511     // called. This function is used when a flexbox is laying out its
512     // descendant. If multiple calls are made to startDelayRepaint(),
513     // finishDelayRepaint() will do nothing until finishDelayRepaint()
514     // is called the same number of times.
515     static void startDelayUpdateScrollInfo();
516     static void finishDelayUpdateScrollInfo();
517
518     void updateScrollInfoAfterLayout();
519
520     virtual void styleWillChange(StyleDifference, const RenderStyle* newStyle);
521     virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle);
522
523     virtual bool hasLineIfEmpty() const;
524     
525     bool simplifiedLayout();
526     virtual void simplifiedNormalFlowLayout();
527
528     void setDesiredColumnCountAndWidth(int, LayoutUnit);
529
530 public:
531     void computeOverflow(LayoutUnit oldClientAfterEdge, bool recomputeFloats = false);
532     void clearLayoutOverflow();
533 protected:
534     virtual void addOverflowFromChildren();
535     void addOverflowFromFloats();
536     void addOverflowFromPositionedObjects();
537     void addOverflowFromBlockChildren();
538     void addOverflowFromInlineChildren();
539     void addVisualOverflowFromTheme();
540
541     virtual void addFocusRingRects(Vector<IntRect>&, const LayoutPoint& additionalOffset, const RenderLayerModelObject* paintContainer = 0) OVERRIDE;
542
543     bool updateShapesBeforeBlockLayout();
544     void updateShapesAfterBlockLayout(bool heightChanged = false);
545     void computeRegionRangeForBoxChild(const RenderBox*) const;
546
547     void estimateRegionRangeForBoxChild(const RenderBox*) const;
548     bool updateRegionRangeForBoxChild(const RenderBox*) const;
549
550     void updateBlockChildDirtyBitsBeforeLayout(bool relayoutChildren, RenderBox*);
551
552     virtual void checkForPaginationLogicalHeightChange(LayoutUnit& pageLogicalHeight, bool& pageLogicalHeightChanged, bool& hasSpecifiedPageLogicalHeight);
553
554 private:
555     LayoutUnit logicalRightFloatOffsetForLine(LayoutUnit logicalTop, LayoutUnit fixedOffset, LayoutUnit* heightRemaining, LayoutUnit logicalHeight, ShapeOutsideFloatOffsetMode) const;
556     LayoutUnit logicalLeftFloatOffsetForLine(LayoutUnit logicalTop, LayoutUnit fixedOffset, LayoutUnit* heightRemaining, LayoutUnit logicalHeight, ShapeOutsideFloatOffsetMode) const;
557     LayoutUnit adjustLogicalRightOffsetForLine(LayoutUnit offsetFromFloats, bool applyTextIndent) const;
558     LayoutUnit adjustLogicalLeftOffsetForLine(LayoutUnit offsetFromFloats, bool applyTextIndent) const;
559
560 #if ENABLE(CSS_SHAPES)
561     void computeShapeSize();
562     void updateShapeInsideInfoAfterStyleChange(const ShapeValue*, const ShapeValue* oldShape);
563     void relayoutShapeDescendantIfMoved(RenderBlock* child, LayoutSize offset);
564     LayoutSize logicalOffsetFromShapeAncestorContainer(const RenderBlock* container) const;
565 #endif
566
567     virtual const char* renderName() const OVERRIDE;
568
569     virtual bool isRenderBlock() const OVERRIDE FINAL { return true; }
570     virtual bool isInlineBlockOrInlineTable() const OVERRIDE FINAL { return isInline() && isReplaced(); }
571
572     void makeChildrenNonInline(RenderObject* insertionPoint = 0);
573     virtual void removeLeftoverAnonymousBlock(RenderBlock* child);
574
575     void moveAllChildrenIncludingFloatsTo(RenderBlock* toBlock, bool fullRemoveInsert);
576
577     virtual void dirtyLinesFromChangedChild(RenderObject* child) OVERRIDE FINAL { m_lineBoxes.dirtyLinesFromChangedChild(this, child); }
578
579     void addChildToContinuation(RenderObject* newChild, RenderObject* beforeChild);
580     void addChildIgnoringContinuation(RenderObject* newChild, RenderObject* beforeChild);
581     void addChildToAnonymousColumnBlocks(RenderObject* newChild, RenderObject* beforeChild);
582
583     void addChildIgnoringAnonymousColumnBlocks(RenderObject* newChild, RenderObject* beforeChild = 0);
584     
585     virtual bool isSelfCollapsingBlock() const OVERRIDE FINAL;
586
587     virtual void repaintOverhangingFloats(bool paintAllDescendants) OVERRIDE FINAL;
588
589     BidiRun* handleTrailingSpaces(BidiRunList<BidiRun>&, BidiContext*);
590
591     void insertIntoTrackedRendererMaps(RenderBox* descendant, TrackedDescendantsMap*&, TrackedContainerMap*&);
592     static void removeFromTrackedRendererMaps(RenderBox* descendant, TrackedDescendantsMap*&, TrackedContainerMap*&);
593
594     virtual RootInlineBox* createRootInlineBox(); // Subclassed by SVG and Ruby.
595
596     // Called to lay out the legend for a fieldset or the ruby text of a ruby run.
597     virtual RenderObject* layoutSpecialExcludedChild(bool /*relayoutChildren*/) { return 0; }
598
599     void createFirstLetterRenderer(RenderObject* firstLetterBlock, RenderText* currentTextChild);
600     void updateFirstLetterStyle(RenderObject* firstLetterBlock, RenderObject* firstLetterContainer);
601
602     Node* nodeForHitTest() const;
603
604     struct FloatWithRect {
605         FloatWithRect(RenderBox* f)
606             : object(f)
607             , rect(LayoutRect(f->x() - f->marginLeft(), f->y() - f->marginTop(), f->width() + f->marginWidth(), f->height() + f->marginHeight()))
608             , everHadLayout(f->everHadLayout())
609         {
610         }
611
612         RenderBox* object;
613         LayoutRect rect;
614         bool everHadLayout;
615     };
616
617     LayoutPoint flipFloatForWritingModeForChild(const FloatingObject*, const LayoutPoint&) const;
618
619     LayoutUnit xPositionForFloatIncludingMargin(const FloatingObject* child) const
620     {
621         if (isHorizontalWritingMode())
622             return child->x() + child->renderer()->marginLeft();
623         else
624             return child->x() + marginBeforeForChild(child->renderer());
625     }
626         
627     LayoutUnit yPositionForFloatIncludingMargin(const FloatingObject* child) const
628     {
629         if (isHorizontalWritingMode())
630             return child->y() + marginBeforeForChild(child->renderer());
631         else
632             return child->y() + child->renderer()->marginTop();
633     }
634
635     LayoutPoint computeLogicalLocationForFloat(const FloatingObject*, LayoutUnit logicalTopOffset) const;
636
637     // The following functions' implementations are in RenderBlockLineLayout.cpp.
638     struct RenderTextInfo {
639         // Destruction of m_layout requires TextLayout to be a complete type, so the constructor and destructor are made non-inline to avoid compilation errors.
640         RenderTextInfo();
641         ~RenderTextInfo();
642
643         RenderText* m_text;
644         OwnPtr<TextLayout> m_layout;
645         LazyLineBreakIterator m_lineBreakIterator;
646         const Font* m_font;
647     };
648
649     class LineBreaker {
650     public:
651         LineBreaker(RenderBlock* block)
652             : m_block(block)
653         {
654             reset();
655         }
656
657         InlineIterator nextLineBreak(InlineBidiResolver&, LineInfo&, RenderTextInfo&, FloatingObject* lastFloatFromPreviousLine, unsigned consecutiveHyphenatedLines, WordMeasurements&);
658
659         bool lineWasHyphenated() { return m_hyphenated; }
660         const Vector<RenderBox*>& positionedObjects() { return m_positionedObjects; }
661         EClear clear() { return m_clear; }
662     private:
663         void reset();
664         
665         InlineIterator nextSegmentBreak(InlineBidiResolver&, LineInfo&, RenderTextInfo&, FloatingObject* lastFloatFromPreviousLine, unsigned consecutiveHyphenatedLines, WordMeasurements&);
666         void skipTrailingWhitespace(InlineIterator&, const LineInfo&);
667         void skipLeadingWhitespace(InlineBidiResolver&, LineInfo&, FloatingObject* lastFloatFromPreviousLine, LineWidth&);
668         
669         RenderBlock* m_block;
670         bool m_hyphenated;
671         EClear m_clear;
672         Vector<RenderBox*> m_positionedObjects;
673     };
674
675     void checkFloatsInCleanLine(RootInlineBox*, Vector<FloatWithRect>&, size_t& floatIndex, bool& encounteredNewFloat, bool& dirtiedByFloat);
676     RootInlineBox* determineStartPosition(LineLayoutState&, InlineBidiResolver&);
677     void determineEndPosition(LineLayoutState&, RootInlineBox* startBox, InlineIterator& cleanLineStart, BidiStatus& cleanLineBidiStatus);
678     bool matchedEndLine(LineLayoutState&, const InlineBidiResolver&, const InlineIterator& endLineStart, const BidiStatus& endLineStatus);
679     bool checkPaginationAndFloatsAtEndLine(LineLayoutState&);
680     
681     RootInlineBox* constructLine(BidiRunList<BidiRun>&, const LineInfo&);
682     InlineFlowBox* createLineBoxes(RenderObject*, const LineInfo&, InlineBox* childBox, bool startsNewSegment);
683
684     void setMarginsForRubyRun(BidiRun*, RenderRubyRun*, RenderObject*, const LineInfo&);
685
686     BidiRun* computeInlineDirectionPositionsForSegment(RootInlineBox*, const LineInfo&, ETextAlign, float& logicalLeft,
687         float& availableLogicalWidth, BidiRun* firstRun, BidiRun* trailingSpaceRun, GlyphOverflowAndFallbackFontsMap& textBoxDataMap, VerticalPositionCache&, WordMeasurements&);
688     void computeInlineDirectionPositionsForLine(RootInlineBox*, const LineInfo&, BidiRun* firstRun, BidiRun* trailingSpaceRun, bool reachedEnd, GlyphOverflowAndFallbackFontsMap&, VerticalPositionCache&, WordMeasurements&);
689     void computeBlockDirectionPositionsForLine(RootInlineBox*, BidiRun*, GlyphOverflowAndFallbackFontsMap&, VerticalPositionCache&);
690     void deleteEllipsisLineBoxes();
691     void checkLinesForTextOverflow();
692
693     // Positions new floats and also adjust all floats encountered on the line if any of them
694     // have to move to the next page/column.
695     bool positionNewFloatOnLine(FloatingObject* newFloat, FloatingObject* lastFloatFromPreviousLine, LineInfo&, LineWidth&);
696     void appendFloatingObjectToLastLine(FloatingObject*);
697
698     // End of functions defined in RenderBlockLineLayout.cpp.
699
700     void paintFloats(PaintInfo&, const LayoutPoint&, bool preservePhase = false);
701     void paintContents(PaintInfo&, const LayoutPoint&);
702     void paintColumnContents(PaintInfo&, const LayoutPoint&, bool paintFloats = false);
703     void paintColumnRules(PaintInfo&, const LayoutPoint&);
704     void paintSelection(PaintInfo&, const LayoutPoint&);
705     void paintCaret(PaintInfo&, const LayoutPoint&, CaretType);
706
707     FloatingObject* insertFloatingObject(RenderBox*);
708     void removeFloatingObject(RenderBox*);
709     void removeFloatingObjectsBelow(FloatingObject*, int logicalOffset);
710     
711     // Called from lineWidth, to position the floats added in the last line.
712     // Returns true if and only if it has positioned any floats.
713     bool positionNewFloats();
714
715     LayoutUnit getClearDelta(RenderBox* child, LayoutUnit yPos);
716
717     virtual bool avoidsFloats() const;
718
719     bool hasOverhangingFloats() { return parent() && !hasColumns() && containsFloats() && lowestFloatLogicalBottom() > logicalHeight(); }
720     bool hasOverhangingFloat(RenderBox*);
721     void addIntrudingFloats(RenderBlock* prev, LayoutUnit xoffset, LayoutUnit yoffset);
722     LayoutUnit addOverhangingFloats(RenderBlock* child, bool makeChildPaintOtherFloats);
723
724     LayoutUnit lowestFloatLogicalBottom(FloatingObject::Type = FloatingObject::FloatLeftRight) const; 
725     LayoutUnit nextFloatLogicalBottomBelow(LayoutUnit) const;
726
727     void updateLocalFloatingObjectsForPaintingContainer(RenderBox* floatToUpdate, bool& didFindPaintContainer);
728     void updateFloatingObjectsPaintingContainer(RenderBox* floatToUpdate, bool& didFindPaintContainer);
729     void updateAllDescendantsFloatingObjectsPaintingContainer(RenderBox* floatToUpdate, bool& didFindPaintContainer);
730
731     
732     bool hitTestColumns(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction);
733     virtual bool hitTestContents(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction);
734     bool hitTestFloats(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset);
735
736     virtual bool isPointInOverflowControl(HitTestResult&, const LayoutPoint& locationInContainer, const LayoutPoint& accumulatedOffset);
737
738     // FIXME: Make this method const so we can remove the const_cast in computeIntrinsicLogicalWidths.
739     void computeInlinePreferredLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth);
740     void computeBlockPreferredLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const;
741
742     // Obtains the nearest enclosing block (including this block) that contributes a first-line style to our inline
743     // children.
744     virtual RenderBlock* firstLineBlock() const OVERRIDE;
745
746     virtual LayoutRect rectWithOutlineForRepaint(const RenderLayerModelObject* repaintContainer, LayoutUnit outlineWidth) const OVERRIDE FINAL;
747     virtual RenderStyle* outlineStyleForRepaint() const OVERRIDE FINAL;
748     
749     virtual RenderObject* hoverAncestor() const OVERRIDE FINAL;
750     virtual void updateDragState(bool dragOn) OVERRIDE FINAL;
751     virtual void childBecameNonInline(RenderObject* child) OVERRIDE FINAL;
752
753     virtual LayoutRect selectionRectForRepaint(const RenderLayerModelObject* repaintContainer, bool /*clipToVisibleContent*/) OVERRIDE FINAL
754     {
755         return selectionGapRectsForRepaint(repaintContainer);
756     }
757     virtual bool shouldPaintSelectionGaps() const OVERRIDE FINAL;
758     bool isSelectionRoot() const;
759     GapRects selectionGaps(RenderBlock* rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
760         LayoutUnit& lastLogicalTop, LayoutUnit& lastLogicalLeft, LayoutUnit& lastLogicalRight, const LogicalSelectionOffsetCaches&, const PaintInfo* = 0);
761     GapRects inlineSelectionGaps(RenderBlock* rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
762         LayoutUnit& lastLogicalTop, LayoutUnit& lastLogicalLeft, LayoutUnit& lastLogicalRight, const LogicalSelectionOffsetCaches&, const PaintInfo*);
763     GapRects blockSelectionGaps(RenderBlock* rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
764         LayoutUnit& lastLogicalTop, LayoutUnit& lastLogicalLeft, LayoutUnit& lastLogicalRight, const LogicalSelectionOffsetCaches&, const PaintInfo*);
765     LayoutRect blockSelectionGap(RenderBlock* rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
766         LayoutUnit lastLogicalTop, LayoutUnit lastLogicalLeft, LayoutUnit lastLogicalRight, LayoutUnit logicalBottom, const LogicalSelectionOffsetCaches&, const PaintInfo*);
767     LayoutUnit logicalLeftSelectionOffset(RenderBlock* rootBlock, LayoutUnit position, const LogicalSelectionOffsetCaches&);
768     LayoutUnit logicalRightSelectionOffset(RenderBlock* rootBlock, LayoutUnit position, const LogicalSelectionOffsetCaches&);
769     
770     friend class LogicalSelectionOffsetCaches;
771
772     virtual void absoluteRects(Vector<IntRect>&, const LayoutPoint& accumulatedOffset) const OVERRIDE;
773     virtual void absoluteQuads(Vector<FloatQuad>&, bool* wasFixed) const OVERRIDE;
774
775     LayoutUnit desiredColumnWidth() const;
776     unsigned desiredColumnCount() const;
777
778     void paintContinuationOutlines(PaintInfo&, const LayoutPoint&);
779
780     virtual LayoutRect localCaretRect(InlineBox*, int caretOffset, LayoutUnit* extraWidthToEndOfLine = 0) OVERRIDE FINAL;
781
782     void adjustPointToColumnContents(LayoutPoint&) const;
783     
784     void fitBorderToLinesIfNeeded(); // Shrink the box in which the border paints if border-fit is set.
785     void adjustForBorderFit(LayoutUnit x, LayoutUnit& left, LayoutUnit& right) const; // Helper function for borderFitAdjust
786
787     void markLinesDirtyInBlockRange(LayoutUnit logicalTop, LayoutUnit logicalBottom, RootInlineBox* highest = 0);
788
789     void newLine(EClear);
790
791     Position positionForBox(InlineBox*, bool start = true) const;
792     VisiblePosition positionForPointWithInlineChildren(const LayoutPoint&);
793
794     virtual void calcColumnWidth();
795     void makeChildrenAnonymousColumnBlocks(RenderObject* beforeChild, RenderBlock* newBlockBox, RenderObject* newChild);
796
797     bool expandsToEncloseOverhangingFloats() const;
798
799     void splitBlocks(RenderBlock* fromBlock, RenderBlock* toBlock, RenderBlock* middleBlock,
800                      RenderObject* beforeChild, RenderBoxModelObject* oldCont);
801     void splitFlow(RenderObject* beforeChild, RenderBlock* newBlockBox,
802                    RenderObject* newChild, RenderBoxModelObject* oldCont);
803     RenderBlock* clone() const;
804     RenderBlock* continuationBefore(RenderObject* beforeChild);
805     RenderBlock* containingColumnsBlock(bool allowAnonymousColumnBlock = true);
806     RenderBlock* columnsBlockForSpanningElement(RenderObject* newChild);
807
808     RenderBoxModelObject* createReplacementRunIn(RenderBoxModelObject* runIn);
809     void moveRunInUnderSiblingBlockIfNeeded(RenderObject* runIn);
810     void moveRunInToOriginalPosition(RenderObject* runIn);
811
812     // Helper function for layoutInlineChildren()
813     RootInlineBox* createLineBoxesFromBidiRuns(BidiRunList<BidiRun>&, const InlineIterator& end, LineInfo&, VerticalPositionCache&, BidiRun* trailingSpaceRun, WordMeasurements&);
814     void layoutRunsAndFloats(LineLayoutState&, bool hasInlineChild);
815     void layoutRunsAndFloatsInRange(LineLayoutState&, InlineBidiResolver&, const InlineIterator& cleanLineStart, const BidiStatus& cleanLineBidiStatus, unsigned consecutiveHyphenatedLines);
816 #if ENABLE(CSS_SHAPES)
817     void updateShapeAndSegmentsForCurrentLine(ShapeInsideInfo*&, const LayoutSize&, LineLayoutState&);
818     void updateShapeAndSegmentsForCurrentLineInFlowThread(ShapeInsideInfo*&, LineLayoutState&);
819     bool adjustLogicalLineTopAndLogicalHeightIfNeeded(ShapeInsideInfo*, LayoutUnit, LineLayoutState&, InlineBidiResolver&, FloatingObject*, InlineIterator&, WordMeasurements&);
820 #endif
821     const InlineIterator& restartLayoutRunsAndFloatsInRange(LayoutUnit oldLogicalHeight, LayoutUnit newLogicalHeight,  FloatingObject* lastFloatFromPreviousLine, InlineBidiResolver&,  const InlineIterator&);
822     void linkToEndLineIfNeeded(LineLayoutState&);
823     static void repaintDirtyFloats(Vector<FloatWithRect>& floats);
824
825 protected:
826     void dirtyForLayoutFromPercentageHeightDescendants();
827     
828     void determineLogicalLeftPositionForChild(RenderBox* child, ApplyLayoutDeltaMode = DoNotApplyLayoutDelta);
829
830     // Pagination routines.
831     virtual bool relayoutForPagination(bool hasSpecifiedPageLogicalHeight, LayoutUnit pageLogicalHeight, LayoutStateMaintainer&);
832     
833     // Returns the logicalOffset at the top of the next page. If the offset passed in is already at the top of the current page,
834     // then nextPageLogicalTop with ExcludePageBoundary will still move to the top of the next page. nextPageLogicalTop with
835     // IncludePageBoundary set will not.
836     //
837     // For a page height of 800px, the first rule will return 800 if the value passed in is 0. The second rule will simply return 0.
838     enum PageBoundaryRule { ExcludePageBoundary, IncludePageBoundary };
839     LayoutUnit nextPageLogicalTop(LayoutUnit logicalOffset, PageBoundaryRule = ExcludePageBoundary) const;
840     bool hasNextPage(LayoutUnit logicalOffset, PageBoundaryRule = ExcludePageBoundary) const;
841
842     virtual ColumnInfo::PaginationUnit paginationUnit() const;
843
844 public:
845     LayoutUnit pageLogicalTopForOffset(LayoutUnit offset) const;
846     LayoutUnit pageLogicalHeightForOffset(LayoutUnit offset) const;
847     LayoutUnit pageRemainingLogicalHeightForOffset(LayoutUnit offset, PageBoundaryRule = IncludePageBoundary) const;
848     
849 protected:
850     bool pushToNextPageWithMinimumLogicalHeight(LayoutUnit& adjustment, LayoutUnit logicalOffset, LayoutUnit minimumLogicalHeight) const;
851
852     // A page break is required at some offset due to space shortage in the current fragmentainer.
853     void setPageBreak(LayoutUnit offset, LayoutUnit spaceShortage);
854
855     // Update minimum page height required to avoid fragmentation where it shouldn't occur (inside
856     // unbreakable content, between orphans and widows, etc.). This will be used as a hint to the
857     // column balancer to help set a good minimum column height.
858     void updateMinimumPageHeight(LayoutUnit offset, LayoutUnit minHeight);
859
860     LayoutUnit adjustForUnsplittableChild(RenderBox* child, LayoutUnit logicalOffset, bool includeMargins = false); // If the child is unsplittable and can't fit on the current page, return the top of the next page/column.
861
862     // Adjust from painting offsets to the local coords of this renderer
863     void offsetForContents(LayoutPoint&) const;
864
865     // This function is called to test a line box that has moved in the block direction to see if it has ended up in a new
866     // region/page/column that has a different available line width than the old one. Used to know when you have to dirty a
867     // line, i.e., that it can't be re-used.
868     bool lineWidthForPaginatedLineChanged(RootInlineBox*, LayoutUnit lineDelta, RenderFlowThread*) const;
869
870     bool logicalWidthChangedInRegions(RenderFlowThread*) const;
871
872     virtual bool requiresColumns(int desiredColumnCount) const;
873
874     virtual bool updateLogicalWidthAndColumnWidth();
875
876     virtual bool canCollapseAnonymousBlockChild() const { return true; }
877
878 public:
879     virtual LayoutUnit offsetFromLogicalTopOfFirstPage() const OVERRIDE;
880     RenderRegion* regionAtBlockOffset(LayoutUnit) const;
881
882     // 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
883     // RenderBlock yet.
884     friend class RenderBlockFlow;
885
886 protected:
887     void createFloatingObjects();
888
889 public:
890     // Allocated only when some of these fields have non-default values
891     struct RenderBlockRareData {
892         WTF_MAKE_NONCOPYABLE(RenderBlockRareData); WTF_MAKE_FAST_ALLOCATED;
893     public:
894         RenderBlockRareData() 
895             : m_paginationStrut(0)
896             , m_pageLogicalOffset(0)
897             , m_lineGridBox(0)
898         { 
899         }
900
901         LayoutUnit m_paginationStrut;
902         LayoutUnit m_pageLogicalOffset;
903         
904         RootInlineBox* m_lineGridBox;
905
906 #if ENABLE(CSS_SHAPES)
907         OwnPtr<ShapeInsideInfo> m_shapeInsideInfo;
908 #endif
909      };
910
911 protected:
912
913     OwnPtr<FloatingObjects> m_floatingObjects;
914     OwnPtr<RenderBlockRareData> m_rareData;
915
916     RenderObjectChildList m_children;
917     RenderLineBoxList m_lineBoxes;   // All of the root line boxes created for this block flow.  For example, <div>Hello<br>world.</div> will have two total lines for the <div>.
918
919     mutable signed m_lineHeight : 27;
920     unsigned m_hasMarginBeforeQuirk : 1; // Note these quirk values can't be put in RenderBlockRareData since they are set too frequently.
921     unsigned m_hasMarginAfterQuirk : 1;
922     unsigned m_beingDestroyed : 1;
923     unsigned m_hasMarkupTruncation : 1;
924     unsigned m_hasBorderOrPaddingLogicalWidthChanged : 1;
925
926 #if ENABLE(IOS_TEXT_AUTOSIZING)
927     int m_widthForTextAutosizing;
928     unsigned m_lineCountForTextAutosizing : 2;
929 #endif
930     
931     // RenderRubyBase objects need to be able to split and merge, moving their children around
932     // (calling moveChildTo, moveAllChildrenTo, and makeChildrenNonInline).
933     friend class RenderRubyBase;
934     friend class LineWidth; // Needs to know FloatingObject
935
936 private:
937     // Used to store state between styleWillChange and styleDidChange
938     static bool s_canPropagateFloatIntoSibling;
939 };
940
941 inline RenderBlock& toRenderBlock(RenderObject& object)
942 {
943     ASSERT_WITH_SECURITY_IMPLICATION(object.isRenderBlock());
944     return static_cast<RenderBlock&>(object);
945 }
946
947 inline const RenderBlock& toRenderBlock(const RenderObject& object)
948 {
949     ASSERT_WITH_SECURITY_IMPLICATION(object.isRenderBlock());
950     return static_cast<const RenderBlock&>(object);
951 }
952
953 inline RenderBlock* toRenderBlock(RenderObject* object)
954
955     ASSERT_WITH_SECURITY_IMPLICATION(!object || object->isRenderBlock());
956     return static_cast<RenderBlock*>(object);
957 }
958
959 inline const RenderBlock* toRenderBlock(const RenderObject* object)
960
961     ASSERT_WITH_SECURITY_IMPLICATION(!object || object->isRenderBlock());
962     return static_cast<const RenderBlock*>(object);
963 }
964
965 // This will catch anyone doing an unnecessary cast.
966 void toRenderBlock(const RenderBlock*);
967 void toRenderBlock(const RenderBlock&);
968
969 } // namespace WebCore
970
971 #endif // RenderBlock_h