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*, unsigned baseTypeFlags);
 101     virtual ~RenderBlock();
 102
 103 public:
 104     static RenderBlock* createAnonymous(Document&);
 105
 106     bool beingDestroyed() const { return m_beingDestroyed; }
 107
 108     // These two functions are overridden for inline-block.
 109     virtual LayoutUnit lineHeight(bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const OVERRIDE FINAL;
 110     virtual int baselinePosition(FontBaseline, bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const OVERRIDE;
 111
 112     LayoutUnit minLineHeightForReplacedRenderer(bool isFirstLine, LayoutUnit replacedHeight) const;
 113
 114     RenderLineBoxList& lineBoxes() { return m_lineBoxes; }
 115     const RenderLineBoxList& lineBoxes() const { return m_lineBoxes; }
 116
 117     InlineFlowBox* firstLineBox() const { return m_lineBoxes.firstLineBox(); }
 118     InlineFlowBox* lastLineBox() const { return m_lineBoxes.lastLineBox(); }
 119
 120     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
 121     virtual void deleteLineBoxTree();
 122
 123     virtual void addChild(RenderObject* newChild, RenderObject* beforeChild = 0) OVERRIDE;
 124     virtual void removeChild(RenderObject*) OVERRIDE;
 125
 126     virtual void layoutBlock(bool relayoutChildren, LayoutUnit pageLogicalHeight = 0);
 127
 128     void insertPositionedObject(RenderBox*);
 129     static void removePositionedObject(RenderBox*);
 130     void removePositionedObjects(RenderBlock*, ContainingBlockState = SameContainingBlock);
 131
 132     TrackedRendererListHashSet* positionedObjects() const;
 133     bool hasPositionedObjects() const
 134     {
 135         TrackedRendererListHashSet* objects = positionedObjects();
 136         return objects && !objects->isEmpty();
 137     }
 138
 139     void addPercentHeightDescendant(RenderBox*);
 140     static void removePercentHeightDescendant(RenderBox*);
 141     TrackedRendererListHashSet* percentHeightDescendants() const;
 142     static bool hasPercentHeightContainerMap();
 143     static bool hasPercentHeightDescendant(RenderBox*);
 144     static void clearPercentHeightDescendantsFrom(RenderBox*);
 145     static void removePercentHeightDescendantIfNeeded(RenderBox*);
 146
 147     void setHasMarkupTruncation(bool b) { m_hasMarkupTruncation = b; }
 148     bool hasMarkupTruncation() const { return m_hasMarkupTruncation; }
 149
 150     void setHasMarginBeforeQuirk(bool b) { m_hasMarginBeforeQuirk = b; }
 151     void setHasMarginAfterQuirk(bool b) { m_hasMarginAfterQuirk = b; }
 152
 153     bool hasMarginBeforeQuirk() const { return m_hasMarginBeforeQuirk; }
 154     bool hasMarginAfterQuirk() const { return m_hasMarginAfterQuirk; }
 155
 156     bool hasMarginBeforeQuirk(const RenderBox* child) const;
 157     bool hasMarginAfterQuirk(const RenderBox* child) const;
 158
 159     RootInlineBox* createAndAppendRootInlineBox();
 160
 161     bool generatesLineBoxesForInlineChild(RenderObject*);
 162
 163     void markPositionedObjectsForLayout();
 164     virtual void markForPaginationRelayoutIfNeeded() OVERRIDE FINAL;
 165
 166     // FIXME-BLOCKFLOW: Remove virtualizaion when all of the line layout code has been moved out of RenderBlock
 167     virtual bool containsFloats() const { return false; }
 168
 169     // Versions that can compute line offsets with the region and page offset passed in. Used for speed to avoid having to
 170     // compute the region all over again when you already know it.
 171     LayoutUnit availableLogicalWidthForLine(LayoutUnit position, bool shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const
 172     {
 173         return max<LayoutUnit>(0, logicalRightOffsetForLine(position, shouldIndentText, region, logicalHeight)
 174             - logicalLeftOffsetForLine(position, shouldIndentText, region, logicalHeight));
 175     }
 176     LayoutUnit logicalRightOffsetForLine(LayoutUnit position, bool shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const
 177     {
 178         return logicalRightOffsetForLine(position, logicalRightOffsetForContent(region), shouldIndentText, 0, logicalHeight);
 179     }
 180     LayoutUnit logicalLeftOffsetForLine(LayoutUnit position, bool shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const
 181     {
 182         return logicalLeftOffsetForLine(position, logicalLeftOffsetForContent(region), shouldIndentText, 0, logicalHeight);
 183     }
 184     LayoutUnit startOffsetForLine(LayoutUnit position, bool shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const
 185     {
 186         return style()->isLeftToRightDirection() ? logicalLeftOffsetForLine(position, shouldIndentText, region, logicalHeight)
 187             : logicalWidth() - logicalRightOffsetForLine(position, shouldIndentText, region, logicalHeight);
 188     }
 189     LayoutUnit endOffsetForLine(LayoutUnit position, bool shouldIndentText, RenderRegion* region, LayoutUnit logicalHeight = 0) const
 190     {
 191         return !style()->isLeftToRightDirection() ? logicalLeftOffsetForLine(position, shouldIndentText, region, logicalHeight)
 192             : logicalWidth() - logicalRightOffsetForLine(position, shouldIndentText, region, logicalHeight);
 193     }
 194
 195     LayoutUnit availableLogicalWidthForLine(LayoutUnit position, bool shouldIndentText, LayoutUnit logicalHeight = 0) const
 196     {
 197         return availableLogicalWidthForLine(position, shouldIndentText, regionAtBlockOffset(position), logicalHeight);
 198     }
 199     LayoutUnit logicalRightOffsetForLine(LayoutUnit position, bool shouldIndentText, LayoutUnit logicalHeight = 0) const
 200     {
 201         return logicalRightOffsetForLine(position, logicalRightOffsetForContent(position), shouldIndentText, 0, logicalHeight);
 202     }
 203     LayoutUnit logicalLeftOffsetForLine(LayoutUnit position, bool shouldIndentText, LayoutUnit logicalHeight = 0) const
 204     {
 205         return logicalLeftOffsetForLine(position, logicalLeftOffsetForContent(position), shouldIndentText, 0, logicalHeight);
 206     }
 207     LayoutUnit pixelSnappedLogicalLeftOffsetForLine(LayoutUnit position, bool shouldIndentText, LayoutUnit logicalHeight = 0) const
 208     {
 209         return roundToInt(logicalLeftOffsetForLine(position, shouldIndentText, logicalHeight));
 210     }
 211     LayoutUnit pixelSnappedLogicalRightOffsetForLine(LayoutUnit position, bool shouldIndentText, LayoutUnit logicalHeight = 0) const
 212     {
 213         // FIXME: Multicolumn layouts break carrying over subpixel values to the logical right offset because the lines may be shifted
 214         // by a subpixel value for all but the first column. This can lead to the actual pixel snapped width of the column being off
 215         // by one pixel when rendered versus layed out, which can result in the line being clipped. For now, we have to floor.
 216         // https://bugs.webkit.org/show_bug.cgi?id=105461
 217         return floorToInt(logicalRightOffsetForLine(position, shouldIndentText, logicalHeight));
 218     }
 219     LayoutUnit startOffsetForLine(LayoutUnit position, bool shouldIndentText, LayoutUnit logicalHeight = 0) const
 220     {
 221         return style()->isLeftToRightDirection() ? logicalLeftOffsetForLine(position, shouldIndentText, logicalHeight)
 222             : logicalWidth() - logicalRightOffsetForLine(position, shouldIndentText, logicalHeight);
 223     }
 224     LayoutUnit endOffsetForLine(LayoutUnit position, bool shouldIndentText, LayoutUnit logicalHeight = 0) const
 225     {
 226         return !style()->isLeftToRightDirection() ? logicalLeftOffsetForLine(position, shouldIndentText, logicalHeight)
 227             : logicalWidth() - logicalRightOffsetForLine(position, shouldIndentText, logicalHeight);
 228     }
 229
 230     LayoutUnit startAlignedOffsetForLine(LayoutUnit position, bool shouldIndentText);
 231     LayoutUnit textIndentOffset() const;
 232
 233     virtual VisiblePosition positionForPoint(const LayoutPoint&) OVERRIDE;
 234
 235     // Block flows subclass availableWidth to handle multi column layout (shrinking the width available to children when laying out.)
 236     virtual LayoutUnit availableLogicalWidth() const OVERRIDE FINAL;
 237
 238     LayoutPoint flipForWritingModeIncludingColumns(const LayoutPoint&) const;
 239     void adjustStartEdgeForWritingModeIncludingColumns(LayoutRect&) const;
 240
 241     RootInlineBox* firstRootBox() const { return static_cast<RootInlineBox*>(firstLineBox()); }
 242     RootInlineBox* lastRootBox() const { return static_cast<RootInlineBox*>(lastLineBox()); }
 243
 244     bool containsNonZeroBidiLevel() const;
 245
 246     GapRects selectionGapRectsForRepaint(const RenderLayerModelObject* repaintContainer);
 247     LayoutRect logicalLeftSelectionGap(RenderBlock* rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
 248         RenderObject* selObj, LayoutUnit logicalLeft, LayoutUnit logicalTop, LayoutUnit logicalHeight, const LogicalSelectionOffsetCaches&, const PaintInfo*);
 249     LayoutRect logicalRightSelectionGap(RenderBlock* rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
 250         RenderObject* selObj, LayoutUnit logicalRight, LayoutUnit logicalTop, LayoutUnit logicalHeight, const LogicalSelectionOffsetCaches&, const PaintInfo*);
 251     void getSelectionGapInfo(SelectionState, bool& leftGap, bool& rightGap);
 252     RenderBlock* blockBeforeWithinSelectionRoot(LayoutSize& offset) const;
 253
 254     LayoutRect logicalRectToPhysicalRect(const LayoutPoint& physicalPosition, const LayoutRect& logicalRect);
 255
 256     // Helper methods for computing line counts and heights for line counts.
 257     RootInlineBox* lineAtIndex(int) const;
 258     int lineCount(const RootInlineBox* = 0, bool* = 0) const;
 259     int heightForLineCount(int);
 260     void clearTruncation();
 261
 262     void adjustRectForColumns(LayoutRect&) const;
 263     virtual void adjustForColumns(LayoutSize&, const LayoutPoint&) const OVERRIDE FINAL;
 264     void adjustForColumnRect(LayoutSize& offset, const LayoutPoint& locationInContainer) const;
 265
 266     void addContinuationWithOutline(RenderInline*);
 267     bool paintsContinuationOutline(RenderInline*);
 268
 269     virtual RenderBoxModelObject* virtualContinuation() const OVERRIDE FINAL { return continuation(); }
 270     bool isAnonymousBlockContinuation() const { return isAnonymousBlock() && continuation(); }
 271     RenderInline* inlineElementContinuation() const;
 272     RenderBlock* blockElementContinuation() const;
 273
 274     using RenderBoxModelObject::continuation;
 275     using RenderBoxModelObject::setContinuation;
 276
 277     static RenderBlock* createAnonymousWithParentRendererAndDisplay(const RenderObject*, EDisplay = BLOCK);
 278     static RenderBlock* createAnonymousColumnsWithParentRenderer(const RenderObject*);
 279     static RenderBlock* createAnonymousColumnSpanWithParentRenderer(const RenderObject*);
 280     RenderBlock* createAnonymousBlock(EDisplay display = BLOCK) const { return createAnonymousWithParentRendererAndDisplay(this, display); }
 281     RenderBlock* createAnonymousColumnsBlock() const { return createAnonymousColumnsWithParentRenderer(this); }
 282     RenderBlock* createAnonymousColumnSpanBlock() const { return createAnonymousColumnSpanWithParentRenderer(this); }
 283     static void collapseAnonymousBoxChild(RenderBlock* parent, RenderBlock* child);
 284
 285     virtual RenderBox* createAnonymousBoxWithSameTypeAs(const RenderObject* parent) const OVERRIDE;
 286
 287     static bool shouldSkipCreatingRunsForObject(RenderObject* obj)
 288     {
 289         return obj->isFloating() || (obj->isOutOfFlowPositioned() && !obj->style()->isOriginalDisplayInlineType() && !obj->container()->isRenderInline());
 290     }
 291
 292     static TextRun constructTextRun(RenderObject* context, const Font&, const String&, const RenderStyle&,
 293         TextRun::ExpansionBehavior = TextRun::AllowTrailingExpansion | TextRun::ForbidLeadingExpansion, TextRunFlags = DefaultTextRunFlags);
 294
 295     static TextRun constructTextRun(RenderObject* context, const Font&, const RenderText*, const RenderStyle&,
 296         TextRun::ExpansionBehavior = TextRun::AllowTrailingExpansion | TextRun::ForbidLeadingExpansion);
 297
 298     static TextRun constructTextRun(RenderObject* context, const Font&, const RenderText*, unsigned offset, unsigned length, const RenderStyle&,
 299         TextRun::ExpansionBehavior = TextRun::AllowTrailingExpansion | TextRun::ForbidLeadingExpansion);
 300
 301     static TextRun constructTextRun(RenderObject* context, const Font&, const RenderText*, unsigned offset, const RenderStyle&,
 302         TextRun::ExpansionBehavior = TextRun::AllowTrailingExpansion | TextRun::ForbidLeadingExpansion);
 303
 304 #if ENABLE(8BIT_TEXTRUN)
 305     static TextRun constructTextRun(RenderObject* context, const Font&, const LChar* characters, int length, const RenderStyle&,
 306         TextRun::ExpansionBehavior = TextRun::AllowTrailingExpansion | TextRun::ForbidLeadingExpansion);
 307 #endif
 308
 309     static TextRun constructTextRun(RenderObject* context, const Font&, const UChar* characters, int length, const RenderStyle&,
 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     // The page logical offset is the object's offset from the top of the page in the page progression
 328     // direction (so an x-offset in vertical text and a y-offset for horizontal text).
 329     LayoutUnit pageLogicalOffset() const { return m_rareData ? m_rareData->m_pageLogicalOffset : LayoutUnit(); }
 330     void setPageLogicalOffset(LayoutUnit);
 331
 332     // Accessors for logical width/height and margins in the containing block's block-flow direction.
 333     enum ApplyLayoutDeltaMode { ApplyLayoutDelta, DoNotApplyLayoutDelta };
 334     LayoutUnit logicalWidthForChild(const RenderBox* child) const { return isHorizontalWritingMode() ? child->width() : child->height(); }
 335     LayoutUnit logicalHeightForChild(const RenderBox* child) const { return isHorizontalWritingMode() ? child->height() : child->width(); }
 336     LayoutUnit logicalTopForChild(const RenderBox* child) const { return isHorizontalWritingMode() ? child->y() : child->x(); }
 337     void setLogicalLeftForChild(RenderBox* child, LayoutUnit logicalLeft, ApplyLayoutDeltaMode = DoNotApplyLayoutDelta);
 338     void setLogicalTopForChild(RenderBox* child, LayoutUnit logicalTop, ApplyLayoutDeltaMode = DoNotApplyLayoutDelta);
 339     LayoutUnit marginBeforeForChild(const RenderBoxModelObject* child) const { return child->marginBefore(style()); }
 340     LayoutUnit marginAfterForChild(const RenderBoxModelObject* child) const { return child->marginAfter(style()); }
 341     LayoutUnit marginStartForChild(const RenderBoxModelObject* child) const { return child->marginStart(style()); }
 342     LayoutUnit marginEndForChild(const RenderBoxModelObject* child) const { return child->marginEnd(style()); }
 343     void setMarginStartForChild(RenderBox* child, LayoutUnit value) const { child->setMarginStart(value, style()); }
 344     void setMarginEndForChild(RenderBox* child, LayoutUnit value) const { child->setMarginEnd(value, style()); }
 345     void setMarginBeforeForChild(RenderBox* child, LayoutUnit value) const { child->setMarginBefore(value, style()); }
 346     void setMarginAfterForChild(RenderBox* child, LayoutUnit value) const { child->setMarginAfter(value, style()); }
 347     LayoutUnit collapsedMarginBeforeForChild(const RenderBox* child) const;
 348     LayoutUnit collapsedMarginAfterForChild(const RenderBox* child) const;
 349
 350     void updateLogicalWidthForAlignment(const ETextAlign&, BidiRun* trailingSpaceRun, float& logicalLeft, float& totalLogicalWidth, float& availableLogicalWidth, int expansionOpportunityCount);
 351
 352     virtual void updateFirstLetter();
 353
 354     virtual void scrollbarsChanged(bool /*horizontalScrollbarChanged*/, bool /*verticalScrollbarChanged*/) { };
 355
 356     LayoutUnit logicalLeftOffsetForContent(RenderRegion*) const;
 357     LayoutUnit logicalRightOffsetForContent(RenderRegion*) const;
 358     LayoutUnit availableLogicalWidthForContent(RenderRegion* region) const
 359     {
 360         return max<LayoutUnit>(0, logicalRightOffsetForContent(region) - logicalLeftOffsetForContent(region)); }
 361     LayoutUnit startOffsetForContent(RenderRegion* region) const
 362     {
 363         return style()->isLeftToRightDirection() ? logicalLeftOffsetForContent(region) : logicalWidth() - logicalRightOffsetForContent(region);
 364     }
 365     LayoutUnit endOffsetForContent(RenderRegion* region) const
 366     {
 367         return !style()->isLeftToRightDirection() ? logicalLeftOffsetForContent(region) : logicalWidth() - logicalRightOffsetForContent(region);
 368     }
 369     LayoutUnit logicalLeftOffsetForContent(LayoutUnit blockOffset) const
 370     {
 371         return logicalLeftOffsetForContent(regionAtBlockOffset(blockOffset));
 372     }
 373     LayoutUnit logicalRightOffsetForContent(LayoutUnit blockOffset) const
 374     {
 375         return logicalRightOffsetForContent(regionAtBlockOffset(blockOffset));
 376     }
 377     LayoutUnit availableLogicalWidthForContent(LayoutUnit blockOffset) const
 378     {
 379         return availableLogicalWidthForContent(regionAtBlockOffset(blockOffset));
 380     }
 381     LayoutUnit startOffsetForContent(LayoutUnit blockOffset) const
 382     {
 383         return startOffsetForContent(regionAtBlockOffset(blockOffset));
 384     }
 385     LayoutUnit endOffsetForContent(LayoutUnit blockOffset) const
 386     {
 387         return endOffsetForContent(regionAtBlockOffset(blockOffset));
 388     }
 389     LayoutUnit logicalLeftOffsetForContent() const { return isHorizontalWritingMode() ? borderLeft() + paddingLeft() : borderTop() + paddingTop(); }
 390     LayoutUnit logicalRightOffsetForContent() const { return logicalLeftOffsetForContent() + availableLogicalWidth(); }
 391     LayoutUnit startOffsetForContent() const { return style()->isLeftToRightDirection() ? logicalLeftOffsetForContent() : logicalWidth() - logicalRightOffsetForContent(); }
 392     LayoutUnit endOffsetForContent() const { return !style()->isLeftToRightDirection() ? logicalLeftOffsetForContent() : logicalWidth() - logicalRightOffsetForContent(); }
 393
 394     void setStaticInlinePositionForChild(RenderBox*, LayoutUnit blockOffset, LayoutUnit inlinePosition);
 395     void updateStaticInlinePositionForChild(RenderBox*, LayoutUnit logicalTop);
 396
 397     LayoutUnit computeStartPositionDeltaForChildAvoidingFloats(const RenderBox* child, LayoutUnit childMarginStart, RenderRegion* = 0);
 398
 399     void placeRunInIfNeeded(RenderObject* newChild);
 400     bool runInIsPlacedIntoSiblingBlock(RenderObject* runIn);
 401
 402 #ifndef NDEBUG
 403     void checkPositionedObjectsNeedLayout();
 404     void showLineTreeAndMark(const InlineBox* = 0, const char* = 0, const InlineBox* = 0, const char* = 0, const RenderObject* = 0) const;
 405 #endif
 406
 407 #if ENABLE(IOS_TEXT_AUTOSIZING)
 408     int immediateLineCount();
 409     void adjustComputedFontSizes(float size, float visibleWidth);
 410     void resetComputedFontSize()
 411     {
 412         m_widthForTextAutosizing = -1;
 413         m_lineCountForTextAutosizing = NOT_SET;
 414     }
 415 #endif
 416
 417 #if ENABLE(CSS_SHAPES)
 418     ShapeInsideInfo* ensureShapeInsideInfo()
 419     {
 420         if (!m_rareData || !m_rareData->m_shapeInsideInfo)
 421             setShapeInsideInfo(ShapeInsideInfo::createInfo(this));
 422         return m_rareData->m_shapeInsideInfo.get();
 423     }
 424
 425     ShapeInsideInfo* shapeInsideInfo() const
 426     {
 427         if (!m_rareData || !m_rareData->m_shapeInsideInfo)
 428             return 0;
 429         return ShapeInsideInfo::isEnabledFor(this) ? m_rareData->m_shapeInsideInfo.get() : 0;
 430     }
 431     void setShapeInsideInfo(PassOwnPtr<ShapeInsideInfo> value)
 432     {
 433         if (!m_rareData)
 434             m_rareData = adoptPtr(new RenderBlockRareData());
 435         m_rareData->m_shapeInsideInfo = value;
 436     }
 437     void markShapeInsideDescendantsForLayout();
 438     ShapeInsideInfo* layoutShapeInsideInfo() const;
 439     bool allowsShapeInsideInfoSharing() const { return !isInline() && !isFloating(); }
 440     LayoutSize logicalOffsetFromShapeAncestorContainer(const RenderBlock* container) const;
 441     virtual void imageChanged(WrappedImagePtr, const IntRect* = 0) OVERRIDE;
 442 #endif
 443
 444     virtual void updateHitTestResult(HitTestResult&, const LayoutPoint&) OVERRIDE;
 445
 446 protected:
 447     virtual void willBeDestroyed() OVERRIDE;
 448
 449     virtual void layout() OVERRIDE;
 450
 451     void layoutPositionedObjects(bool relayoutChildren, bool fixedPositionObjectsOnly = false);
 452     void markFixedPositionObjectForLayoutIfNeeded(RenderObject* child);
 453
 454     virtual void paint(PaintInfo&, const LayoutPoint&) OVERRIDE;
 455     virtual void paintObject(PaintInfo&, const LayoutPoint&) OVERRIDE;
 456     virtual void paintChildren(PaintInfo& forSelf, const LayoutPoint&, PaintInfo& forChild, bool usePrintRect);
 457     bool paintChild(RenderBox*, PaintInfo& forSelf, const LayoutPoint&, PaintInfo& forChild, bool usePrintRect);
 458
 459     LayoutUnit logicalRightOffsetForLine(LayoutUnit logicalTop, LayoutUnit fixedOffset, bool applyTextIndent, LayoutUnit* heightRemaining = 0, LayoutUnit logicalHeight = 0) const
 460     {
 461         return adjustLogicalRightOffsetForLine(logicalRightFloatOffsetForLine(logicalTop, fixedOffset, heightRemaining, logicalHeight, ShapeOutsideFloatShapeOffset), applyTextIndent);
 462     }
 463     LayoutUnit logicalLeftOffsetForLine(LayoutUnit logicalTop, LayoutUnit fixedOffset, bool applyTextIndent, LayoutUnit* heightRemaining = 0, LayoutUnit logicalHeight = 0) const
 464     {
 465         return adjustLogicalLeftOffsetForLine(logicalLeftFloatOffsetForLine(logicalTop, fixedOffset, heightRemaining, logicalHeight, ShapeOutsideFloatShapeOffset), applyTextIndent);
 466     }
 467     LayoutUnit logicalRightOffsetForLineIgnoringShapeOutside(LayoutUnit logicalTop, LayoutUnit fixedOffset, bool applyTextIndent, LayoutUnit* heightRemaining = 0, LayoutUnit logicalHeight = 0) const
 468     {
 469         return adjustLogicalRightOffsetForLine(logicalRightFloatOffsetForLine(logicalTop, fixedOffset, heightRemaining, logicalHeight, ShapeOutsideFloatMarginBoxOffset), applyTextIndent);
 470     }
 471     LayoutUnit logicalLeftOffsetForLineIgnoringShapeOutside(LayoutUnit logicalTop, LayoutUnit fixedOffset, bool applyTextIndent, LayoutUnit* heightRemaining = 0, LayoutUnit logicalHeight = 0) const
 472     {
 473         return adjustLogicalLeftOffsetForLine(logicalLeftFloatOffsetForLine(logicalTop, fixedOffset, heightRemaining, logicalHeight, ShapeOutsideFloatMarginBoxOffset), applyTextIndent);
 474     }
 475
 476     virtual ETextAlign textAlignmentForLine(bool endsWithSoftBreak) const;
 477     virtual void adjustInlineDirectionLineBounds(int /* expansionOpportunityCount */, float& /* logicalLeft */, float& /* logicalWidth */) const { }
 478
 479     virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) OVERRIDE;
 480
 481     virtual void computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const OVERRIDE;
 482     virtual void computePreferredLogicalWidths() OVERRIDE;
 483     void adjustIntrinsicLogicalWidthsForColumns(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const;
 484
 485     virtual int firstLineBoxBaseline() const OVERRIDE;
 486     virtual int inlineBlockBaseline(LineDirectionMode) const OVERRIDE;
 487     int lastLineBoxBaseline(LineDirectionMode) const;
 488
 489     // Delay update scrollbar until finishDelayRepaint() will be
 490     // called. This function is used when a flexbox is laying out its
 491     // descendant. If multiple calls are made to startDelayRepaint(),
 492     // finishDelayRepaint() will do nothing until finishDelayRepaint()
 493     // is called the same number of times.
 494     static void startDelayUpdateScrollInfo();
 495     static void finishDelayUpdateScrollInfo();
 496
 497     void updateScrollInfoAfterLayout();
 498
 499     virtual void styleWillChange(StyleDifference, const RenderStyle* newStyle) OVERRIDE;
 500     virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle) OVERRIDE;
 501
 502     virtual bool hasLineIfEmpty() const;
 503
 504     bool simplifiedLayout();
 505     virtual void simplifiedNormalFlowLayout();
 506
 507     void setDesiredColumnCountAndWidth(int, LayoutUnit);
 508
 509 public:
 510     virtual void computeOverflow(LayoutUnit oldClientAfterEdge, bool recomputeFloats = false);
 511     void clearLayoutOverflow();
 512 protected:
 513     virtual void addOverflowFromChildren();
 514     void addOverflowFromPositionedObjects();
 515     void addOverflowFromBlockChildren();
 516     void addOverflowFromInlineChildren();
 517     void addVisualOverflowFromTheme();
 518
 519     virtual void addFocusRingRects(Vector<IntRect>&, const LayoutPoint& additionalOffset, const RenderLayerModelObject* paintContainer = 0) OVERRIDE;
 520
 521     bool updateShapesBeforeBlockLayout();
 522     void updateShapesAfterBlockLayout(bool heightChanged = false);
 523     void computeRegionRangeForBoxChild(const RenderBox*) const;
 524
 525     void estimateRegionRangeForBoxChild(const RenderBox*) const;
 526     bool updateRegionRangeForBoxChild(const RenderBox*) const;
 527
 528     void updateBlockChildDirtyBitsBeforeLayout(bool relayoutChildren, RenderBox*);
 529
 530     virtual void checkForPaginationLogicalHeightChange(LayoutUnit& pageLogicalHeight, bool& pageLogicalHeightChanged, bool& hasSpecifiedPageLogicalHeight);
 531
 532 private:
 533     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
 534     virtual LayoutUnit logicalRightFloatOffsetForLine(LayoutUnit, LayoutUnit fixedOffset, LayoutUnit*, LayoutUnit, ShapeOutsideFloatOffsetMode) const { return fixedOffset; };
 535     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
 536     virtual LayoutUnit logicalLeftFloatOffsetForLine(LayoutUnit, LayoutUnit fixedOffset, LayoutUnit*, LayoutUnit, ShapeOutsideFloatOffsetMode) const { return fixedOffset; }
 537     LayoutUnit adjustLogicalRightOffsetForLine(LayoutUnit offsetFromFloats, bool applyTextIndent) const;
 538     LayoutUnit adjustLogicalLeftOffsetForLine(LayoutUnit offsetFromFloats, bool applyTextIndent) const;
 539
 540 #if ENABLE(CSS_SHAPES)
 541     void computeShapeSize();
 542     void updateShapeInsideInfoAfterStyleChange(const ShapeValue*, const ShapeValue* oldShape);
 543     void relayoutShapeDescendantIfMoved(RenderBlock* child, LayoutSize offset);
 544 #endif
 545
 546     virtual const char* renderName() const OVERRIDE;
 547
 548     virtual bool isInlineBlockOrInlineTable() const OVERRIDE FINAL { return isInline() && isReplaced(); }
 549     virtual bool canHaveChildren() const OVERRIDE { return true; }
 550
 551     void makeChildrenNonInline(RenderObject* insertionPoint = 0);
 552     virtual void removeLeftoverAnonymousBlock(RenderBlock* child);
 553
 554     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
 555     virtual void moveAllChildrenIncludingFloatsTo(RenderBlock* toBlock, bool fullRemoveInsert) { moveAllChildrenTo(toBlock, fullRemoveInsert); }
 556
 557     void addChildToContinuation(RenderObject* newChild, RenderObject* beforeChild);
 558     virtual void addChildIgnoringContinuation(RenderObject* newChild, RenderObject* beforeChild) OVERRIDE;
 559     void addChildToAnonymousColumnBlocks(RenderObject* newChild, RenderObject* beforeChild);
 560
 561     void addChildIgnoringAnonymousColumnBlocks(RenderObject* newChild, RenderObject* beforeChild = 0);
 562
 563     virtual bool isSelfCollapsingBlock() const OVERRIDE FINAL;
 564
 565     void insertIntoTrackedRendererMaps(RenderBox* descendant, TrackedDescendantsMap*&, TrackedContainerMap*&);
 566     static void removeFromTrackedRendererMaps(RenderBox* descendant, TrackedDescendantsMap*&, TrackedContainerMap*&);
 567
 568     virtual RootInlineBox* createRootInlineBox(); // Subclassed by SVG and Ruby.
 569
 570     // Called to lay out the legend for a fieldset or the ruby text of a ruby run.
 571     virtual RenderObject* layoutSpecialExcludedChild(bool /*relayoutChildren*/) { return 0; }
 572
 573     void createFirstLetterRenderer(RenderObject* firstLetterBlock, RenderText* currentTextChild);
 574     void updateFirstLetterStyle(RenderObject* firstLetterBlock, RenderObject* firstLetterContainer);
 575
 576     Node* nodeForHitTest() const;
 577
 578     struct FloatWithRect {
 579         FloatWithRect(RenderBox* f)
 580             : object(f)
 581             , rect(LayoutRect(f->x() - f->marginLeft(), f->y() - f->marginTop(), f->width() + f->marginWidth(), f->height() + f->marginHeight()))
 582             , everHadLayout(f->everHadLayout())
 583         {
 584         }
 585
 586         RenderBox* object;
 587         LayoutRect rect;
 588         bool everHadLayout;
 589     };
 590
 591     LayoutPoint flipFloatForWritingModeForChild(const FloatingObject*, const LayoutPoint&) const;
 592
 593     LayoutUnit xPositionForFloatIncludingMargin(const FloatingObject* child) const
 594     {
 595         if (isHorizontalWritingMode())
 596             return child->x() + child->renderer().marginLeft();
 597         else
 598             return child->x() + marginBeforeForChild(&child->renderer());
 599     }
 600
 601     LayoutUnit yPositionForFloatIncludingMargin(const FloatingObject* child) const
 602     {
 603         if (isHorizontalWritingMode())
 604             return child->y() + marginBeforeForChild(&child->renderer());
 605         else
 606             return child->y() + child->renderer().marginTop();
 607     }
 608
 609     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
 610     virtual void paintFloats(PaintInfo&, const LayoutPoint&, bool) { }
 611     void paintContents(PaintInfo&, const LayoutPoint&);
 612     void paintColumnContents(PaintInfo&, const LayoutPoint&, bool paintFloats = false);
 613     void paintColumnRules(PaintInfo&, const LayoutPoint&);
 614     void paintSelection(PaintInfo&, const LayoutPoint&);
 615     void paintCaret(PaintInfo&, const LayoutPoint&, CaretType);
 616
 617     virtual bool avoidsFloats() const OVERRIDE;
 618
 619     bool hitTestColumns(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction);
 620     virtual bool hitTestContents(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction);
 621     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
 622     virtual bool hitTestFloats(const HitTestRequest&, HitTestResult&, const HitTestLocation&, const LayoutPoint&) { return false; }
 623
 624     virtual bool isPointInOverflowControl(HitTestResult&, const LayoutPoint& locationInContainer, const LayoutPoint& accumulatedOffset);
 625
 626     // FIXME: Make this method const so we can remove the const_cast in computeIntrinsicLogicalWidths.
 627     void computeInlinePreferredLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth);
 628     void computeBlockPreferredLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const;
 629
 630     // Obtains the nearest enclosing block (including this block) that contributes a first-line style to our inline
 631     // children.
 632     virtual RenderBlock* firstLineBlock() const OVERRIDE;
 633
 634     virtual LayoutRect rectWithOutlineForRepaint(const RenderLayerModelObject* repaintContainer, LayoutUnit outlineWidth) const OVERRIDE FINAL;
 635     virtual RenderStyle* outlineStyleForRepaint() const OVERRIDE FINAL;
 636
 637     virtual RenderElement* hoverAncestor() const OVERRIDE FINAL;
 638     virtual void updateDragState(bool dragOn) OVERRIDE FINAL;
 639     virtual void childBecameNonInline(RenderObject* child) OVERRIDE FINAL;
 640
 641     virtual LayoutRect selectionRectForRepaint(const RenderLayerModelObject* repaintContainer, bool /*clipToVisibleContent*/) OVERRIDE FINAL
 642     {
 643         return selectionGapRectsForRepaint(repaintContainer);
 644     }
 645     virtual bool shouldPaintSelectionGaps() const OVERRIDE FINAL;
 646     bool isSelectionRoot() const;
 647     GapRects selectionGaps(RenderBlock* rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
 648         LayoutUnit& lastLogicalTop, LayoutUnit& lastLogicalLeft, LayoutUnit& lastLogicalRight, const LogicalSelectionOffsetCaches&, const PaintInfo* = 0);
 649     GapRects inlineSelectionGaps(RenderBlock* rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
 650         LayoutUnit& lastLogicalTop, LayoutUnit& lastLogicalLeft, LayoutUnit& lastLogicalRight, const LogicalSelectionOffsetCaches&, const PaintInfo*);
 651     GapRects blockSelectionGaps(RenderBlock* rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
 652         LayoutUnit& lastLogicalTop, LayoutUnit& lastLogicalLeft, LayoutUnit& lastLogicalRight, const LogicalSelectionOffsetCaches&, const PaintInfo*);
 653     LayoutRect blockSelectionGap(RenderBlock* rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
 654         LayoutUnit lastLogicalTop, LayoutUnit lastLogicalLeft, LayoutUnit lastLogicalRight, LayoutUnit logicalBottom, const LogicalSelectionOffsetCaches&, const PaintInfo*);
 655     LayoutUnit logicalLeftSelectionOffset(RenderBlock* rootBlock, LayoutUnit position, const LogicalSelectionOffsetCaches&);
 656     LayoutUnit logicalRightSelectionOffset(RenderBlock* rootBlock, LayoutUnit position, const LogicalSelectionOffsetCaches&);
 657
 658     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
 659     virtual void clipOutFloatingObjects(RenderBlock*, const PaintInfo*, const LayoutPoint&, const LayoutSize&) { };
 660     friend class LogicalSelectionOffsetCaches;
 661
 662     virtual void absoluteRects(Vector<IntRect>&, const LayoutPoint& accumulatedOffset) const OVERRIDE;
 663     virtual void absoluteQuads(Vector<FloatQuad>&, bool* wasFixed) const OVERRIDE;
 664
 665     LayoutUnit desiredColumnWidth() const;
 666     unsigned desiredColumnCount() const;
 667
 668     void paintContinuationOutlines(PaintInfo&, const LayoutPoint&);
 669
 670     virtual LayoutRect localCaretRect(InlineBox*, int caretOffset, LayoutUnit* extraWidthToEndOfLine = 0) OVERRIDE FINAL;
 671
 672     void adjustPointToColumnContents(LayoutPoint&) const;
 673
 674     void fitBorderToLinesIfNeeded(); // Shrink the box in which the border paints if border-fit is set.
 675     virtual void adjustForBorderFit(LayoutUnit x, LayoutUnit& left, LayoutUnit& right) const; // Helper function for borderFitAdjust
 676
 677     void markLinesDirtyInBlockRange(LayoutUnit logicalTop, LayoutUnit logicalBottom, RootInlineBox* highest = 0);
 678
 679     Position positionForBox(InlineBox*, bool start = true) const;
 680     VisiblePosition positionForPointWithInlineChildren(const LayoutPoint&);
 681
 682     virtual void calcColumnWidth();
 683     void makeChildrenAnonymousColumnBlocks(RenderObject* beforeChild, RenderBlock* newBlockBox, RenderObject* newChild);
 684
 685     bool expandsToEncloseOverhangingFloats() const;
 686
 687     void splitBlocks(RenderBlock* fromBlock, RenderBlock* toBlock, RenderBlock* middleBlock,
 688                      RenderObject* beforeChild, RenderBoxModelObject* oldCont);
 689     void splitFlow(RenderObject* beforeChild, RenderBlock* newBlockBox,
 690                    RenderObject* newChild, RenderBoxModelObject* oldCont);
 691     RenderBlock* clone() const;
 692     RenderBlock* continuationBefore(RenderObject* beforeChild);
 693     RenderBlock* containingColumnsBlock(bool allowAnonymousColumnBlock = true);
 694     RenderBlock* columnsBlockForSpanningElement(RenderObject* newChild);
 695
 696     RenderBoxModelObject* createReplacementRunIn(RenderBoxModelObject* runIn);
 697     void moveRunInUnderSiblingBlockIfNeeded(RenderObject* runIn);
 698     void moveRunInToOriginalPosition(RenderObject* runIn);
 699
 700 protected:
 701     void dirtyForLayoutFromPercentageHeightDescendants();
 702
 703     void determineLogicalLeftPositionForChild(RenderBox* child, ApplyLayoutDeltaMode = DoNotApplyLayoutDelta);
 704
 705     // Pagination routines.
 706     virtual bool relayoutForPagination(bool hasSpecifiedPageLogicalHeight, LayoutUnit pageLogicalHeight, LayoutStateMaintainer&);
 707
 708     // Returns the logicalOffset at the top of the next page. If the offset passed in is already at the top of the current page,
 709     // then nextPageLogicalTop with ExcludePageBoundary will still move to the top of the next page. nextPageLogicalTop with
 710     // IncludePageBoundary set will not.
 711     //
 712     // 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.
 713     enum PageBoundaryRule { ExcludePageBoundary, IncludePageBoundary };
 714     LayoutUnit nextPageLogicalTop(LayoutUnit logicalOffset, PageBoundaryRule = ExcludePageBoundary) const;
 715     bool hasNextPage(LayoutUnit logicalOffset, PageBoundaryRule = ExcludePageBoundary) const;
 716
 717     virtual ColumnInfo::PaginationUnit paginationUnit() const;
 718
 719 public:
 720     LayoutUnit pageLogicalTopForOffset(LayoutUnit offset) const;
 721     LayoutUnit pageLogicalHeightForOffset(LayoutUnit offset) const;
 722     LayoutUnit pageRemainingLogicalHeightForOffset(LayoutUnit offset, PageBoundaryRule = IncludePageBoundary) const;
 723
 724 protected:
 725     bool pushToNextPageWithMinimumLogicalHeight(LayoutUnit& adjustment, LayoutUnit logicalOffset, LayoutUnit minimumLogicalHeight) const;
 726
 727     // A page break is required at some offset due to space shortage in the current fragmentainer.
 728     void setPageBreak(LayoutUnit offset, LayoutUnit spaceShortage);
 729
 730     // Update minimum page height required to avoid fragmentation where it shouldn't occur (inside
 731     // unbreakable content, between orphans and widows, etc.). This will be used as a hint to the
 732     // column balancer to help set a good minimum column height.
 733     void updateMinimumPageHeight(LayoutUnit offset, LayoutUnit minHeight);
 734
 735     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.
 736
 737     // Adjust from painting offsets to the local coords of this renderer
 738     void offsetForContents(LayoutPoint&) const;
 739
 740     // 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
 741     // region/page/column that has a different available line width than the old one. Used to know when you have to dirty a
 742     // line, i.e., that it can't be re-used.
 743     bool lineWidthForPaginatedLineChanged(RootInlineBox*, LayoutUnit lineDelta, RenderFlowThread*) const;
 744
 745     bool logicalWidthChangedInRegions(RenderFlowThread*) const;
 746
 747     virtual bool requiresColumns(int desiredColumnCount) const;
 748
 749     virtual bool updateLogicalWidthAndColumnWidth();
 750
 751     virtual bool canCollapseAnonymousBlockChild() const { return true; }
 752
 753 public:
 754     virtual LayoutUnit offsetFromLogicalTopOfFirstPage() const OVERRIDE;
 755     RenderRegion* regionAtBlockOffset(LayoutUnit) const;
 756
 757     // 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
 758     // RenderBlock yet.
 759     friend class RenderBlockFlow;
 760     // FIXME-BLOCKFLOW: Remove this when the line layout stuff has all moved out of RenderBlock
 761     friend class LineBreaker;
 762
 763 public:
 764     // Allocated only when some of these fields have non-default values
 765     struct RenderBlockRareData {
 766         WTF_MAKE_NONCOPYABLE(RenderBlockRareData); WTF_MAKE_FAST_ALLOCATED;
 767     public:
 768         RenderBlockRareData()
 769             : m_paginationStrut(0)
 770             , m_pageLogicalOffset(0)
 771         {
 772         }
 773
 774         LayoutUnit m_paginationStrut;
 775         LayoutUnit m_pageLogicalOffset;
 776
 777 #if ENABLE(CSS_SHAPES)
 778         OwnPtr<ShapeInsideInfo> m_shapeInsideInfo;
 779 #endif
 780      };
 781
 782 protected:
 783
 784     OwnPtr<RenderBlockRareData> m_rareData;
 785
 786     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>.
 787
 788     mutable signed m_lineHeight : 27;
 789     unsigned m_hasMarginBeforeQuirk : 1; // Note these quirk values can't be put in RenderBlockRareData since they are set too frequently.
 790     unsigned m_hasMarginAfterQuirk : 1;
 791     unsigned m_beingDestroyed : 1;
 792     unsigned m_hasMarkupTruncation : 1;
 793     unsigned m_hasBorderOrPaddingLogicalWidthChanged : 1;
 794
 795 #if ENABLE(IOS_TEXT_AUTOSIZING)
 796     int m_widthForTextAutosizing;
 797     unsigned m_lineCountForTextAutosizing : 2;
 798 #endif
 799
 800     // RenderRubyBase objects need to be able to split and merge, moving their children around
 801     // (calling moveChildTo, moveAllChildrenTo, and makeChildrenNonInline).
 802     friend class RenderRubyBase;
 803
 804 private:
 805     // Used to store state between styleWillChange and styleDidChange
 806     static bool s_canPropagateFloatIntoSibling;
 807 };
 808
 809 inline RenderBlock& toRenderBlock(RenderObject& object)
 810 {
 811     ASSERT_WITH_SECURITY_IMPLICATION(object.isRenderBlock());
 812     return static_cast<RenderBlock&>(object);
 813 }
 814
 815 inline const RenderBlock& toRenderBlock(const RenderObject& object)
 816 {
 817     ASSERT_WITH_SECURITY_IMPLICATION(object.isRenderBlock());
 818     return static_cast<const RenderBlock&>(object);
 819 }
 820
 821 inline RenderBlock* toRenderBlock(RenderObject* object)
 822 {
 823     ASSERT_WITH_SECURITY_IMPLICATION(!object || object->isRenderBlock());
 824     return static_cast<RenderBlock*>(object);
 825 }
 826
 827 inline const RenderBlock* toRenderBlock(const RenderObject* object)
 828 {
 829     ASSERT_WITH_SECURITY_IMPLICATION(!object || object->isRenderBlock());
 830     return static_cast<const RenderBlock*>(object);
 831 }
 832
 833 // This will catch anyone doing an unnecessary cast.
 834 void toRenderBlock(const RenderBlock*);
 835 void toRenderBlock(const RenderBlock&);
 836
 837 } // namespace WebCore
 838
 839 #endif // RenderBlock_h