src/third_party/WebKit/Source/core/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 "core/rendering/ColumnInfo.h"
  27 #include "core/rendering/FloatingObjects.h"
  28 #include "core/rendering/GapRects.h"
  29 #include "core/rendering/RenderBox.h"
  30 #include "core/rendering/RenderLineBoxList.h"
  31 #include "core/rendering/RootInlineBox.h"
  32 #include "core/rendering/style/ShapeValue.h"
  33 #include "platform/text/TextBreakIterator.h"
  34 #include "platform/text/TextRun.h"
  35 #include "wtf/ListHashSet.h"
  36 #include "wtf/OwnPtr.h"
  37
  38 namespace WebCore {
  39
  40 class BasicShape;
  41 class BidiContext;
  42 class LayoutStateMaintainer;
  43 class LineLayoutState;
  44 class RenderInline;
  45 class RenderText;
  46
  47 struct BidiRun;
  48 struct PaintInfo;
  49 class LineInfo;
  50 class RenderRubyRun;
  51 class WordMeasurement;
  52
  53 template <class Run> class BidiRunList;
  54 typedef WTF::ListHashSet<RenderBox*, 16> TrackedRendererListHashSet;
  55 typedef WTF::HashMap<const RenderBlock*, OwnPtr<TrackedRendererListHashSet> > TrackedDescendantsMap;
  56 typedef WTF::HashMap<const RenderBox*, OwnPtr<HashSet<RenderBlock*> > > TrackedContainerMap;
  57 typedef Vector<WordMeasurement, 64> WordMeasurements;
  58
  59 enum CaretType { CursorCaret, DragCaret };
  60 enum ContainingBlockState { NewContainingBlock, SameContainingBlock };
  61
  62 enum TextRunFlag {
  63     DefaultTextRunFlags = 0,
  64     RespectDirection = 1 << 0,
  65     RespectDirectionOverride = 1 << 1
  66 };
  67
  68 typedef unsigned TextRunFlags;
  69
  70 class RenderBlock : public RenderBox {
  71 public:
  72     friend class LineLayoutState;
  73
  74 protected:
  75     explicit RenderBlock(ContainerNode*);
  76     virtual ~RenderBlock();
  77
  78 public:
  79     RenderObject* firstChild() const { ASSERT(children() == virtualChildren()); return children()->firstChild(); }
  80     RenderObject* lastChild() const { ASSERT(children() == virtualChildren()); return children()->lastChild(); }
  81
  82     const RenderObjectChildList* children() const { return &m_children; }
  83     RenderObjectChildList* children() { return &m_children; }
  84
  85     bool beingDestroyed() const { return m_beingDestroyed; }
  86
  87     // These two functions are overridden for inline-block.
  88     virtual LayoutUnit lineHeight(bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const OVERRIDE FINAL;
  89     virtual int baselinePosition(FontBaseline, bool firstLine, LineDirectionMode, LinePositionMode = PositionOnContainingLine) const OVERRIDE;
  90
  91     LayoutUnit minLineHeightForReplacedRenderer(bool isFirstLine, LayoutUnit replacedHeight) const;
  92
  93     RenderLineBoxList* lineBoxes() { return &m_lineBoxes; }
  94
  95     InlineFlowBox* firstLineBox() const { return m_lineBoxes.firstLineBox(); }
  96     InlineFlowBox* lastLineBox() const { return m_lineBoxes.lastLineBox(); }
  97
  98     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
  99     virtual void deleteLineBoxTree();
 100
 101     virtual void addChild(RenderObject* newChild, RenderObject* beforeChild = 0) OVERRIDE;
 102     virtual void removeChild(RenderObject*) OVERRIDE;
 103
 104     virtual void layoutBlock(bool relayoutChildren);
 105
 106     void insertPositionedObject(RenderBox*);
 107     static void removePositionedObject(RenderBox*);
 108     void removePositionedObjects(RenderBlock*, ContainingBlockState = SameContainingBlock);
 109
 110     TrackedRendererListHashSet* positionedObjects() const;
 111     bool hasPositionedObjects() const
 112     {
 113         TrackedRendererListHashSet* objects = positionedObjects();
 114         return objects && !objects->isEmpty();
 115     }
 116
 117     void addPercentHeightDescendant(RenderBox*);
 118     static void removePercentHeightDescendant(RenderBox*);
 119     static bool hasPercentHeightContainerMap();
 120     static bool hasPercentHeightDescendant(RenderBox*);
 121     static void clearPercentHeightDescendantsFrom(RenderBox*);
 122     static void removePercentHeightDescendantIfNeeded(RenderBox*);
 123
 124     TrackedRendererListHashSet* percentHeightDescendants() const;
 125     bool hasPercentHeightDescendants() const
 126     {
 127         TrackedRendererListHashSet* descendants = percentHeightDescendants();
 128         return descendants && !descendants->isEmpty();
 129     }
 130
 131     void setHasMarkupTruncation(bool b) { m_hasMarkupTruncation = b; }
 132     bool hasMarkupTruncation() const { return m_hasMarkupTruncation; }
 133
 134     void setHasMarginBeforeQuirk(bool b) { m_hasMarginBeforeQuirk = b; }
 135     void setHasMarginAfterQuirk(bool b) { m_hasMarginAfterQuirk = b; }
 136
 137     bool hasMarginBeforeQuirk() const { return m_hasMarginBeforeQuirk; }
 138     bool hasMarginAfterQuirk() const { return m_hasMarginAfterQuirk; }
 139
 140     bool hasMarginBeforeQuirk(const RenderBox* child) const;
 141     bool hasMarginAfterQuirk(const RenderBox* child) const;
 142
 143     void markPositionedObjectsForLayout();
 144     // FIXME: Do we really need this to be virtual? It's just so we can call this on
 145     // RenderBoxes without needed to check whether they're RenderBlocks first.
 146     virtual void markForPaginationRelayoutIfNeeded(SubtreeLayoutScope&) OVERRIDE FINAL;
 147
 148     // FIXME-BLOCKFLOW: Remove virtualizaion when all of the line layout code has been moved out of RenderBlock
 149     virtual bool containsFloats() const { return false; }
 150
 151     LayoutUnit textIndentOffset() const;
 152
 153     virtual PositionWithAffinity positionForPoint(const LayoutPoint&) OVERRIDE;
 154
 155     // Block flows subclass availableWidth to handle multi column layout (shrinking the width available to children when laying out.)
 156     virtual LayoutUnit availableLogicalWidth() const OVERRIDE FINAL;
 157
 158     LayoutPoint flipForWritingModeIncludingColumns(const LayoutPoint&) const;
 159     void adjustStartEdgeForWritingModeIncludingColumns(LayoutRect&) const;
 160
 161     LayoutUnit blockDirectionOffset(const LayoutSize& offsetFromBlock) const;
 162     LayoutUnit inlineDirectionOffset(const LayoutSize& offsetFromBlock) const;
 163
 164     RootInlineBox* firstRootBox() const { return static_cast<RootInlineBox*>(firstLineBox()); }
 165     RootInlineBox* lastRootBox() const { return static_cast<RootInlineBox*>(lastLineBox()); }
 166
 167     GapRects selectionGapRectsForRepaint(const RenderLayerModelObject* repaintContainer);
 168     LayoutRect logicalLeftSelectionGap(RenderBlock* rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
 169                                        RenderObject* selObj, LayoutUnit logicalLeft, LayoutUnit logicalTop, LayoutUnit logicalHeight, const PaintInfo*);
 170     LayoutRect logicalRightSelectionGap(RenderBlock* rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
 171                                         RenderObject* selObj, LayoutUnit logicalRight, LayoutUnit logicalTop, LayoutUnit logicalHeight, const PaintInfo*);
 172     void getSelectionGapInfo(SelectionState, bool& leftGap, bool& rightGap);
 173     RenderBlock* blockBeforeWithinSelectionRoot(LayoutSize& offset) const;
 174
 175     LayoutRect logicalRectToPhysicalRect(const LayoutPoint& physicalPosition, const LayoutRect& logicalRect);
 176
 177     // Helper methods for computing line counts and heights for line counts.
 178     RootInlineBox* lineAtIndex(int) const;
 179     int lineCount(const RootInlineBox* = 0, bool* = 0) const;
 180     int heightForLineCount(int);
 181     void clearTruncation();
 182
 183     void adjustRectForColumns(LayoutRect&) const;
 184     virtual LayoutSize columnOffset(const LayoutPoint&) const OVERRIDE;
 185     void adjustForColumnRect(LayoutSize& offset, const LayoutPoint& locationInContainer) const;
 186
 187     void addContinuationWithOutline(RenderInline*);
 188     bool paintsContinuationOutline(RenderInline*);
 189
 190     virtual RenderBoxModelObject* virtualContinuation() const OVERRIDE FINAL { return continuation(); }
 191     bool isAnonymousBlockContinuation() const { return continuation() && isAnonymousBlock(); }
 192     RenderInline* inlineElementContinuation() const;
 193     RenderBlock* blockElementContinuation() const;
 194
 195     using RenderBoxModelObject::continuation;
 196     using RenderBoxModelObject::setContinuation;
 197
 198     static RenderBlock* createAnonymousWithParentRendererAndDisplay(const RenderObject*, EDisplay = BLOCK);
 199     static RenderBlockFlow* createAnonymousColumnsWithParentRenderer(const RenderObject*);
 200     static RenderBlockFlow* createAnonymousColumnSpanWithParentRenderer(const RenderObject*);
 201     RenderBlock* createAnonymousBlock(EDisplay display = BLOCK) const { return createAnonymousWithParentRendererAndDisplay(this, display); }
 202     RenderBlockFlow* createAnonymousColumnsBlock() const { return createAnonymousColumnsWithParentRenderer(this); }
 203     RenderBlockFlow* createAnonymousColumnSpanBlock() const { return createAnonymousColumnSpanWithParentRenderer(this); }
 204
 205     virtual RenderBox* createAnonymousBoxWithSameTypeAs(const RenderObject* parent) const OVERRIDE;
 206
 207     ColumnInfo* columnInfo() const;
 208     int columnGap() const;
 209
 210     // These two functions take the ColumnInfo* to avoid repeated lookups of the info in the global HashMap.
 211     unsigned columnCount(ColumnInfo*) const;
 212     LayoutRect columnRectAt(ColumnInfo*, unsigned) const;
 213
 214     LayoutUnit paginationStrut() const { return m_rareData ? m_rareData->m_paginationStrut : LayoutUnit(); }
 215     void setPaginationStrut(LayoutUnit);
 216
 217     bool shouldBreakAtLineToAvoidWidow() const { return m_rareData && m_rareData->m_lineBreakToAvoidWidow >= 0; }
 218     void clearShouldBreakAtLineToAvoidWidow() const;
 219     int lineBreakToAvoidWidow() const { return m_rareData ? m_rareData->m_lineBreakToAvoidWidow : -1; }
 220     void setBreakAtLineToAvoidWidow(int);
 221     void clearDidBreakAtLineToAvoidWidow();
 222     void setDidBreakAtLineToAvoidWidow();
 223     bool didBreakAtLineToAvoidWidow() const { return m_rareData && m_rareData->m_didBreakAtLineToAvoidWidow; }
 224
 225     // The page logical offset is the object's offset from the top of the page in the page progression
 226     // direction (so an x-offset in vertical text and a y-offset for horizontal text).
 227     LayoutUnit pageLogicalOffset() const { return m_rareData ? m_rareData->m_pageLogicalOffset : LayoutUnit(); }
 228     void setPageLogicalOffset(LayoutUnit);
 229
 230     // Accessors for logical width/height and margins in the containing block's block-flow direction.
 231     LayoutUnit logicalWidthForChild(const RenderBox* child) const { return isHorizontalWritingMode() ? child->width() : child->height(); }
 232     LayoutUnit logicalHeightForChild(const RenderBox* child) const { return isHorizontalWritingMode() ? child->height() : child->width(); }
 233     LayoutSize logicalSizeForChild(const RenderBox* child) const { return isHorizontalWritingMode() ? child->size() : child->size().transposedSize(); }
 234     LayoutUnit logicalTopForChild(const RenderBox* child) const { return isHorizontalWritingMode() ? child->y() : child->x(); }
 235     LayoutUnit marginBeforeForChild(const RenderBoxModelObject* child) const { return child->marginBefore(style()); }
 236     LayoutUnit marginAfterForChild(const RenderBoxModelObject* child) const { return child->marginAfter(style()); }
 237     LayoutUnit marginStartForChild(const RenderBoxModelObject* child) const { return child->marginStart(style()); }
 238     LayoutUnit marginEndForChild(const RenderBoxModelObject* child) const { return child->marginEnd(style()); }
 239     void setMarginStartForChild(RenderBox* child, LayoutUnit value) const { child->setMarginStart(value, style()); }
 240     void setMarginEndForChild(RenderBox* child, LayoutUnit value) const { child->setMarginEnd(value, style()); }
 241     void setMarginBeforeForChild(RenderBox* child, LayoutUnit value) const { child->setMarginBefore(value, style()); }
 242     void setMarginAfterForChild(RenderBox* child, LayoutUnit value) const { child->setMarginAfter(value, style()); }
 243     LayoutUnit collapsedMarginBeforeForChild(const RenderBox* child) const;
 244     LayoutUnit collapsedMarginAfterForChild(const RenderBox* child) const;
 245
 246     virtual void updateFirstLetter();
 247
 248     virtual void scrollbarsChanged(bool /*horizontalScrollbarChanged*/, bool /*verticalScrollbarChanged*/) { };
 249
 250     LayoutUnit availableLogicalWidthForContent() const { return max<LayoutUnit>(0, logicalRightOffsetForContent() - logicalLeftOffsetForContent()); }
 251     LayoutUnit logicalLeftOffsetForContent() const { return isHorizontalWritingMode() ? borderLeft() + paddingLeft() : borderTop() + paddingTop(); }
 252     LayoutUnit logicalRightOffsetForContent() const { return logicalLeftOffsetForContent() + availableLogicalWidth(); }
 253     LayoutUnit startOffsetForContent() const { return style()->isLeftToRightDirection() ? logicalLeftOffsetForContent() : logicalWidth() - logicalRightOffsetForContent(); }
 254     LayoutUnit endOffsetForContent() const { return !style()->isLeftToRightDirection() ? logicalLeftOffsetForContent() : logicalWidth() - logicalRightOffsetForContent(); }
 255
 256 #ifndef NDEBUG
 257     void checkPositionedObjectsNeedLayout();
 258     void showLineTreeAndMark(const InlineBox* = 0, const char* = 0, const InlineBox* = 0, const char* = 0, const RenderObject* = 0) const;
 259 #endif
 260
 261     // inline-block elements paint all phases atomically. This function ensures that. Certain other elements
 262     // (grid items, flex items) require this behavior as well, and this function exists as a helper for them.
 263     // It is expected that the caller will call this function independent of the value of paintInfo.phase.
 264     static void paintAsInlineBlock(RenderObject*, PaintInfo&, const LayoutPoint&);
 265
 266     bool recalcChildOverflowAfterStyleChange();
 267     bool recalcOverflowAfterStyleChange();
 268
 269 protected:
 270     virtual void willBeDestroyed() OVERRIDE;
 271
 272     void dirtyForLayoutFromPercentageHeightDescendants(SubtreeLayoutScope&);
 273
 274     virtual void layout() OVERRIDE;
 275     virtual bool updateImageLoadingPriorities() OVERRIDE FINAL;
 276
 277     enum PositionedLayoutBehavior {
 278         DefaultLayout,
 279         LayoutOnlyFixedPositionedObjects,
 280         ForcedLayoutAfterContainingBlockMoved
 281     };
 282
 283     void layoutPositionedObjects(bool relayoutChildren, PositionedLayoutBehavior = DefaultLayout);
 284     void markFixedPositionObjectForLayoutIfNeeded(RenderObject* child, SubtreeLayoutScope&);
 285
 286     LayoutUnit marginIntrinsicLogicalWidthForChild(RenderBox* child) const;
 287
 288     int beforeMarginInLineDirection(LineDirectionMode) const;
 289
 290     virtual void paint(PaintInfo&, const LayoutPoint&) OVERRIDE;
 291     virtual void paintObject(PaintInfo&, const LayoutPoint&) OVERRIDE;
 292     virtual void paintChildren(PaintInfo&, const LayoutPoint&);
 293     void paintChild(RenderBox*, PaintInfo&, const LayoutPoint&);
 294     void paintChildAsInlineBlock(RenderBox*, PaintInfo&, const LayoutPoint&);
 295
 296     virtual void adjustInlineDirectionLineBounds(unsigned /* expansionOpportunityCount */, float& /* logicalLeft */, float& /* logicalWidth */) const { }
 297
 298     virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) OVERRIDE;
 299
 300     virtual void computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const OVERRIDE;
 301     virtual void computePreferredLogicalWidths() OVERRIDE;
 302     void adjustIntrinsicLogicalWidthsForColumns(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const;
 303
 304     virtual int firstLineBoxBaseline() const OVERRIDE;
 305     virtual int inlineBlockBaseline(LineDirectionMode) const OVERRIDE;
 306     int lastLineBoxBaseline(LineDirectionMode) const;
 307
 308     virtual void updateHitTestResult(HitTestResult&, const LayoutPoint&) OVERRIDE;
 309
 310     // Delay update scrollbar until finishDelayRepaint() will be
 311     // called. This function is used when a flexbox is laying out its
 312     // descendant. If multiple calls are made to startDelayRepaint(),
 313     // finishDelayRepaint() will do nothing until finishDelayRepaint()
 314     // is called the same number of times.
 315     static void startDelayUpdateScrollInfo();
 316     static void finishDelayUpdateScrollInfo();
 317
 318     void updateScrollInfoAfterLayout();
 319
 320     virtual void styleWillChange(StyleDifference, const RenderStyle& newStyle) OVERRIDE;
 321     virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle) OVERRIDE;
 322
 323     virtual bool hasLineIfEmpty() const;
 324
 325     bool simplifiedLayout();
 326     virtual void simplifiedNormalFlowLayout();
 327
 328     void setDesiredColumnCountAndWidth(int, LayoutUnit);
 329
 330     bool avoidsOrIgnoresFloats() { return isFloatingOrOutOfFlowPositioned() || avoidsFloats(); }
 331 public:
 332     virtual void computeOverflow(LayoutUnit oldClientAfterEdge, bool = false);
 333 protected:
 334     virtual void addOverflowFromChildren();
 335     void addOverflowFromPositionedObjects();
 336     void addOverflowFromBlockChildren();
 337     void addVisualOverflowFromTheme();
 338
 339     virtual void addFocusRingRects(Vector<IntRect>&, const LayoutPoint& additionalOffset, const RenderLayerModelObject* paintContainer = 0) OVERRIDE;
 340
 341     virtual void computeSelfHitTestRects(Vector<LayoutRect>&, const LayoutPoint& layerOffset) const OVERRIDE;
 342
 343     void computeRegionRangeForBlock(RenderFlowThread*);
 344
 345     void updateBlockChildDirtyBitsBeforeLayout(bool relayoutChildren, RenderBox*);
 346
 347     virtual bool isInlineBlockOrInlineTable() const OVERRIDE FINAL { return isInline() && isReplaced(); }
 348
 349     virtual void repaintTreeAfterLayout() OVERRIDE;
 350
 351 private:
 352     virtual RenderObjectChildList* virtualChildren() OVERRIDE FINAL { return children(); }
 353     virtual const RenderObjectChildList* virtualChildren() const OVERRIDE FINAL { return children(); }
 354
 355     virtual const char* renderName() const OVERRIDE;
 356
 357     virtual bool isRenderBlock() const OVERRIDE FINAL { return true; }
 358
 359     void makeChildrenNonInline(RenderObject* insertionPoint = 0);
 360     virtual void removeLeftoverAnonymousBlock(RenderBlock* child);
 361
 362     static void collapseAnonymousBlockChild(RenderBlock* parent, RenderBlock* child);
 363
 364     virtual void dirtyLinesFromChangedChild(RenderObject* child) OVERRIDE FINAL { m_lineBoxes.dirtyLinesFromChangedChild(this, child); }
 365
 366     void addChildToContinuation(RenderObject* newChild, RenderObject* beforeChild);
 367     virtual void addChildIgnoringContinuation(RenderObject* newChild, RenderObject* beforeChild) OVERRIDE;
 368     void addChildToAnonymousColumnBlocks(RenderObject* newChild, RenderObject* beforeChild);
 369
 370     void addChildIgnoringAnonymousColumnBlocks(RenderObject* newChild, RenderObject* beforeChild = 0);
 371
 372     virtual bool isSelfCollapsingBlock() const OVERRIDE;
 373
 374     void insertIntoTrackedRendererMaps(RenderBox* descendant, TrackedDescendantsMap*&, TrackedContainerMap*&);
 375     static void removeFromTrackedRendererMaps(RenderBox* descendant, TrackedDescendantsMap*&, TrackedContainerMap*&);
 376
 377     void createFirstLetterRenderer(RenderObject* firstLetterBlock, RenderObject* currentChild, unsigned length);
 378     void updateFirstLetterStyle(RenderObject* firstLetterBlock, RenderObject* firstLetterContainer);
 379
 380     Node* nodeForHitTest() const;
 381
 382     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
 383     virtual void paintFloats(PaintInfo&, const LayoutPoint&, bool) { }
 384     void paintContents(PaintInfo&, const LayoutPoint&);
 385     void paintColumnContents(PaintInfo&, const LayoutPoint&, bool paintFloats = false);
 386     void paintColumnRules(PaintInfo&, const LayoutPoint&);
 387     void paintSelection(PaintInfo&, const LayoutPoint&);
 388     void paintCaret(PaintInfo&, const LayoutPoint&, CaretType);
 389
 390     bool hasCaret() const { return hasCaret(CursorCaret) || hasCaret(DragCaret); }
 391     bool hasCaret(CaretType) const;
 392
 393     bool hitTestColumns(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction);
 394     bool hitTestContents(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction);
 395     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
 396     virtual bool hitTestFloats(const HitTestRequest&, HitTestResult&, const HitTestLocation&, const LayoutPoint&) { return false; }
 397
 398     virtual bool isPointInOverflowControl(HitTestResult&, const LayoutPoint& locationInContainer, const LayoutPoint& accumulatedOffset);
 399
 400     void computeBlockPreferredLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const;
 401
 402     // Obtains the nearest enclosing block (including this block) that contributes a first-line style to our inline
 403     // children.
 404     virtual RenderBlock* firstLineBlock() const OVERRIDE;
 405
 406     virtual LayoutRect rectWithOutlineForRepaint(const RenderLayerModelObject* repaintContainer, LayoutUnit outlineWidth) const OVERRIDE FINAL;
 407     virtual RenderStyle* outlineStyleForRepaint() const OVERRIDE FINAL;
 408
 409     virtual RenderObject* hoverAncestor() const OVERRIDE FINAL;
 410     virtual void updateDragState(bool dragOn) OVERRIDE FINAL;
 411     virtual void childBecameNonInline(RenderObject* child) OVERRIDE FINAL;
 412
 413     virtual LayoutRect selectionRectForRepaint(const RenderLayerModelObject* repaintContainer, bool /*clipToVisibleContent*/) OVERRIDE FINAL
 414     {
 415         return selectionGapRectsForRepaint(repaintContainer);
 416     }
 417     virtual bool shouldPaintSelectionGaps() const OVERRIDE FINAL;
 418     bool isSelectionRoot() const;
 419     GapRects selectionGaps(RenderBlock* rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
 420                            LayoutUnit& lastLogicalTop, LayoutUnit& lastLogicalLeft, LayoutUnit& lastLogicalRight, const PaintInfo* = 0);
 421     GapRects blockSelectionGaps(RenderBlock* rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
 422                                 LayoutUnit& lastLogicalTop, LayoutUnit& lastLogicalLeft, LayoutUnit& lastLogicalRight, const PaintInfo*);
 423     LayoutRect blockSelectionGap(RenderBlock* rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock,
 424                                  LayoutUnit lastLogicalTop, LayoutUnit lastLogicalLeft, LayoutUnit lastLogicalRight, LayoutUnit logicalBottom, const PaintInfo*);
 425     virtual LayoutUnit logicalLeftSelectionOffset(RenderBlock* rootBlock, LayoutUnit position);
 426     virtual LayoutUnit logicalRightSelectionOffset(RenderBlock* rootBlock, LayoutUnit position);
 427
 428     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to RenderBlockFlow
 429     virtual void clipOutFloatingObjects(RenderBlock*, const PaintInfo*, const LayoutPoint&, const LayoutSize&) { };
 430
 431     virtual void absoluteRects(Vector<IntRect>&, const LayoutPoint& accumulatedOffset) const OVERRIDE;
 432     virtual void absoluteQuads(Vector<FloatQuad>&, bool* wasFixed) const OVERRIDE;
 433
 434     LayoutUnit desiredColumnWidth() const;
 435
 436     void paintContinuationOutlines(PaintInfo&, const LayoutPoint&);
 437
 438     virtual LayoutRect localCaretRect(InlineBox*, int caretOffset, LayoutUnit* extraWidthToEndOfLine = 0) OVERRIDE FINAL;
 439
 440     void adjustPointToColumnContents(LayoutPoint&) const;
 441
 442     void fitBorderToLinesIfNeeded(); // Shrink the box in which the border paints if border-fit is set.
 443     virtual void adjustForBorderFit(LayoutUnit x, LayoutUnit& left, LayoutUnit& right) const; // Helper function for borderFitAdjust
 444
 445     void markLinesDirtyInBlockRange(LayoutUnit logicalTop, LayoutUnit logicalBottom, RootInlineBox* highest = 0);
 446
 447     Position positionForBox(InlineBox*, bool start = true) const;
 448     PositionWithAffinity positionForPointWithInlineChildren(const LayoutPoint&);
 449
 450     void calcColumnWidth();
 451     void makeChildrenAnonymousColumnBlocks(RenderObject* beforeChild, RenderBlockFlow* newBlockBox, RenderObject* newChild);
 452
 453     void splitBlocks(RenderBlock* fromBlock, RenderBlock* toBlock, RenderBlock* middleBlock,
 454                      RenderObject* beforeChild, RenderBoxModelObject* oldCont);
 455     void splitFlow(RenderObject* beforeChild, RenderBlock* newBlockBox,
 456                    RenderObject* newChild, RenderBoxModelObject* oldCont);
 457     RenderBlock* clone() const;
 458     RenderBlock* continuationBefore(RenderObject* beforeChild);
 459     RenderBlockFlow* containingColumnsBlock(bool allowAnonymousColumnBlock = true);
 460     RenderBlockFlow* columnsBlockForSpanningElement(RenderObject* newChild);
 461
 462     // End helper functions and structs used by layoutBlockChildren.
 463
 464 protected:
 465     // Returns the logicalOffset at the top of the next page. If the offset passed in is already at the top of the current page,
 466     // then nextPageLogicalTop with ExcludePageBoundary will still move to the top of the next page. nextPageLogicalTop with
 467     // IncludePageBoundary set will not.
 468     //
 469     // 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.
 470     enum PageBoundaryRule { ExcludePageBoundary, IncludePageBoundary };
 471     LayoutUnit nextPageLogicalTop(LayoutUnit logicalOffset, PageBoundaryRule = ExcludePageBoundary) const;
 472
 473 public:
 474     LayoutUnit pageLogicalTopForOffset(LayoutUnit offset) const;
 475     LayoutUnit pageLogicalHeightForOffset(LayoutUnit offset) const;
 476     LayoutUnit pageRemainingLogicalHeightForOffset(LayoutUnit offset, PageBoundaryRule = IncludePageBoundary) const;
 477
 478 protected:
 479     // A page break is required at some offset due to space shortage in the current fragmentainer.
 480     void setPageBreak(LayoutUnit offset, LayoutUnit spaceShortage);
 481
 482     // Update minimum page height required to avoid fragmentation where it shouldn't occur (inside
 483     // unbreakable content, between orphans and widows, etc.). This will be used as a hint to the
 484     // column balancer to help set a good minimum column height.
 485     void updateMinimumPageHeight(LayoutUnit offset, LayoutUnit minHeight);
 486
 487     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.
 488     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.
 489
 490     // Adjust from painting offsets to the local coords of this renderer
 491     void offsetForContents(LayoutPoint&) const;
 492
 493     bool requiresColumns(int desiredColumnCount) const;
 494
 495     virtual bool updateLogicalWidthAndColumnWidth();
 496
 497     virtual bool canCollapseAnonymousBlockChild() const { return true; }
 498
 499 public:
 500     virtual LayoutUnit offsetFromLogicalTopOfFirstPage() const OVERRIDE FINAL;
 501
 502     void invalidateLineHeight() { m_lineHeight = -1; }
 503
 504 public:
 505
 506     // Allocated only when some of these fields have non-default values
 507     struct RenderBlockRareData {
 508         WTF_MAKE_NONCOPYABLE(RenderBlockRareData); WTF_MAKE_FAST_ALLOCATED;
 509     public:
 510         RenderBlockRareData()
 511             : m_paginationStrut(0)
 512             , m_pageLogicalOffset(0)
 513             , m_lineBreakToAvoidWidow(-1)
 514             , m_didBreakAtLineToAvoidWidow(false)
 515         {
 516         }
 517
 518         LayoutUnit m_paginationStrut;
 519         LayoutUnit m_pageLogicalOffset;
 520
 521         int m_lineBreakToAvoidWidow : 31;
 522         unsigned m_didBreakAtLineToAvoidWidow : 1;
 523      };
 524
 525 protected:
 526     OwnPtr<RenderBlockRareData> m_rareData;
 527
 528     RenderObjectChildList m_children;
 529     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>.
 530
 531     mutable signed m_lineHeight : 26;
 532     unsigned m_hasMarginBeforeQuirk : 1; // Note these quirk values can't be put in RenderBlockRareData since they are set too frequently.
 533     unsigned m_hasMarginAfterQuirk : 1;
 534     unsigned m_beingDestroyed : 1;
 535     unsigned m_hasMarkupTruncation : 1;
 536     unsigned m_hasBorderOrPaddingLogicalWidthChanged : 1;
 537     mutable unsigned m_hasOnlySelfCollapsingChildren : 1;
 538
 539     // RenderRubyBase objects need to be able to split and merge, moving their children around
 540     // (calling moveChildTo, moveAllChildrenTo, and makeChildrenNonInline).
 541     friend class RenderRubyBase;
 542     // FIXME-BLOCKFLOW: Remove this when the line layout stuff has all moved out of RenderBlock
 543     friend class LineBreaker;
 544
 545     // FIXME: This is temporary as we move code that accesses block flow
 546     // member variables out of RenderBlock and into RenderBlockFlow.
 547     friend class RenderBlockFlow;
 548 };
 549
 550 DEFINE_RENDER_OBJECT_TYPE_CASTS(RenderBlock, isRenderBlock());
 551
 552 } // namespace WebCore
 553
 554 #endif // RenderBlock_h