Finish making FloatingObject a real class with private members
[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 "PODIntervalTree.h"
29 #include "RenderBox.h"
30 #include "RenderLineBoxList.h"
31 #include "RootInlineBox.h"
32 #include "TextBreakIterator.h"
33 #include "TextRun.h"
34 #include <wtf/OwnPtr.h>
35 #include <wtf/ListHashSet.h>
36
37 #if ENABLE(CSS_SHAPES)
38 #include "ShapeInsideInfo.h"
39 #include "ShapeValue.h"
40 #endif
41
42 namespace WebCore {
43
44 class BidiContext;
45 class InlineIterator;
46 class LayoutStateMaintainer;
47 class LineLayoutState;
48 class LineWidth;
49 class LogicalSelectionOffsetCaches;
50 class RenderInline;
51 class RenderText;
52
53 struct BidiRun;
54 struct PaintInfo;
55 class LineInfo;
56 class RenderRubyRun;
57 #if ENABLE(CSS_SHAPES)
58 class BasicShape;
59 #endif
60 class TextLayout;
61 class WordMeasurement;
62
63 template <class Iterator, class Run> class BidiResolver;
64 template <class Run> class BidiRunList;
65 template <class Iterator> struct MidpointState;
66 typedef BidiResolver<InlineIterator, BidiRun> InlineBidiResolver;
67 typedef MidpointState<InlineIterator> LineMidpointState;
68 typedef WTF::ListHashSet<RenderBox*, 16> TrackedRendererListHashSet;
69 typedef WTF::HashMap<const RenderBlock*, OwnPtr<TrackedRendererListHashSet> > TrackedDescendantsMap;
70 typedef WTF::HashMap<const RenderBox*, OwnPtr<HashSet<RenderBlock*> > > TrackedContainerMap;
71 typedef Vector<WordMeasurement, 64> WordMeasurements;
72
73 enum CaretType { CursorCaret, DragCaret };
74 enum ContainingBlockState { NewContainingBlock, SameContainingBlock };
75
76 enum TextRunFlag {
77     DefaultTextRunFlags = 0,
78     RespectDirection = 1 << 0,
79     RespectDirectionOverride = 1 << 1
80 };
81
82 typedef unsigned TextRunFlags;
83
84 class RenderBlock : public RenderBox {
85 public:
86     friend class LineLayoutState;
87 #ifndef NDEBUG
88     // Used by the PODIntervalTree for debugging the FloatingObject.
89     template <class> friend struct ValueToString;
90 #endif
91
92     explicit RenderBlock(ContainerNode*);
93     virtual ~RenderBlock();
94
95     static RenderBlock* createAnonymous(Document*);
96
97     RenderObject* firstChild() const { ASSERT(children() == virtualChildren()); return children()->firstChild(); }
98     RenderObject* lastChild() const { ASSERT(children() == virtualChildren()); return children()->lastChild(); }
99
100     const RenderObjectChildList* children() const { return &m_children; }
101     RenderObjectChildList* children() { return &m_children; }
102
103     bool beingDestroyed() const { return m_beingDestroyed; }
104
105     // These two functions are overridden for inline-block.
106     virtual LayoutUnit lineHeight(bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const OVERRIDE FINAL;
107     virtual int baselinePosition(FontBaseline, bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const;
108
109     RenderLineBoxList* lineBoxes() { return &m_lineBoxes; }
110     const RenderLineBoxList* lineBoxes() const { return &m_lineBoxes; }
111
112     InlineFlowBox* firstLineBox() const { return m_lineBoxes.firstLineBox(); }
113     InlineFlowBox* lastLineBox() const { return m_lineBoxes.lastLineBox(); }
114
115     void deleteLineBoxTree();
116
117     virtual void addChild(RenderObject* newChild, RenderObject* beforeChild = 0);
118     virtual void removeChild(RenderObject*);
119
120     virtual void layoutBlock(bool relayoutChildren, LayoutUnit pageLogicalHeight = 0);
121
122     void insertPositionedObject(RenderBox*);
123     static void removePositionedObject(RenderBox*);
124     void removePositionedObjects(RenderBlock*, ContainingBlockState = SameContainingBlock);
125
126     void removeFloatingObjects();
127
128     TrackedRendererListHashSet* positionedObjects() const;
129     bool hasPositionedObjects() const
130     {
131         TrackedRendererListHashSet* objects = positionedObjects();
132         return objects && !objects->isEmpty();
133     }
134
135     void addPercentHeightDescendant(RenderBox*);
136     static void removePercentHeightDescendant(RenderBox*);
137     TrackedRendererListHashSet* percentHeightDescendants() const;
138     static bool hasPercentHeightContainerMap();
139     static bool hasPercentHeightDescendant(RenderBox*);
140     static void clearPercentHeightDescendantsFrom(RenderBox*);
141     static void removePercentHeightDescendantIfNeeded(RenderBox*);
142
143     void setHasMarkupTruncation(bool b) { m_hasMarkupTruncation = b; }
144     bool hasMarkupTruncation() const { return m_hasMarkupTruncation; }
145
146     void setHasMarginBeforeQuirk(bool b) { m_hasMarginBeforeQuirk = b; }
147     void setHasMarginAfterQuirk(bool b) { m_hasMarginAfterQuirk = b; }
148
149     bool hasMarginBeforeQuirk() const { return m_hasMarginBeforeQuirk; }
150     bool hasMarginAfterQuirk() const { return m_hasMarginAfterQuirk; }
151
152     bool hasMarginBeforeQuirk(const RenderBox* child) const;
153     bool hasMarginAfterQuirk(const RenderBox* child) const;
154
155     RootInlineBox* createAndAppendRootInlineBox();
156
157     bool generatesLineBoxesForInlineChild(RenderObject*);
158
159     void markAllDescendantsWithFloatsForLayout(RenderBox* floatToRemove = 0, bool inLayout = true);
160     void markSiblingsWithFloatsForLayout(RenderBox* floatToRemove = 0);
161     void markPositionedObjectsForLayout();
162     virtual void markForPaginationRelayoutIfNeeded() OVERRIDE FINAL;
163     
164     bool containsFloats() const { return m_floatingObjects && !m_floatingObjects->set().isEmpty(); }
165     bool containsFloat(RenderBox*) const;
166
167     // Versions that can compute line offsets with the region and page offset passed in. Used for speed to avoid having to
168     // compute the region all over again when you already know it.
169     LayoutUnit availableLogicalWidthForLine(LayoutUnit position, bool shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const
170     {
171         return max<LayoutUnit>(0, logicalRightOffsetForLine(position, shouldIndentText, region, logicalHeight)
172             - logicalLeftOffsetForLine(position, shouldIndentText, region, logicalHeight));
173     }
174     LayoutUnit logicalRightOffsetForLine(LayoutUnit position, bool shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const 
175     {
176         return logicalRightOffsetForLine(position, logicalRightOffsetForContent(region), shouldIndentText, 0, logicalHeight);
177     }
178     LayoutUnit logicalLeftOffsetForLine(LayoutUnit position, bool shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const 
179     {
180         return logicalLeftOffsetForLine(position, logicalLeftOffsetForContent(region), shouldIndentText, 0, logicalHeight);
181     }
182     LayoutUnit startOffsetForLine(LayoutUnit position, bool shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const
183     {
184         return style()->isLeftToRightDirection() ? logicalLeftOffsetForLine(position, shouldIndentText, region, logicalHeight)
185             : logicalWidth() - logicalRightOffsetForLine(position, shouldIndentText, region, logicalHeight);
186     }
187     LayoutUnit endOffsetForLine(LayoutUnit position, bool shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const
188     {
189         return !style()->isLeftToRightDirection() ? logicalLeftOffsetForLine(position, shouldIndentText, region, logicalHeight)
190             : logicalWidth() - logicalRightOffsetForLine(position, shouldIndentText, region, logicalHeight);
191     }
192
193     LayoutUnit availableLogicalWidthForLine(LayoutUnit position, bool shouldIndentText, LayoutUnit logicalHeight = 0) const
194     {
195         return availableLogicalWidthForLine(position, shouldIndentText, regionAtBlockOffset(position), logicalHeight);
196     }
197     LayoutUnit logicalRightOffsetForLine(LayoutUnit position, bool shouldIndentText, LayoutUnit logicalHeight = 0) const 
198     {
199         return logicalRightOffsetForLine(position, logicalRightOffsetForContent(position), shouldIndentText, 0, logicalHeight);
200     }
201     LayoutUnit logicalLeftOffsetForLine(LayoutUnit position, bool shouldIndentText, LayoutUnit logicalHeight = 0) const 
202     {
203         return logicalLeftOffsetForLine(position, logicalLeftOffsetForContent(position), shouldIndentText, 0, logicalHeight);
204     }
205     LayoutUnit pixelSnappedLogicalLeftOffsetForLine(LayoutUnit position, bool shouldIndentText, LayoutUnit logicalHeight = 0) const 
206     {
207         return roundToInt(logicalLeftOffsetForLine(position, shouldIndentText, logicalHeight));
208     }
209     LayoutUnit pixelSnappedLogicalRightOffsetForLine(LayoutUnit position, bool shouldIndentText, LayoutUnit logicalHeight = 0) const 
210     {
211         // FIXME: Multicolumn layouts break carrying over subpixel values to the logical right offset because the lines may be shifted
212         // by a subpixel value for all but the first column. This can lead to the actual pixel snapped width of the column being off
213         // by one pixel when rendered versus layed out, which can result in the line being clipped. For now, we have to floor.
214         // https://bugs.webkit.org/show_bug.cgi?id=105461
215         return floorToInt(logicalRightOffsetForLine(position, shouldIndentText, logicalHeight));
216     }
217     LayoutUnit startOffsetForLine(LayoutUnit position, bool shouldIndentText, LayoutUnit logicalHeight = 0) const
218     {
219         return style()->isLeftToRightDirection() ? logicalLeftOffsetForLine(position, shouldIndentText, logicalHeight)
220             : logicalWidth() - logicalRightOffsetForLine(position, shouldIndentText, logicalHeight);
221     }
222     LayoutUnit endOffsetForLine(LayoutUnit position, bool shouldIndentText, LayoutUnit logicalHeight = 0) const
223     {
224         return !style()->isLeftToRightDirection() ? logicalLeftOffsetForLine(position, shouldIndentText, logicalHeight)
225             : logicalWidth() - logicalRightOffsetForLine(position, shouldIndentText, logicalHeight);
226     }
227
228     LayoutUnit startAlignedOffsetForLine(LayoutUnit position, bool shouldIndentText);
229     LayoutUnit textIndentOffset() const;
230
231     virtual VisiblePosition positionForPoint(const LayoutPoint&);
232     
233     // Block flows subclass availableWidth to handle multi column layout (shrinking the width available to children when laying out.)
234     virtual LayoutUnit availableLogicalWidth() const OVERRIDE FINAL;
235
236     LayoutPoint flipForWritingModeIncludingColumns(const LayoutPoint&) const;
237     void adjustStartEdgeForWritingModeIncludingColumns(LayoutRect&) const;
238
239     RootInlineBox* firstRootBox() const { return static_cast<RootInlineBox*>(firstLineBox()); }
240     RootInlineBox* lastRootBox() const { return static_cast<RootInlineBox*>(lastLineBox()); }
241
242     bool containsNonZeroBidiLevel() const;
243
244     GapRects selectionGapRectsForRepaint(const RenderLayerModelObject* repaintContainer);
245     LayoutRect logicalLeftSelectionGap(RenderBlock* rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
246         RenderObject* selObj, LayoutUnit logicalLeft, LayoutUnit logicalTop, LayoutUnit logicalHeight, const LogicalSelectionOffsetCaches&, const PaintInfo*);
247     LayoutRect logicalRightSelectionGap(RenderBlock* rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
248         RenderObject* selObj, LayoutUnit logicalRight, LayoutUnit logicalTop, LayoutUnit logicalHeight, const LogicalSelectionOffsetCaches&, const PaintInfo*);
249     void getSelectionGapInfo(SelectionState, bool& leftGap, bool& rightGap);
250     RenderBlock* blockBeforeWithinSelectionRoot(LayoutSize& offset) const;
251
252     LayoutRect logicalRectToPhysicalRect(const LayoutPoint& physicalPosition, const LayoutRect& logicalRect);
253
254     // Helper methods for computing line counts and heights for line counts.
255     RootInlineBox* lineAtIndex(int) const;
256     int lineCount(const RootInlineBox* = 0, bool* = 0) const;
257     int heightForLineCount(int);
258     void clearTruncation();
259
260     void adjustRectForColumns(LayoutRect&) const;
261     virtual void adjustForColumns(LayoutSize&, const LayoutPoint&) const OVERRIDE FINAL;
262     void adjustForColumnRect(LayoutSize& offset, const LayoutPoint& locationInContainer) const;
263
264     void addContinuationWithOutline(RenderInline*);
265     bool paintsContinuationOutline(RenderInline*);
266
267     virtual RenderBoxModelObject* virtualContinuation() const OVERRIDE FINAL { return continuation(); }
268     bool isAnonymousBlockContinuation() const { return continuation() && isAnonymousBlock(); }
269     RenderInline* inlineElementContinuation() const;
270     RenderBlock* blockElementContinuation() const;
271
272     using RenderBoxModelObject::continuation;
273     using RenderBoxModelObject::setContinuation;
274
275     static RenderBlock* createAnonymousWithParentRendererAndDisplay(const RenderObject*, EDisplay = BLOCK);
276     static RenderBlock* createAnonymousColumnsWithParentRenderer(const RenderObject*);
277     static RenderBlock* createAnonymousColumnSpanWithParentRenderer(const RenderObject*);
278     RenderBlock* createAnonymousBlock(EDisplay display = BLOCK) const { return createAnonymousWithParentRendererAndDisplay(this, display); }
279     RenderBlock* createAnonymousColumnsBlock() const { return createAnonymousColumnsWithParentRenderer(this); }
280     RenderBlock* createAnonymousColumnSpanBlock() const { return createAnonymousColumnSpanWithParentRenderer(this); }
281     static void collapseAnonymousBoxChild(RenderBlock* parent, RenderObject* child);
282
283     virtual RenderBox* createAnonymousBoxWithSameTypeAs(const RenderObject* parent) const OVERRIDE;
284
285     static bool shouldSkipCreatingRunsForObject(RenderObject* obj)
286     {
287         return obj->isFloating() || (obj->isOutOfFlowPositioned() && !obj->style()->isOriginalDisplayInlineType() && !obj->container()->isRenderInline());
288     }
289     
290     static void appendRunsForObject(BidiRunList<BidiRun>&, int start, int end, RenderObject*, InlineBidiResolver&);
291
292     static TextRun constructTextRun(RenderObject* context, const Font& font, const String& string, RenderStyle* style,
293         TextRun::ExpansionBehavior = TextRun::AllowTrailingExpansion | TextRun::ForbidLeadingExpansion, TextRunFlags = DefaultTextRunFlags);
294
295     static TextRun constructTextRun(RenderObject* context, const Font& font, const RenderText* text, RenderStyle* style,
296         TextRun::ExpansionBehavior = TextRun::AllowTrailingExpansion | TextRun::ForbidLeadingExpansion);
297
298     static TextRun constructTextRun(RenderObject* context, const Font& font, const RenderText* text, unsigned offset, unsigned length, RenderStyle* style,
299         TextRun::ExpansionBehavior = TextRun::AllowTrailingExpansion | TextRun::ForbidLeadingExpansion);
300
301     static TextRun constructTextRun(RenderObject* context, const Font& font, const RenderText* text, unsigned offset, RenderStyle* style,
302         TextRun::ExpansionBehavior = TextRun::AllowTrailingExpansion | TextRun::ForbidLeadingExpansion);
303
304 #if ENABLE(8BIT_TEXTRUN)
305     static TextRun constructTextRun(RenderObject* context, const Font& font, const LChar* characters, int length, RenderStyle* style,
306         TextRun::ExpansionBehavior = TextRun::AllowTrailingExpansion | TextRun::ForbidLeadingExpansion);
307 #endif
308
309     static TextRun constructTextRun(RenderObject* context, const Font& font, const UChar* characters, int length, RenderStyle* style,
310         TextRun::ExpansionBehavior = TextRun::AllowTrailingExpansion | TextRun::ForbidLeadingExpansion);
311
312     ColumnInfo* columnInfo() const;
313     int columnGap() const;
314
315     void updateColumnInfoFromStyle(RenderStyle*);
316     
317     LayoutUnit initialBlockOffsetForPainting() const;
318     LayoutUnit blockDeltaForPaintingNextColumn() const;
319
320     // These two functions take the ColumnInfo* to avoid repeated lookups of the info in the global HashMap.
321     unsigned columnCount(ColumnInfo*) const;
322     LayoutRect columnRectAt(ColumnInfo*, unsigned) const;
323
324     LayoutUnit paginationStrut() const { return m_rareData ? m_rareData->m_paginationStrut : LayoutUnit(); }
325     void setPaginationStrut(LayoutUnit);
326
327     bool shouldBreakAtLineToAvoidWidow() const { return m_rareData && m_rareData->m_shouldBreakAtLineToAvoidWidow; }
328     void clearShouldBreakAtLineToAvoidWidow() const;
329     int lineBreakToAvoidWidow() const { return m_rareData ? m_rareData->m_lineBreakToAvoidWidow : -1; }
330     void setBreakAtLineToAvoidWidow(int);
331
332     // The page logical offset is the object's offset from the top of the page in the page progression
333     // direction (so an x-offset in vertical text and a y-offset for horizontal text).
334     LayoutUnit pageLogicalOffset() const { return m_rareData ? m_rareData->m_pageLogicalOffset : LayoutUnit(); }
335     void setPageLogicalOffset(LayoutUnit);
336
337     RootInlineBox* lineGridBox() const { return m_rareData ? m_rareData->m_lineGridBox : 0; }
338     void setLineGridBox(RootInlineBox* box)
339     {
340         if (!m_rareData)
341             m_rareData = adoptPtr(new RenderBlockRareData(this));
342         if (m_rareData->m_lineGridBox)
343             m_rareData->m_lineGridBox->destroy(renderArena());
344         m_rareData->m_lineGridBox = box;
345     }
346     void layoutLineGridBox();
347
348     // Accessors for logical width/height and margins in the containing block's block-flow direction.
349     enum ApplyLayoutDeltaMode { ApplyLayoutDelta, DoNotApplyLayoutDelta };
350     LayoutUnit logicalWidthForChild(const RenderBox* child) const { return isHorizontalWritingMode() ? child->width() : child->height(); }
351     LayoutUnit logicalHeightForChild(const RenderBox* child) const { return isHorizontalWritingMode() ? child->height() : child->width(); }
352     LayoutUnit logicalTopForChild(const RenderBox* child) const { return isHorizontalWritingMode() ? child->y() : child->x(); }
353     void setLogicalLeftForChild(RenderBox* child, LayoutUnit logicalLeft, ApplyLayoutDeltaMode = DoNotApplyLayoutDelta);
354     void setLogicalTopForChild(RenderBox* child, LayoutUnit logicalTop, ApplyLayoutDeltaMode = DoNotApplyLayoutDelta);
355     LayoutUnit marginBeforeForChild(const RenderBoxModelObject* child) const { return child->marginBefore(style()); }
356     LayoutUnit marginAfterForChild(const RenderBoxModelObject* child) const { return child->marginAfter(style()); }
357     LayoutUnit marginStartForChild(const RenderBoxModelObject* child) const { return child->marginStart(style()); }
358     LayoutUnit marginEndForChild(const RenderBoxModelObject* child) const { return child->marginEnd(style()); }
359     void setMarginStartForChild(RenderBox* child, LayoutUnit value) const { child->setMarginStart(value, style()); }
360     void setMarginEndForChild(RenderBox* child, LayoutUnit value) const { child->setMarginEnd(value, style()); }
361     void setMarginBeforeForChild(RenderBox* child, LayoutUnit value) const { child->setMarginBefore(value, style()); }
362     void setMarginAfterForChild(RenderBox* child, LayoutUnit value) const { child->setMarginAfter(value, style()); }
363     LayoutUnit collapsedMarginBeforeForChild(const RenderBox* child) const;
364     LayoutUnit collapsedMarginAfterForChild(const RenderBox* child) const;
365
366     void updateLogicalWidthForAlignment(const ETextAlign&, BidiRun* trailingSpaceRun, float& logicalLeft, float& totalLogicalWidth, float& availableLogicalWidth, int expansionOpportunityCount);
367
368     virtual void updateFirstLetter();
369
370     class MarginValues {
371     public:
372         MarginValues(LayoutUnit beforePos, LayoutUnit beforeNeg, LayoutUnit afterPos, LayoutUnit afterNeg)
373             : m_positiveMarginBefore(beforePos)
374             , m_negativeMarginBefore(beforeNeg)
375             , m_positiveMarginAfter(afterPos)
376             , m_negativeMarginAfter(afterNeg)
377         { }
378         
379         LayoutUnit positiveMarginBefore() const { return m_positiveMarginBefore; }
380         LayoutUnit negativeMarginBefore() const { return m_negativeMarginBefore; }
381         LayoutUnit positiveMarginAfter() const { return m_positiveMarginAfter; }
382         LayoutUnit negativeMarginAfter() const { return m_negativeMarginAfter; }
383         
384         void setPositiveMarginBefore(LayoutUnit pos) { m_positiveMarginBefore = pos; }
385         void setNegativeMarginBefore(LayoutUnit neg) { m_negativeMarginBefore = neg; }
386         void setPositiveMarginAfter(LayoutUnit pos) { m_positiveMarginAfter = pos; }
387         void setNegativeMarginAfter(LayoutUnit neg) { m_negativeMarginAfter = neg; }
388     
389     private:
390         LayoutUnit m_positiveMarginBefore;
391         LayoutUnit m_negativeMarginBefore;
392         LayoutUnit m_positiveMarginAfter;
393         LayoutUnit m_negativeMarginAfter;
394     };
395     MarginValues marginValuesForChild(RenderBox* child) const;
396
397     virtual void scrollbarsChanged(bool /*horizontalScrollbarChanged*/, bool /*verticalScrollbarChanged*/) { };
398
399     LayoutUnit logicalLeftOffsetForContent(RenderRegion*) const;
400     LayoutUnit logicalRightOffsetForContent(RenderRegion*) const;
401     LayoutUnit availableLogicalWidthForContent(RenderRegion* region) const
402     { 
403         return max<LayoutUnit>(0, logicalRightOffsetForContent(region) - logicalLeftOffsetForContent(region)); }
404     LayoutUnit startOffsetForContent(RenderRegion* region) const
405     {
406         return style()->isLeftToRightDirection() ? logicalLeftOffsetForContent(region) : logicalWidth() - logicalRightOffsetForContent(region);
407     }
408     LayoutUnit endOffsetForContent(RenderRegion* region) const
409     {
410         return !style()->isLeftToRightDirection() ? logicalLeftOffsetForContent(region) : logicalWidth() - logicalRightOffsetForContent(region);
411     }
412     LayoutUnit logicalLeftOffsetForContent(LayoutUnit blockOffset) const
413     {
414         return logicalLeftOffsetForContent(regionAtBlockOffset(blockOffset));
415     }
416     LayoutUnit logicalRightOffsetForContent(LayoutUnit blockOffset) const
417     {
418         return logicalRightOffsetForContent(regionAtBlockOffset(blockOffset));
419     }
420     LayoutUnit availableLogicalWidthForContent(LayoutUnit blockOffset) const
421     {
422         return availableLogicalWidthForContent(regionAtBlockOffset(blockOffset));
423     }
424     LayoutUnit startOffsetForContent(LayoutUnit blockOffset) const
425     {
426         return startOffsetForContent(regionAtBlockOffset(blockOffset));
427     }
428     LayoutUnit endOffsetForContent(LayoutUnit blockOffset) const
429     {
430         return endOffsetForContent(regionAtBlockOffset(blockOffset));
431     }
432     LayoutUnit logicalLeftOffsetForContent() const { return isHorizontalWritingMode() ? borderLeft() + paddingLeft() : borderTop() + paddingTop(); }
433     LayoutUnit logicalRightOffsetForContent() const { return logicalLeftOffsetForContent() + availableLogicalWidth(); }
434     LayoutUnit startOffsetForContent() const { return style()->isLeftToRightDirection() ? logicalLeftOffsetForContent() : logicalWidth() - logicalRightOffsetForContent(); }
435     LayoutUnit endOffsetForContent() const { return !style()->isLeftToRightDirection() ? logicalLeftOffsetForContent() : logicalWidth() - logicalRightOffsetForContent(); }
436     
437     void setStaticInlinePositionForChild(RenderBox*, LayoutUnit blockOffset, LayoutUnit inlinePosition);
438     void updateStaticInlinePositionForChild(RenderBox*, LayoutUnit logicalTop);
439
440     LayoutUnit computeStartPositionDeltaForChildAvoidingFloats(const RenderBox* child, LayoutUnit childMarginStart, RenderRegion* = 0);
441
442     void placeRunInIfNeeded(RenderObject* newChild);
443     bool runInIsPlacedIntoSiblingBlock(RenderObject* runIn);
444
445 #ifndef NDEBUG
446     void checkPositionedObjectsNeedLayout();
447     void showLineTreeAndMark(const InlineBox* = 0, const char* = 0, const InlineBox* = 0, const char* = 0, const RenderObject* = 0) const;
448 #endif
449
450 #if ENABLE(CSS_SHAPES)
451     ShapeInsideInfo* ensureShapeInsideInfo()
452     {
453         if (!m_rareData || !m_rareData->m_shapeInsideInfo)
454             setShapeInsideInfo(ShapeInsideInfo::createInfo(this));
455         return m_rareData->m_shapeInsideInfo.get();
456     }
457
458     ShapeInsideInfo* shapeInsideInfo() const
459     {
460         if (!m_rareData || !m_rareData->m_shapeInsideInfo)
461             return 0;
462         return ShapeInsideInfo::isEnabledFor(this) ? m_rareData->m_shapeInsideInfo.get() : 0;
463     }
464     void setShapeInsideInfo(PassOwnPtr<ShapeInsideInfo> value)
465     {
466         if (!m_rareData)
467             m_rareData = adoptPtr(new RenderBlockRareData(this));
468         m_rareData->m_shapeInsideInfo = value;
469     }
470     void markShapeInsideDescendantsForLayout();
471     ShapeInsideInfo* layoutShapeInsideInfo() const;
472     bool allowsShapeInsideInfoSharing() const { return !isInline() && !isFloating(); }
473 #endif
474
475 protected:
476     virtual void willBeDestroyed();
477
478     LayoutUnit maxPositiveMarginBefore() const { return m_rareData ? m_rareData->m_margins.positiveMarginBefore() : RenderBlockRareData::positiveMarginBeforeDefault(this); }
479     LayoutUnit maxNegativeMarginBefore() const { return m_rareData ? m_rareData->m_margins.negativeMarginBefore() : RenderBlockRareData::negativeMarginBeforeDefault(this); }
480     LayoutUnit maxPositiveMarginAfter() const { return m_rareData ? m_rareData->m_margins.positiveMarginAfter() : RenderBlockRareData::positiveMarginAfterDefault(this); }
481     LayoutUnit maxNegativeMarginAfter() const { return m_rareData ? m_rareData->m_margins.negativeMarginAfter() : RenderBlockRareData::negativeMarginAfterDefault(this); }
482     
483     void setMaxMarginBeforeValues(LayoutUnit pos, LayoutUnit neg);
484     void setMaxMarginAfterValues(LayoutUnit pos, LayoutUnit neg);
485
486     void setMustDiscardMarginBefore(bool = true);
487     void setMustDiscardMarginAfter(bool = true);
488
489     bool mustDiscardMarginBefore() const;
490     bool mustDiscardMarginAfter() const;
491
492     bool mustDiscardMarginBeforeForChild(const RenderBox*) const;
493     bool mustDiscardMarginAfterForChild(const RenderBox*) const;
494
495     bool mustSeparateMarginBeforeForChild(const RenderBox*) const;
496     bool mustSeparateMarginAfterForChild(const RenderBox*) const;
497
498     void initMaxMarginValues()
499     {
500         if (m_rareData) {
501             m_rareData->m_margins = MarginValues(RenderBlockRareData::positiveMarginBeforeDefault(this) , RenderBlockRareData::negativeMarginBeforeDefault(this),
502                                                  RenderBlockRareData::positiveMarginAfterDefault(this), RenderBlockRareData::negativeMarginAfterDefault(this));
503             m_rareData->m_paginationStrut = 0;
504
505             m_rareData->m_discardMarginBefore = false;
506             m_rareData->m_discardMarginAfter = false;
507         }
508     }
509
510     virtual void layout();
511
512     void layoutPositionedObjects(bool relayoutChildren, bool fixedPositionObjectsOnly = false);
513     void markFixedPositionObjectForLayoutIfNeeded(RenderObject* child);
514
515     virtual void paint(PaintInfo&, const LayoutPoint&);
516     virtual void paintObject(PaintInfo&, const LayoutPoint&);
517     virtual void paintChildren(PaintInfo& forSelf, const LayoutPoint&, PaintInfo& forChild, bool usePrintRect);
518     bool paintChild(RenderBox*, PaintInfo& forSelf, const LayoutPoint&, PaintInfo& forChild, bool usePrintRect);
519    
520     LayoutUnit logicalRightOffsetForLine(LayoutUnit logicalTop, LayoutUnit fixedOffset, bool applyTextIndent, LayoutUnit* heightRemaining = 0, LayoutUnit logicalHeight = 0) const
521     {
522         return adjustLogicalRightOffsetForLine(logicalRightFloatOffsetForLine(logicalTop, fixedOffset, heightRemaining, logicalHeight, ShapeOutsideFloatShapeOffset), applyTextIndent);
523     }
524     LayoutUnit logicalLeftOffsetForLine(LayoutUnit logicalTop, LayoutUnit fixedOffset, bool applyTextIndent, LayoutUnit* heightRemaining = 0, LayoutUnit logicalHeight = 0) const
525     {
526         return adjustLogicalLeftOffsetForLine(logicalLeftFloatOffsetForLine(logicalTop, fixedOffset, heightRemaining, logicalHeight, ShapeOutsideFloatShapeOffset), applyTextIndent);
527     }
528     LayoutUnit logicalRightOffsetForLineIgnoringShapeOutside(LayoutUnit logicalTop, LayoutUnit fixedOffset, bool applyTextIndent, LayoutUnit* heightRemaining = 0, LayoutUnit logicalHeight = 0) const
529     {
530         return adjustLogicalRightOffsetForLine(logicalRightFloatOffsetForLine(logicalTop, fixedOffset, heightRemaining, logicalHeight, ShapeOutsideFloatMarginBoxOffset), applyTextIndent);
531     }
532     LayoutUnit logicalLeftOffsetForLineIgnoringShapeOutside(LayoutUnit logicalTop, LayoutUnit fixedOffset, bool applyTextIndent, LayoutUnit* heightRemaining = 0, LayoutUnit logicalHeight = 0) const
533     {
534         return adjustLogicalLeftOffsetForLine(logicalLeftFloatOffsetForLine(logicalTop, fixedOffset, heightRemaining, logicalHeight, ShapeOutsideFloatMarginBoxOffset), applyTextIndent);
535     }
536
537     virtual ETextAlign textAlignmentForLine(bool endsWithSoftBreak) const;
538     virtual void adjustInlineDirectionLineBounds(int /* expansionOpportunityCount */, float& /* logicalLeft */, float& /* logicalWidth */) const { }
539
540     virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) OVERRIDE;
541
542     virtual void computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const OVERRIDE;
543     virtual void computePreferredLogicalWidths() OVERRIDE;
544
545     virtual int firstLineBoxBaseline() const;
546     virtual int inlineBlockBaseline(LineDirectionMode) const OVERRIDE;
547     int lastLineBoxBaseline(LineDirectionMode) const;
548
549     virtual void updateHitTestResult(HitTestResult&, const LayoutPoint&);
550
551     // Delay update scrollbar until finishDelayRepaint() will be
552     // called. This function is used when a flexbox is laying out its
553     // descendant. If multiple calls are made to startDelayRepaint(),
554     // finishDelayRepaint() will do nothing until finishDelayRepaint()
555     // is called the same number of times.
556     static void startDelayUpdateScrollInfo();
557     static void finishDelayUpdateScrollInfo();
558
559     void updateScrollInfoAfterLayout();
560
561     virtual void styleWillChange(StyleDifference, const RenderStyle* newStyle);
562     virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle);
563
564     virtual bool hasLineIfEmpty() const;
565     
566     bool simplifiedLayout();
567     virtual void simplifiedNormalFlowLayout();
568
569     void setDesiredColumnCountAndWidth(int, LayoutUnit);
570
571 public:
572     void computeOverflow(LayoutUnit oldClientAfterEdge, bool recomputeFloats = false);
573     void clearLayoutOverflow();
574 protected:
575     virtual void addOverflowFromChildren();
576     void addOverflowFromFloats();
577     void addOverflowFromPositionedObjects();
578     void addOverflowFromBlockChildren();
579     void addOverflowFromInlineChildren();
580     void addVisualOverflowFromTheme();
581
582     virtual void addFocusRingRects(Vector<IntRect>&, const LayoutPoint& additionalOffset, const RenderLayerModelObject* paintContainer = 0) OVERRIDE;
583
584 #if ENABLE(SVG)
585     // Only used by RenderSVGText, which explicitely overrides RenderBlock::layoutBlock(), do NOT use for anything else.
586     void forceLayoutInlineChildren()
587     {
588         LayoutUnit repaintLogicalTop = 0;
589         LayoutUnit repaintLogicalBottom = 0;
590         clearFloats();
591         layoutInlineChildren(true, repaintLogicalTop, repaintLogicalBottom);
592     }
593 #endif
594
595     bool updateShapesBeforeBlockLayout();
596     void updateShapesAfterBlockLayout(bool heightChanged = false);
597     void computeRegionRangeForBoxChild(const RenderBox*) const;
598
599     void estimateRegionRangeForBoxChild(const RenderBox*) const;
600     bool updateRegionRangeForBoxChild(const RenderBox*) const;
601
602     void updateBlockChildDirtyBitsBeforeLayout(bool relayoutChildren, RenderBox*);
603
604     virtual void checkForPaginationLogicalHeightChange(LayoutUnit& pageLogicalHeight, bool& pageLogicalHeightChanged, bool& hasSpecifiedPageLogicalHeight);
605
606 private:
607     enum ShapeOutsideFloatOffsetMode { ShapeOutsideFloatShapeOffset, ShapeOutsideFloatMarginBoxOffset };
608
609     LayoutUnit logicalRightFloatOffsetForLine(LayoutUnit logicalTop, LayoutUnit fixedOffset, LayoutUnit* heightRemaining, LayoutUnit logicalHeight, ShapeOutsideFloatOffsetMode) const;
610     LayoutUnit logicalLeftFloatOffsetForLine(LayoutUnit logicalTop, LayoutUnit fixedOffset, LayoutUnit* heightRemaining, LayoutUnit logicalHeight, ShapeOutsideFloatOffsetMode) const;
611     LayoutUnit adjustLogicalRightOffsetForLine(LayoutUnit offsetFromFloats, bool applyTextIndent) const;
612     LayoutUnit adjustLogicalLeftOffsetForLine(LayoutUnit offsetFromFloats, bool applyTextIndent) const;
613
614 #if ENABLE(CSS_SHAPES)
615     void computeShapeSize();
616     void updateShapeInsideInfoAfterStyleChange(const ShapeValue*, const ShapeValue* oldShape);
617 #endif
618     virtual RenderObjectChildList* virtualChildren() { return children(); }
619     virtual const RenderObjectChildList* virtualChildren() const { return children(); }
620
621     virtual const char* renderName() const;
622
623     virtual bool isRenderBlock() const OVERRIDE FINAL { return true; }
624     virtual bool isBlockFlow() const OVERRIDE FINAL { return (!isInline() || isReplaced()) && !isTable(); }
625     virtual bool isInlineBlockOrInlineTable() const OVERRIDE FINAL { return isInline() && isReplaced(); }
626
627     void makeChildrenNonInline(RenderObject* insertionPoint = 0);
628     virtual void removeLeftoverAnonymousBlock(RenderBlock* child);
629
630     void moveAllChildrenIncludingFloatsTo(RenderBlock* toBlock, bool fullRemoveInsert);
631
632     virtual void dirtyLinesFromChangedChild(RenderObject* child) OVERRIDE FINAL { m_lineBoxes.dirtyLinesFromChangedChild(this, child); }
633
634     void addChildToContinuation(RenderObject* newChild, RenderObject* beforeChild);
635     void addChildIgnoringContinuation(RenderObject* newChild, RenderObject* beforeChild);
636     void addChildToAnonymousColumnBlocks(RenderObject* newChild, RenderObject* beforeChild);
637
638     void addChildIgnoringAnonymousColumnBlocks(RenderObject* newChild, RenderObject* beforeChild = 0);
639     
640     virtual bool isSelfCollapsingBlock() const OVERRIDE FINAL;
641
642     virtual LayoutUnit collapsedMarginBefore() const OVERRIDE FINAL { return maxPositiveMarginBefore() - maxNegativeMarginBefore(); }
643     virtual LayoutUnit collapsedMarginAfter() const OVERRIDE FINAL { return maxPositiveMarginAfter() - maxNegativeMarginAfter(); }
644
645     virtual void repaintOverhangingFloats(bool paintAllDescendants) OVERRIDE FINAL;
646
647     void layoutBlockChildren(bool relayoutChildren, LayoutUnit& maxFloatLogicalBottom);
648     void layoutInlineChildren(bool relayoutChildren, LayoutUnit& repaintLogicalTop, LayoutUnit& repaintLogicalBottom);
649     BidiRun* handleTrailingSpaces(BidiRunList<BidiRun>&, BidiContext*);
650
651     void insertIntoTrackedRendererMaps(RenderBox* descendant, TrackedDescendantsMap*&, TrackedContainerMap*&);
652     static void removeFromTrackedRendererMaps(RenderBox* descendant, TrackedDescendantsMap*&, TrackedContainerMap*&);
653
654     virtual RootInlineBox* createRootInlineBox(); // Subclassed by SVG and Ruby.
655
656     // Called to lay out the legend for a fieldset or the ruby text of a ruby run.
657     virtual RenderObject* layoutSpecialExcludedChild(bool /*relayoutChildren*/) { return 0; }
658
659     bool relayoutToAvoidWidows(LayoutStateMaintainer&);
660
661     void createFirstLetterRenderer(RenderObject* firstLetterBlock, RenderObject* currentChild);
662     void updateFirstLetterStyle(RenderObject* firstLetterBlock, RenderObject* firstLetterContainer);
663
664     Node* nodeForHitTest() const;
665
666     struct FloatWithRect {
667         FloatWithRect(RenderBox* f)
668             : object(f)
669             , rect(LayoutRect(f->x() - f->marginLeft(), f->y() - f->marginTop(), f->width() + f->marginWidth(), f->height() + f->marginHeight()))
670             , everHadLayout(f->everHadLayout())
671         {
672         }
673
674         RenderBox* object;
675         LayoutRect rect;
676         bool everHadLayout;
677     };
678
679     class FloatingObject {
680         WTF_MAKE_NONCOPYABLE(FloatingObject); WTF_MAKE_FAST_ALLOCATED;
681     public:
682         // Note that Type uses bits so you can use FloatLeftRight as a mask to query for both left and right.
683         enum Type { FloatLeft = 1, FloatRight = 2, FloatLeftRight = 3 };
684
685         FloatingObject(EFloat type)
686             : m_renderer(0)
687             , m_originatingLine(0)
688             , m_paginationStrut(0)
689             , m_shouldPaint(true)
690             , m_isDescendant(false)
691             , m_isPlaced(false)
692 #ifndef NDEBUG
693             , m_isInPlacedTree(false)
694 #endif
695         {
696             ASSERT(type != NoFloat);
697             if (type == LeftFloat)
698                 m_type = FloatLeft;
699             else if (type == RightFloat)
700                 m_type = FloatRight;  
701         }
702
703         FloatingObject(Type type, const LayoutRect& frameRect)
704             : m_renderer(0)
705             , m_originatingLine(0)
706             , m_frameRect(frameRect)
707             , m_paginationStrut(0)
708             , m_type(type)
709             , m_shouldPaint(true)
710             , m_isDescendant(false)
711             , m_isPlaced(true)
712 #ifndef NDEBUG
713             , m_isInPlacedTree(false)
714 #endif
715         {
716         }
717
718         FloatingObject* clone() const
719         {
720             FloatingObject* cloneObject = new FloatingObject(type(), m_frameRect);
721             cloneObject->m_renderer = m_renderer;
722             cloneObject->m_originatingLine = m_originatingLine;
723             cloneObject->m_paginationStrut = m_paginationStrut;
724             cloneObject->m_shouldPaint = m_shouldPaint;
725             cloneObject->m_isDescendant = m_isDescendant;
726             cloneObject->m_isPlaced = m_isPlaced;
727             return cloneObject;
728         }
729
730         Type type() const { return static_cast<Type>(m_type); }
731         RenderBox* renderer() const { return m_renderer; }
732         
733         bool isPlaced() const { return m_isPlaced; }
734         void setIsPlaced(bool placed = true) { m_isPlaced = placed; }
735
736         inline LayoutUnit x() const { ASSERT(isPlaced()); return m_frameRect.x(); }
737         inline LayoutUnit maxX() const { ASSERT(isPlaced()); return m_frameRect.maxX(); }
738         inline LayoutUnit y() const { ASSERT(isPlaced()); return m_frameRect.y(); }
739         inline LayoutUnit maxY() const { ASSERT(isPlaced()); return m_frameRect.maxY(); }
740         inline LayoutUnit width() const { return m_frameRect.width(); }
741         inline LayoutUnit height() const { return m_frameRect.height(); }
742
743         void setX(LayoutUnit x) { ASSERT(!isInPlacedTree()); m_frameRect.setX(x); }
744         void setY(LayoutUnit y) { ASSERT(!isInPlacedTree()); m_frameRect.setY(y); }
745         void setWidth(LayoutUnit width) { ASSERT(!isInPlacedTree()); m_frameRect.setWidth(width); }
746         void setHeight(LayoutUnit height) { ASSERT(!isInPlacedTree()); m_frameRect.setHeight(height); }
747
748         const LayoutRect& frameRect() const { ASSERT(isPlaced()); return m_frameRect; }
749         void setFrameRect(const LayoutRect& frameRect) { ASSERT(!isInPlacedTree()); m_frameRect = frameRect; }
750
751         int paginationStrut() const { return m_paginationStrut; }
752         void setPaginationStrut(int strut) { m_paginationStrut = strut; }
753
754 #ifndef NDEBUG
755         bool isInPlacedTree() const { return m_isInPlacedTree; }
756         void setIsInPlacedTree(bool value) { m_isInPlacedTree = value; }
757 #endif
758
759         bool shouldPaint() const { return m_shouldPaint; }
760         void setShouldPaint(bool shouldPaint) { m_shouldPaint = shouldPaint; }
761         bool isDescendant() const { return m_isDescendant; }
762         void setIsDescendant(bool isDescendant) { m_isDescendant = isDescendant; }
763
764         // FIXME: Callers of these methods are dangerous and should be whitelisted explicitly or removed.
765         void setRenderer(RenderBox* renderer) { m_renderer = renderer; }
766         RootInlineBox* originatingLine() const { return m_originatingLine; }
767         void setOriginatingLine(RootInlineBox* line) { m_originatingLine = line; }
768
769     private:
770         RenderBox* m_renderer;
771         RootInlineBox* m_originatingLine;
772         LayoutRect m_frameRect;
773         int m_paginationStrut; // FIXME: This should be a LayoutUnit, since it's a vertical offset.
774
775         unsigned m_type : 2; // Type (left or right aligned)
776         unsigned m_shouldPaint : 1;
777         unsigned m_isDescendant : 1;
778         unsigned m_isPlaced : 1;
779 #ifndef NDEBUG
780         unsigned m_isInPlacedTree : 1;
781 #endif
782     };
783
784     LayoutPoint flipFloatForWritingModeForChild(const FloatingObject*, const LayoutPoint&) const;
785
786     LayoutUnit logicalTopForFloat(const FloatingObject* child) const { return isHorizontalWritingMode() ? child->y() : child->x(); }
787     LayoutUnit logicalBottomForFloat(const FloatingObject* child) const { return isHorizontalWritingMode() ? child->maxY() : child->maxX(); }
788     LayoutUnit logicalLeftForFloat(const FloatingObject* child) const { return isHorizontalWritingMode() ? child->x() : child->y(); }
789     LayoutUnit logicalRightForFloat(const FloatingObject* child) const { return isHorizontalWritingMode() ? child->maxX() : child->maxY(); }
790     LayoutUnit logicalWidthForFloat(const FloatingObject* child) const { return isHorizontalWritingMode() ? child->width() : child->height(); }
791
792     int pixelSnappedLogicalTopForFloat(const FloatingObject* child) const { return isHorizontalWritingMode() ? child->frameRect().pixelSnappedY() : child->frameRect().pixelSnappedX(); }
793     int pixelSnappedLogicalBottomForFloat(const FloatingObject* child) const { return isHorizontalWritingMode() ? child->frameRect().pixelSnappedMaxY() : child->frameRect().pixelSnappedMaxX(); }
794     int pixelSnappedLogicalLeftForFloat(const FloatingObject* child) const { return isHorizontalWritingMode() ? child->frameRect().pixelSnappedX() : child->frameRect().pixelSnappedY(); }
795     int pixelSnappedLogicalRightForFloat(const FloatingObject* child) const { return isHorizontalWritingMode() ? child->frameRect().pixelSnappedMaxX() : child->frameRect().pixelSnappedMaxY(); }
796
797     void setLogicalTopForFloat(FloatingObject* child, LayoutUnit logicalTop)
798     {
799         if (isHorizontalWritingMode())
800             child->setY(logicalTop);
801         else
802             child->setX(logicalTop);
803     }
804     void setLogicalLeftForFloat(FloatingObject* child, LayoutUnit logicalLeft)
805     {
806         if (isHorizontalWritingMode())
807             child->setX(logicalLeft);
808         else
809             child->setY(logicalLeft);
810     }
811     void setLogicalHeightForFloat(FloatingObject* child, LayoutUnit logicalHeight)
812     {
813         if (isHorizontalWritingMode())
814             child->setHeight(logicalHeight);
815         else
816             child->setWidth(logicalHeight);
817     }
818     void setLogicalWidthForFloat(FloatingObject* child, LayoutUnit logicalWidth)
819     {
820         if (isHorizontalWritingMode())
821             child->setWidth(logicalWidth);
822         else
823             child->setHeight(logicalWidth);
824     }
825
826     LayoutUnit xPositionForFloatIncludingMargin(const FloatingObject* child) const
827     {
828         if (isHorizontalWritingMode())
829             return child->x() + child->renderer()->marginLeft();
830         else
831             return child->x() + marginBeforeForChild(child->renderer());
832     }
833         
834     LayoutUnit yPositionForFloatIncludingMargin(const FloatingObject* child) const
835     {
836         if (isHorizontalWritingMode())
837             return child->y() + marginBeforeForChild(child->renderer());
838         else
839             return child->y() + child->renderer()->marginTop();
840     }
841
842     LayoutPoint computeLogicalLocationForFloat(const FloatingObject*, LayoutUnit logicalTopOffset) const;
843
844     // The following functions' implementations are in RenderBlockLineLayout.cpp.
845     struct RenderTextInfo {
846         // Destruction of m_layout requires TextLayout to be a complete type, so the constructor and destructor are made non-inline to avoid compilation errors.
847         RenderTextInfo();
848         ~RenderTextInfo();
849
850         RenderText* m_text;
851         OwnPtr<TextLayout> m_layout;
852         LazyLineBreakIterator m_lineBreakIterator;
853         const Font* m_font;
854     };
855
856     class LineBreaker {
857     public:
858         LineBreaker(RenderBlock* block)
859             : m_block(block)
860         {
861             reset();
862         }
863
864         InlineIterator nextLineBreak(InlineBidiResolver&, LineInfo&, RenderTextInfo&, FloatingObject* lastFloatFromPreviousLine, unsigned consecutiveHyphenatedLines, WordMeasurements&);
865
866         bool lineWasHyphenated() { return m_hyphenated; }
867         const Vector<RenderBox*>& positionedObjects() { return m_positionedObjects; }
868         EClear clear() { return m_clear; }
869     private:
870         void reset();
871         
872         InlineIterator nextSegmentBreak(InlineBidiResolver&, LineInfo&, RenderTextInfo&, FloatingObject* lastFloatFromPreviousLine, unsigned consecutiveHyphenatedLines, WordMeasurements&);
873         void skipTrailingWhitespace(InlineIterator&, const LineInfo&);
874         void skipLeadingWhitespace(InlineBidiResolver&, LineInfo&, FloatingObject* lastFloatFromPreviousLine, LineWidth&);
875         
876         RenderBlock* m_block;
877         bool m_hyphenated;
878         EClear m_clear;
879         Vector<RenderBox*> m_positionedObjects;
880     };
881
882     void checkFloatsInCleanLine(RootInlineBox*, Vector<FloatWithRect>&, size_t& floatIndex, bool& encounteredNewFloat, bool& dirtiedByFloat);
883     RootInlineBox* determineStartPosition(LineLayoutState&, InlineBidiResolver&);
884     void determineEndPosition(LineLayoutState&, RootInlineBox* startBox, InlineIterator& cleanLineStart, BidiStatus& cleanLineBidiStatus);
885     bool matchedEndLine(LineLayoutState&, const InlineBidiResolver&, const InlineIterator& endLineStart, const BidiStatus& endLineStatus);
886     bool checkPaginationAndFloatsAtEndLine(LineLayoutState&);
887     
888     RootInlineBox* constructLine(BidiRunList<BidiRun>&, const LineInfo&);
889     InlineFlowBox* createLineBoxes(RenderObject*, const LineInfo&, InlineBox* childBox, bool startsNewSegment);
890
891     void setMarginsForRubyRun(BidiRun*, RenderRubyRun*, RenderObject*, const LineInfo&);
892
893     BidiRun* computeInlineDirectionPositionsForSegment(RootInlineBox*, const LineInfo&, ETextAlign, float& logicalLeft,
894         float& availableLogicalWidth, BidiRun* firstRun, BidiRun* trailingSpaceRun, GlyphOverflowAndFallbackFontsMap& textBoxDataMap, VerticalPositionCache&, WordMeasurements&);
895     void computeInlineDirectionPositionsForLine(RootInlineBox*, const LineInfo&, BidiRun* firstRun, BidiRun* trailingSpaceRun, bool reachedEnd, GlyphOverflowAndFallbackFontsMap&, VerticalPositionCache&, WordMeasurements&);
896     void computeBlockDirectionPositionsForLine(RootInlineBox*, BidiRun*, GlyphOverflowAndFallbackFontsMap&, VerticalPositionCache&);
897     void deleteEllipsisLineBoxes();
898     void checkLinesForTextOverflow();
899
900     // Positions new floats and also adjust all floats encountered on the line if any of them
901     // have to move to the next page/column.
902     bool positionNewFloatOnLine(FloatingObject* newFloat, FloatingObject* lastFloatFromPreviousLine, LineInfo&, LineWidth&);
903     void appendFloatingObjectToLastLine(FloatingObject*);
904
905     // End of functions defined in RenderBlockLineLayout.cpp.
906
907     void paintFloats(PaintInfo&, const LayoutPoint&, bool preservePhase = false);
908     void paintContents(PaintInfo&, const LayoutPoint&);
909     void paintColumnContents(PaintInfo&, const LayoutPoint&, bool paintFloats = false);
910     void paintColumnRules(PaintInfo&, const LayoutPoint&);
911     void paintSelection(PaintInfo&, const LayoutPoint&);
912     void paintCaret(PaintInfo&, const LayoutPoint&, CaretType);
913
914     FloatingObject* insertFloatingObject(RenderBox*);
915     void removeFloatingObject(RenderBox*);
916     void removeFloatingObjectsBelow(FloatingObject*, int logicalOffset);
917     
918     // Called from lineWidth, to position the floats added in the last line.
919     // Returns true if and only if it has positioned any floats.
920     bool positionNewFloats();
921
922     void clearFloats();
923
924     LayoutUnit getClearDelta(RenderBox* child, LayoutUnit yPos);
925
926     virtual bool avoidsFloats() const;
927
928     bool hasOverhangingFloats() { return parent() && !hasColumns() && containsFloats() && lowestFloatLogicalBottom() > logicalHeight(); }
929     bool hasOverhangingFloat(RenderBox*);
930     void addIntrudingFloats(RenderBlock* prev, LayoutUnit xoffset, LayoutUnit yoffset);
931     LayoutUnit addOverhangingFloats(RenderBlock* child, bool makeChildPaintOtherFloats);
932
933     LayoutUnit lowestFloatLogicalBottom(FloatingObject::Type = FloatingObject::FloatLeftRight) const; 
934     LayoutUnit nextFloatLogicalBottomBelow(LayoutUnit) const;
935     
936     bool hitTestColumns(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction);
937     virtual bool hitTestContents(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction);
938     bool hitTestFloats(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset);
939
940     virtual bool isPointInOverflowControl(HitTestResult&, const LayoutPoint& locationInContainer, const LayoutPoint& accumulatedOffset);
941
942     // FIXME: Make this method const so we can remove the const_cast in computeIntrinsicLogicalWidths.
943     void computeInlinePreferredLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth);
944     void computeBlockPreferredLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const;
945
946     // Obtains the nearest enclosing block (including this block) that contributes a first-line style to our inline
947     // children.
948     virtual RenderBlock* firstLineBlock() const OVERRIDE;
949
950     virtual LayoutRect rectWithOutlineForRepaint(const RenderLayerModelObject* repaintContainer, LayoutUnit outlineWidth) const OVERRIDE FINAL;
951     virtual RenderStyle* outlineStyleForRepaint() const OVERRIDE FINAL;
952     
953     virtual RenderObject* hoverAncestor() const OVERRIDE FINAL;
954     virtual void updateDragState(bool dragOn) OVERRIDE FINAL;
955     virtual void childBecameNonInline(RenderObject* child) OVERRIDE FINAL;
956
957     virtual LayoutRect selectionRectForRepaint(const RenderLayerModelObject* repaintContainer, bool /*clipToVisibleContent*/) OVERRIDE FINAL
958     {
959         return selectionGapRectsForRepaint(repaintContainer);
960     }
961     virtual bool shouldPaintSelectionGaps() const OVERRIDE FINAL;
962     bool isSelectionRoot() const;
963     GapRects selectionGaps(RenderBlock* rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
964         LayoutUnit& lastLogicalTop, LayoutUnit& lastLogicalLeft, LayoutUnit& lastLogicalRight, const LogicalSelectionOffsetCaches&, const PaintInfo* = 0);
965     GapRects inlineSelectionGaps(RenderBlock* rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
966         LayoutUnit& lastLogicalTop, LayoutUnit& lastLogicalLeft, LayoutUnit& lastLogicalRight, const LogicalSelectionOffsetCaches&, const PaintInfo*);
967     GapRects blockSelectionGaps(RenderBlock* rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
968         LayoutUnit& lastLogicalTop, LayoutUnit& lastLogicalLeft, LayoutUnit& lastLogicalRight, const LogicalSelectionOffsetCaches&, const PaintInfo*);
969     LayoutRect blockSelectionGap(RenderBlock* rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
970         LayoutUnit lastLogicalTop, LayoutUnit lastLogicalLeft, LayoutUnit lastLogicalRight, LayoutUnit logicalBottom, const LogicalSelectionOffsetCaches&, const PaintInfo*);
971     LayoutUnit logicalLeftSelectionOffset(RenderBlock* rootBlock, LayoutUnit position, const LogicalSelectionOffsetCaches&);
972     LayoutUnit logicalRightSelectionOffset(RenderBlock* rootBlock, LayoutUnit position, const LogicalSelectionOffsetCaches&);
973     
974     friend class LogicalSelectionOffsetCaches;
975
976     virtual void absoluteRects(Vector<IntRect>&, const LayoutPoint& accumulatedOffset) const;
977     virtual void absoluteQuads(Vector<FloatQuad>&, bool* wasFixed) const;
978
979     LayoutUnit desiredColumnWidth() const;
980     unsigned desiredColumnCount() const;
981
982     void paintContinuationOutlines(PaintInfo&, const LayoutPoint&);
983
984     virtual LayoutRect localCaretRect(InlineBox*, int caretOffset, LayoutUnit* extraWidthToEndOfLine = 0) OVERRIDE FINAL;
985
986     void adjustPointToColumnContents(LayoutPoint&) const;
987     
988     void fitBorderToLinesIfNeeded(); // Shrink the box in which the border paints if border-fit is set.
989     void adjustForBorderFit(LayoutUnit x, LayoutUnit& left, LayoutUnit& right) const; // Helper function for borderFitAdjust
990
991     void markLinesDirtyInBlockRange(LayoutUnit logicalTop, LayoutUnit logicalBottom, RootInlineBox* highest = 0);
992
993     void newLine(EClear);
994
995     Position positionForBox(InlineBox*, bool start = true) const;
996     VisiblePosition positionForPointWithInlineChildren(const LayoutPoint&);
997
998     virtual void calcColumnWidth();
999     void makeChildrenAnonymousColumnBlocks(RenderObject* beforeChild, RenderBlock* newBlockBox, RenderObject* newChild);
1000
1001     bool expandsToEncloseOverhangingFloats() const;
1002
1003     void splitBlocks(RenderBlock* fromBlock, RenderBlock* toBlock, RenderBlock* middleBlock,
1004                      RenderObject* beforeChild, RenderBoxModelObject* oldCont);
1005     void splitFlow(RenderObject* beforeChild, RenderBlock* newBlockBox,
1006                    RenderObject* newChild, RenderBoxModelObject* oldCont);
1007     RenderBlock* clone() const;
1008     RenderBlock* continuationBefore(RenderObject* beforeChild);
1009     RenderBlock* containingColumnsBlock(bool allowAnonymousColumnBlock = true);
1010     RenderBlock* columnsBlockForSpanningElement(RenderObject* newChild);
1011
1012     class MarginInfo {
1013         // Collapsing flags for whether we can collapse our margins with our children's margins.
1014         bool m_canCollapseWithChildren : 1;
1015         bool m_canCollapseMarginBeforeWithChildren : 1;
1016         bool m_canCollapseMarginAfterWithChildren : 1;
1017
1018         // Whether or not we are a quirky container, i.e., do we collapse away top and bottom
1019         // margins in our container.  Table cells and the body are the common examples. We
1020         // also have a custom style property for Safari RSS to deal with TypePad blog articles.
1021         bool m_quirkContainer : 1;
1022
1023         // This flag tracks whether we are still looking at child margins that can all collapse together at the beginning of a block.  
1024         // They may or may not collapse with the top margin of the block (|m_canCollapseTopWithChildren| tells us that), but they will
1025         // always be collapsing with one another.  This variable can remain set to true through multiple iterations 
1026         // as long as we keep encountering self-collapsing blocks.
1027         bool m_atBeforeSideOfBlock : 1;
1028
1029         // This flag is set when we know we're examining bottom margins and we know we're at the bottom of the block.
1030         bool m_atAfterSideOfBlock : 1;
1031
1032         // These variables are used to detect quirky margins that we need to collapse away (in table cells
1033         // and in the body element).
1034         bool m_hasMarginBeforeQuirk : 1;
1035         bool m_hasMarginAfterQuirk : 1;
1036         bool m_determinedMarginBeforeQuirk : 1;
1037
1038         bool m_discardMargin : 1;
1039
1040         // These flags track the previous maximal positive and negative margins.
1041         LayoutUnit m_positiveMargin;
1042         LayoutUnit m_negativeMargin;
1043
1044     public:
1045         MarginInfo(RenderBlock*, LayoutUnit beforeBorderPadding, LayoutUnit afterBorderPadding);
1046
1047         void setAtBeforeSideOfBlock(bool b) { m_atBeforeSideOfBlock = b; }
1048         void setAtAfterSideOfBlock(bool b) { m_atAfterSideOfBlock = b; }
1049         void clearMargin()
1050         {
1051             m_positiveMargin = 0;
1052             m_negativeMargin = 0;
1053         }
1054         void setHasMarginBeforeQuirk(bool b) { m_hasMarginBeforeQuirk = b; }
1055         void setHasMarginAfterQuirk(bool b) { m_hasMarginAfterQuirk = b; }
1056         void setDeterminedMarginBeforeQuirk(bool b) { m_determinedMarginBeforeQuirk = b; }
1057         void setPositiveMargin(LayoutUnit p) { ASSERT(!m_discardMargin); m_positiveMargin = p; }
1058         void setNegativeMargin(LayoutUnit n) { ASSERT(!m_discardMargin); m_negativeMargin = n; }
1059         void setPositiveMarginIfLarger(LayoutUnit p)
1060         {
1061             ASSERT(!m_discardMargin);
1062             if (p > m_positiveMargin)
1063                 m_positiveMargin = p;
1064         }
1065         void setNegativeMarginIfLarger(LayoutUnit n)
1066         {
1067             ASSERT(!m_discardMargin);
1068             if (n > m_negativeMargin)
1069                 m_negativeMargin = n;
1070         }
1071
1072         void setMargin(LayoutUnit p, LayoutUnit n) { ASSERT(!m_discardMargin); m_positiveMargin = p; m_negativeMargin = n; }
1073         void setCanCollapseMarginAfterWithChildren(bool collapse) { m_canCollapseMarginAfterWithChildren = collapse; }
1074         void setDiscardMargin(bool value) { m_discardMargin = value; }
1075
1076         bool atBeforeSideOfBlock() const { return m_atBeforeSideOfBlock; }
1077         bool canCollapseWithMarginBefore() const { return m_atBeforeSideOfBlock && m_canCollapseMarginBeforeWithChildren; }
1078         bool canCollapseWithMarginAfter() const { return m_atAfterSideOfBlock && m_canCollapseMarginAfterWithChildren; }
1079         bool canCollapseMarginBeforeWithChildren() const { return m_canCollapseMarginBeforeWithChildren; }
1080         bool canCollapseMarginAfterWithChildren() const { return m_canCollapseMarginAfterWithChildren; }
1081         bool quirkContainer() const { return m_quirkContainer; }
1082         bool determinedMarginBeforeQuirk() const { return m_determinedMarginBeforeQuirk; }
1083         bool hasMarginBeforeQuirk() const { return m_hasMarginBeforeQuirk; }
1084         bool hasMarginAfterQuirk() const { return m_hasMarginAfterQuirk; }
1085         LayoutUnit positiveMargin() const { return m_positiveMargin; }
1086         LayoutUnit negativeMargin() const { return m_negativeMargin; }
1087         bool discardMargin() const { return m_discardMargin; }
1088         LayoutUnit margin() const { return m_positiveMargin - m_negativeMargin; }
1089     };
1090
1091     void layoutBlockChild(RenderBox* child, MarginInfo&, LayoutUnit& previousFloatLogicalBottom, LayoutUnit& maxFloatLogicalBottom);
1092     void adjustPositionedBlock(RenderBox* child, const MarginInfo&);
1093     void adjustFloatingBlock(const MarginInfo&);
1094
1095     RenderBoxModelObject* createReplacementRunIn(RenderBoxModelObject* runIn);
1096     void moveRunInUnderSiblingBlockIfNeeded(RenderObject* runIn);
1097     void moveRunInToOriginalPosition(RenderObject* runIn);
1098
1099     LayoutUnit collapseMargins(RenderBox* child, MarginInfo&);
1100     LayoutUnit clearFloatsIfNeeded(RenderBox* child, MarginInfo&, LayoutUnit oldTopPosMargin, LayoutUnit oldTopNegMargin, LayoutUnit yPos);
1101     LayoutUnit estimateLogicalTopPosition(RenderBox* child, const MarginInfo&, LayoutUnit& estimateWithoutPagination);
1102     void marginBeforeEstimateForChild(RenderBox*, LayoutUnit&, LayoutUnit&, bool&) const;
1103     void handleAfterSideOfBlock(LayoutUnit top, LayoutUnit bottom, MarginInfo&);
1104     void setCollapsedBottomMargin(const MarginInfo&);
1105     // End helper functions and structs used by layoutBlockChildren.
1106
1107     // Helper function for layoutInlineChildren()
1108     RootInlineBox* createLineBoxesFromBidiRuns(BidiRunList<BidiRun>&, const InlineIterator& end, LineInfo&, VerticalPositionCache&, BidiRun* trailingSpaceRun, WordMeasurements&);
1109     void layoutRunsAndFloats(LineLayoutState&, bool hasInlineChild);
1110     void layoutRunsAndFloatsInRange(LineLayoutState&, InlineBidiResolver&, const InlineIterator& cleanLineStart, const BidiStatus& cleanLineBidiStatus, unsigned consecutiveHyphenatedLines);
1111 #if ENABLE(CSS_SHAPES)
1112     void updateShapeAndSegmentsForCurrentLine(ShapeInsideInfo*&, LayoutUnit&, LineLayoutState&);
1113     void updateShapeAndSegmentsForCurrentLineInFlowThread(ShapeInsideInfo*&, LineLayoutState&);
1114     bool adjustLogicalLineTopAndLogicalHeightIfNeeded(ShapeInsideInfo*, LayoutUnit, LineLayoutState&, InlineBidiResolver&, FloatingObject*, InlineIterator&, WordMeasurements&);
1115 #endif
1116     const InlineIterator& restartLayoutRunsAndFloatsInRange(LayoutUnit oldLogicalHeight, LayoutUnit newLogicalHeight,  FloatingObject* lastFloatFromPreviousLine, InlineBidiResolver&,  const InlineIterator&);
1117     void linkToEndLineIfNeeded(LineLayoutState&);
1118     static void repaintDirtyFloats(Vector<FloatWithRect>& floats);
1119
1120 protected:
1121     void dirtyForLayoutFromPercentageHeightDescendants();
1122     
1123     void determineLogicalLeftPositionForChild(RenderBox* child, ApplyLayoutDeltaMode = DoNotApplyLayoutDelta);
1124
1125     // Pagination routines.
1126     virtual bool relayoutForPagination(bool hasSpecifiedPageLogicalHeight, LayoutUnit pageLogicalHeight, LayoutStateMaintainer&);
1127     
1128     // Returns the logicalOffset at the top of the next page. If the offset passed in is already at the top of the current page,
1129     // then nextPageLogicalTop with ExcludePageBoundary will still move to the top of the next page. nextPageLogicalTop with
1130     // IncludePageBoundary set will not.
1131     //
1132     // 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.
1133     enum PageBoundaryRule { ExcludePageBoundary, IncludePageBoundary };
1134     LayoutUnit nextPageLogicalTop(LayoutUnit logicalOffset, PageBoundaryRule = ExcludePageBoundary) const;
1135     bool hasNextPage(LayoutUnit logicalOffset, PageBoundaryRule = ExcludePageBoundary) const;
1136
1137     virtual ColumnInfo::PaginationUnit paginationUnit() const;
1138
1139     LayoutUnit applyBeforeBreak(RenderBox* child, LayoutUnit logicalOffset); // If the child has a before break, then return a new yPos that shifts to the top of the next page/column.
1140     LayoutUnit applyAfterBreak(RenderBox* child, LayoutUnit logicalOffset, MarginInfo&); // If the child has an after break, then return a new offset that shifts to the top of the next page/column.
1141
1142 public:
1143     LayoutUnit pageLogicalTopForOffset(LayoutUnit offset) const;
1144     LayoutUnit pageLogicalHeightForOffset(LayoutUnit offset) const;
1145     LayoutUnit pageRemainingLogicalHeightForOffset(LayoutUnit offset, PageBoundaryRule = IncludePageBoundary) const;
1146     
1147 protected:
1148     bool pushToNextPageWithMinimumLogicalHeight(LayoutUnit& adjustment, LayoutUnit logicalOffset, LayoutUnit minimumLogicalHeight) const;
1149
1150     // A page break is required at some offset due to space shortage in the current fragmentainer.
1151     void setPageBreak(LayoutUnit offset, LayoutUnit spaceShortage);
1152
1153     // Update minimum page height required to avoid fragmentation where it shouldn't occur (inside
1154     // unbreakable content, between orphans and widows, etc.). This will be used as a hint to the
1155     // column balancer to help set a good minimum column height.
1156     void updateMinimumPageHeight(LayoutUnit offset, LayoutUnit minHeight);
1157
1158     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.
1159     void adjustLinePositionForPagination(RootInlineBox*, LayoutUnit& deltaOffset, RenderFlowThread*); // Computes a deltaOffset value that put a line at the top of the next page if it doesn't fit on the current page.
1160     LayoutUnit adjustBlockChildForPagination(LayoutUnit logicalTopAfterClear, LayoutUnit estimateWithoutPagination, RenderBox* child, bool atBeforeSideOfBlock);
1161
1162     // Adjust from painting offsets to the local coords of this renderer
1163     void offsetForContents(LayoutPoint&) const;
1164
1165     // 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
1166     // region/page/column that has a different available line width than the old one. Used to know when you have to dirty a
1167     // line, i.e., that it can't be re-used.
1168     bool lineWidthForPaginatedLineChanged(RootInlineBox*, LayoutUnit lineDelta, RenderFlowThread*) const;
1169
1170     bool logicalWidthChangedInRegions(RenderFlowThread*) const;
1171
1172     virtual bool requiresColumns(int desiredColumnCount) const;
1173
1174     virtual bool updateLogicalWidthAndColumnWidth();
1175
1176     virtual bool canCollapseAnonymousBlockChild() const { return true; }
1177
1178 public:
1179     virtual LayoutUnit offsetFromLogicalTopOfFirstPage() const;
1180     RenderRegion* regionAtBlockOffset(LayoutUnit) const;
1181
1182 protected:
1183     struct FloatingObjectHashFunctions {
1184         static unsigned hash(FloatingObject* key) { return DefaultHash<RenderBox*>::Hash::hash(key->renderer()); }
1185         static bool equal(FloatingObject* a, FloatingObject* b) { return a->renderer() == b->renderer(); }
1186         static const bool safeToCompareToEmptyOrDeleted = true;
1187     };
1188     struct FloatingObjectHashTranslator {
1189         static unsigned hash(RenderBox* key) { return DefaultHash<RenderBox*>::Hash::hash(key); }
1190         static bool equal(FloatingObject* a, RenderBox* b) { return a->renderer() == b; }
1191     };
1192     typedef ListHashSet<FloatingObject*, 4, FloatingObjectHashFunctions> FloatingObjectSet;
1193     typedef FloatingObjectSet::const_iterator FloatingObjectSetIterator;
1194     typedef PODInterval<int, FloatingObject*> FloatingObjectInterval;
1195     typedef PODIntervalTree<int, FloatingObject*> FloatingObjectTree;
1196     typedef PODFreeListArena<PODRedBlackTree<FloatingObjectInterval>::Node> IntervalArena;
1197     
1198     template <FloatingObject::Type FloatTypeValue>
1199     class FloatIntervalSearchAdapter {
1200     public:
1201         typedef FloatingObjectInterval IntervalType;
1202         
1203         FloatIntervalSearchAdapter(const RenderBlock* renderer, int lowValue, int highValue, LayoutUnit& offset, LayoutUnit* heightRemaining)
1204             : m_renderer(renderer)
1205             , m_lowValue(lowValue)
1206             , m_highValue(highValue)
1207             , m_offset(offset)
1208             , m_heightRemaining(heightRemaining)
1209 #if ENABLE(CSS_SHAPES)
1210             , m_last(0)
1211 #endif
1212         {
1213         }
1214         
1215         inline int lowValue() const { return m_lowValue; }
1216         inline int highValue() const { return m_highValue; }
1217         void collectIfNeeded(const IntervalType&) const;
1218
1219 #if ENABLE(CSS_SHAPES)
1220         // When computing the offset caused by the floats on a given line, if
1221         // the outermost float on that line has a shape-outside, the inline
1222         // content that butts up against that float must be positioned using
1223         // the contours of the shape, not the margin box of the float.
1224         // We save the last float encountered so that the offset can be
1225         // computed correctly by the code using this adapter.
1226         const FloatingObject* lastFloat() const { return m_last; }
1227 #endif
1228
1229     private:
1230         const RenderBlock* m_renderer;
1231         int m_lowValue;
1232         int m_highValue;
1233         LayoutUnit& m_offset;
1234         LayoutUnit* m_heightRemaining;
1235 #if ENABLE(CSS_SHAPES)
1236         // This member variable is mutable because the collectIfNeeded method
1237         // is declared as const, even though it doesn't actually respect that
1238         // contract. It modifies other member variables via loopholes in the
1239         // const behavior. Instead of using loopholes, I decided it was better
1240         // to make the fact that this is modified in a const method explicit.
1241         mutable const FloatingObject* m_last;
1242 #endif
1243     };
1244
1245     void createFloatingObjects();
1246
1247 public:
1248
1249     class FloatingObjects {
1250         WTF_MAKE_NONCOPYABLE(FloatingObjects); WTF_MAKE_FAST_ALLOCATED;
1251     public:
1252         void clear();
1253         void add(FloatingObject*);
1254         void remove(FloatingObject*);
1255         void addPlacedObject(FloatingObject*);
1256         void removePlacedObject(FloatingObject*);
1257         void setHorizontalWritingMode(bool b = true) { m_horizontalWritingMode = b; }
1258
1259         bool hasLeftObjects() const { return m_leftObjectsCount > 0; }
1260         bool hasRightObjects() const { return m_rightObjectsCount > 0; }
1261         const FloatingObjectSet& set() const { return m_set; }
1262         const FloatingObjectTree& placedFloatsTree()
1263         {
1264             computePlacedFloatsTreeIfNeeded();
1265             return m_placedFloatsTree; 
1266         }
1267     private:
1268         FloatingObjects(const RenderBlock*, bool horizontalWritingMode);
1269         void computePlacedFloatsTree();
1270         inline void computePlacedFloatsTreeIfNeeded()
1271         {
1272             if (!m_placedFloatsTree.isInitialized())
1273                 computePlacedFloatsTree();
1274         }
1275         void increaseObjectsCount(FloatingObject::Type);
1276         void decreaseObjectsCount(FloatingObject::Type);
1277         FloatingObjectInterval intervalForFloatingObject(FloatingObject*);
1278
1279         FloatingObjectSet m_set;
1280         FloatingObjectTree m_placedFloatsTree;
1281         unsigned m_leftObjectsCount;
1282         unsigned m_rightObjectsCount;
1283         bool m_horizontalWritingMode;
1284         const RenderBlock* m_renderer;
1285
1286         friend void RenderBlock::createFloatingObjects();
1287     };
1288
1289     // Allocated only when some of these fields have non-default values
1290     struct RenderBlockRareData {
1291         WTF_MAKE_NONCOPYABLE(RenderBlockRareData); WTF_MAKE_FAST_ALLOCATED;
1292     public:
1293         RenderBlockRareData(const RenderBlock* block) 
1294             : m_margins(positiveMarginBeforeDefault(block), negativeMarginBeforeDefault(block), positiveMarginAfterDefault(block), negativeMarginAfterDefault(block))
1295             , m_paginationStrut(0)
1296             , m_pageLogicalOffset(0)
1297             , m_lineGridBox(0)
1298             , m_lineBreakToAvoidWidow(-1)
1299             , m_shouldBreakAtLineToAvoidWidow(false)
1300             , m_discardMarginBefore(false)
1301             , m_discardMarginAfter(false)
1302         { 
1303         }
1304
1305         static LayoutUnit positiveMarginBeforeDefault(const RenderBlock* block)
1306         { 
1307             return std::max<LayoutUnit>(block->marginBefore(), 0);
1308         }
1309         static LayoutUnit negativeMarginBeforeDefault(const RenderBlock* block)
1310         { 
1311             return std::max<LayoutUnit>(-block->marginBefore(), 0);
1312         }
1313         static LayoutUnit positiveMarginAfterDefault(const RenderBlock* block)
1314         {
1315             return std::max<LayoutUnit>(block->marginAfter(), 0);
1316         }
1317         static LayoutUnit negativeMarginAfterDefault(const RenderBlock* block)
1318         {
1319             return std::max<LayoutUnit>(-block->marginAfter(), 0);
1320         }
1321         
1322         MarginValues m_margins;
1323         LayoutUnit m_paginationStrut;
1324         LayoutUnit m_pageLogicalOffset;
1325         
1326         RootInlineBox* m_lineGridBox;
1327
1328         int m_lineBreakToAvoidWidow;
1329 #if ENABLE(CSS_SHAPES)
1330         OwnPtr<ShapeInsideInfo> m_shapeInsideInfo;
1331 #endif
1332         bool m_shouldBreakAtLineToAvoidWidow : 1;
1333         bool m_discardMarginBefore : 1;
1334         bool m_discardMarginAfter : 1;
1335      };
1336
1337 protected:
1338
1339     OwnPtr<FloatingObjects> m_floatingObjects;
1340     OwnPtr<RenderBlockRareData> m_rareData;
1341
1342     RenderObjectChildList m_children;
1343     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>.
1344
1345     mutable signed m_lineHeight : 27;
1346     unsigned m_hasMarginBeforeQuirk : 1; // Note these quirk values can't be put in RenderBlockRareData since they are set too frequently.
1347     unsigned m_hasMarginAfterQuirk : 1;
1348     unsigned m_beingDestroyed : 1;
1349     unsigned m_hasMarkupTruncation : 1;
1350     unsigned m_hasBorderOrPaddingLogicalWidthChanged : 1;
1351
1352     // RenderRubyBase objects need to be able to split and merge, moving their children around
1353     // (calling moveChildTo, moveAllChildrenTo, and makeChildrenNonInline).
1354     friend class RenderRubyBase;
1355     friend class LineWidth; // Needs to know FloatingObject
1356
1357 private:
1358     // Used to store state between styleWillChange and styleDidChange
1359     static bool s_canPropagateFloatIntoSibling;
1360 };
1361
1362 inline RenderBlock* toRenderBlock(RenderObject* object)
1363
1364     ASSERT_WITH_SECURITY_IMPLICATION(!object || object->isRenderBlock());
1365     return static_cast<RenderBlock*>(object);
1366 }
1367
1368 inline const RenderBlock* toRenderBlock(const RenderObject* object)
1369
1370     ASSERT_WITH_SECURITY_IMPLICATION(!object || object->isRenderBlock());
1371     return static_cast<const RenderBlock*>(object);
1372 }
1373
1374 // This will catch anyone doing an unnecessary cast.
1375 void toRenderBlock(const RenderBlock*);
1376
1377 #ifndef NDEBUG
1378 // These structures are used by PODIntervalTree for debugging purposes.
1379 template <> struct ValueToString<int> {
1380     static String string(const int value);
1381 };
1382 template<> struct ValueToString<RenderBlock::FloatingObject*> {
1383     static String string(const RenderBlock::FloatingObject*);
1384 };
1385 #endif
1386
1387 } // namespace WebCore
1388
1389 #endif // RenderBlock_h