Attachment #67609 for bug #38402

View Details Raw Unified Return to Bug 38402

| Differences between

and this patch



    ColumnInfo()
        : m_desiredColumnWidth(0)
        , m_desiredColumnCount(1)
        , m_columnCount(1)
        , m_columnHeight(0)
        , m_minimumColumnHeight(0)
        { }
    
    int desiredColumnWidth() const { return m_desiredColumnWidth; }

    unsigned desiredColumnCount() const { return m_desiredColumnCount; }
    void setDesiredColumnCount(unsigned count) { m_desiredColumnCount = count; }

    unsigned columnCount() const { return m_columnCount; }
    int columnHeight() const { return m_columnHeight; }
    const IntRect& columnRectAt(size_t i) const { return m_columnRects[i]; }

    // Set our count and height.  This is enough info for a RenderBlock to compute page rects
    // dynamically.
    void setColumnCountAndHeight(int c, int h)
    { 
        m_columnCount = c;
        m_columnHeight = h;
    }
    void setColumnHeight(int h) { m_columnHeight = h; }

    void updateMinimumColumnHeight(int h) { m_minimumColumnHeight = max(h, m_minimumColumnHeight); }
    int minimumColumnHeight() const { return m_minimumColumnHeight; }

    // FIXME: Will go away once we don't use the Vector.
    void addColumnRect(const IntRect& rect) { m_columnRects.append(rect); }
    
private:
    int m_desiredColumnWidth;
    unsigned m_desiredColumnCount;
    
    unsigned m_columnCount;
    int m_columnHeight;
    int m_minimumColumnHeight;
};

}




namespace WebCore {

LayoutState::LayoutState(LayoutState* prev, RenderBox* renderer, const IntSize& offset, int pageHeight, ColumnInfo* colInfo)
    : m_columnInfo(colInfo)
    , m_next(prev)
#ifndef NDEBUG
    , m_renderer(renderer)
#endif

    if (fixed) {
        // FIXME: This doesn't work correctly with transforms.
        FloatPoint fixedOffset = renderer->view()->localToAbsolute(FloatPoint(), true);
        m_paintOffset = IntSize(fixedOffset.x(), fixedOffset.y()) + offset;
    } else
        m_paintOffset = prev->m_paintOffset + offset;

    if (renderer->isPositioned() && !fixed) {
        if (renderer->hasLayer())
            m_offset += renderer->layer()->relativePositionOffset();
    } else if (renderer->isPositioned() && !fixed) {
        if (RenderObject* container = renderer->container()) {
            if (container->isRelPositioned() && container->isRenderInline())
                m_paintOffset += toRenderInline(container)->relativePositionedInlineOffset(renderer);
        }
    }

    m_layoutOffset = m_paintOffset;

    if (renderer->isRelPositioned() && renderer->hasLayer())
        m_paintOffset += renderer->layer()->relativePositionOffset();

    m_clipped = !fixed && prev->m_clipped;
    if (m_clipped)
        m_clipRect = prev->m_clipRect;

    if (renderer->hasOverflowClip()) {
        RenderLayer* layer = renderer->layer();
        IntRect clipRect(toPoint(m_paintOffset) + renderer->view()->layoutDelta(), layer->size());
        if (m_clipped)
            m_clipRect.intersect(clipRect);
        else {
            m_clipRect = clipRect;
            m_clipped = true;
        }

        m_paintOffset -= layer->scrolledContentOffset();
    }

    // Disable pagination for objects we don't support.  For now this includes overflow:scroll/auto and inline blocks.
    if (renderer->isReplaced() || renderer->scrollsOverflow())
        m_pageHeight = 0;

    // If we establish a new page height, then cache the offset to the top of the first page.
    // We can compare this later on to figure out what part of the page we're actually on,
    if (pageHeight) {
        m_pageHeight = pageHeight;
        m_pageOffset = IntSize(m_paintOffset.width() + renderer->borderLeft() + renderer->paddingLeft(),
                               m_paintOffset.height() + renderer->borderTop() + renderer->paddingTop());
    } else {
        // If we don't establish a new page height, then propagate the old page height and offset down.
        m_pageHeight = m_next->m_pageHeight;
        m_pageOffset = m_next->m_pageOffset;
    }
    
    if (!m_columnInfo)
        m_columnInfo = m_next->m_columnInfo;

    m_layoutDelta = m_next->m_layoutDelta;
    
    // FIXME: <http://bugs.webkit.org/show_bug.cgi?id=13443> Apply control clip if present.
}

LayoutState::LayoutState(RenderObject* root)
    : m_clipped(false)
    , m_pageHeight(0)
    , m_columnInfo(0)
    , m_next(0)
#ifndef NDEBUG
    , m_renderer(root)

{
    RenderObject* container = root->container();
    FloatPoint absContentPoint = container->localToAbsolute(FloatPoint(), false, true);
    m_paintOffset = IntSize(absContentPoint.x(), absContentPoint.y());

    if (container->hasOverflowClip()) {
        RenderLayer* layer = toRenderBoxModelObject(container)->layer();
        m_clipped = true;
        m_clipRect = IntRect(toPoint(m_paintOffset), layer->size());
        m_paintOffset -= layer->scrolledContentOffset();
    }
}


    *(size_t*)ptr = sz;
}

void LayoutState::clearPaginationInformation()
{
    m_pageHeight = m_next->m_pageHeight;
    m_pageOffset = m_next->m_pageOffset;
    m_columnInfo = m_next->m_columnInfo;
}

int LayoutState::pageY(int childY) const
{
    ASSERT(m_pageHeight);
    int layoutY = m_layoutOffset.height() + childY;
    int pageY = m_pageOffset.height();
    return layoutY - pageY;
}

} // namespace WebCore

Lines 32-37 WebCore/rendering/LayoutState.h_sec1
- WebCore/rendering/LayoutState.h -2 / +16 lines
32		32
33	namespace WebCore {	33	namespace WebCore {
34		34
		35	class ColumnInfo;
35	class RenderArena;	36	class RenderArena;
36	class RenderBox;	37	class RenderBox;
37	class RenderObject;	38	class RenderObject;
Lines 40-45 class LayoutState : public Noncopyable { WebCore/rendering/LayoutState.h_sec2
40	public:	41	public:
41	LayoutState()	42	LayoutState()
42	: m_clipped(false)	43	: m_clipped(false)
		44	, m_pageHeight(0)
		45	, m_columnInfo(0)
43	, m_next(0)	46	, m_next(0)
44	#ifndef NDEBUG	47	#ifndef NDEBUG
45	, m_renderer(0)	48	, m_renderer(0)
Lines 47-53 public: WebCore/rendering/LayoutState.h_sec3
47	{	50	{
48	}	51	}
49		52
50	LayoutState(LayoutState, RenderBox, const IntSize& offset);	53	LayoutState(LayoutState, RenderBox, const IntSize& offset, int pageHeight, ColumnInfo*);
51	LayoutState(RenderObject*);	54	LayoutState(RenderObject*);
52		55
53	void destroy(RenderArena*);	56	void destroy(RenderArena*);
Lines 58-63 public: WebCore/rendering/LayoutState.h_sec4
58	// Overridden to prevent the normal delete from being called.	61	// Overridden to prevent the normal delete from being called.
59	void operator delete(void*, size_t);	62	void operator delete(void*, size_t);
60		63
		64	void clearPaginationInformation();
		65	bool paginatingColumns() const { return m_columnInfo; }
		66	bool paginated() const { return m_pageHeight \|\| m_columnInfo; }
		67	int pageY(int childY) const;
		68
61	private:	69	private:
62	// The normal operator new is disallowed.	70	// The normal operator new is disallowed.
63	void* operator new(size_t) throw();	71	void* operator new(size_t) throw();
Lines 65-74 private: WebCore/rendering/LayoutState.h_sec5
65	public:	73	public:
66	bool m_clipped;	74	bool m_clipped;
67	IntRect m_clipRect;	75	IntRect m_clipRect;
68	IntSize m_offset; // x/y offset from container.	76	IntSize m_paintOffset; // x/y offset from container. Includes relative positioning and scroll offsets.
		77	IntSize m_layoutOffset; // x/y offset from container. Does not include relative positioning or scroll offsets.
69	IntSize m_layoutDelta; // Transient offset from the final position of the object	78	IntSize m_layoutDelta; // Transient offset from the final position of the object
70	// used to ensure that repaints happen in the correct place.	79	// used to ensure that repaints happen in the correct place.
71	// This is a total delta accumulated from the root.	80	// This is a total delta accumulated from the root.
		81
		82	int m_pageHeight; // The current page height for the pagination model that encloses us.
		83	IntSize m_pageOffset; // The offset of the start of the first page in the nearest enclosing pagination model.
		84	ColumnInfo* m_columnInfo; // If the enclosing pagination model is a column model, then this will store column information for easy retrieval/manipulation.
		85
72	LayoutState* m_next;	86	LayoutState* m_next;
73	#ifndef NDEBUG	87	#ifndef NDEBUG
74	RenderObject* m_renderer;	88	RenderObject* m_renderer;



      , m_floatingObjects(0)
      , m_positionedObjects(0)
      , m_continuation(0)
      , m_rareData(0)
      , m_lineHeight(-1)
{
    setChildrenInline(true);

{
    delete m_floatingObjects;
    delete m_positionedObjects;
    delete m_rareData;
    
    if (hasColumns())
        delete gColumnInfoMap->take(this);

        clearLayoutOverflow();
}

void RenderBlock::layoutBlock(bool relayoutChildren, int pageHeight)
{
    ASSERT(needsLayout());


    if (!relayoutChildren && layoutOnlyPositionedObjects())
        return;

    LayoutRepainter repainter(*this, m_everHadLayout && checkForRepaintDuringLayout());
    LayoutStateMaintainer statePusher(view(), this, IntSize(x(), y()), hasColumns() || hasTransform() || hasReflection());

    int oldWidth = width();
    int oldColumnWidth = desiredColumnWidth();



    int previousHeight = height();
    setHeight(0);
    bool hasSpecifiedPageHeight = false;
    ColumnInfo* colInfo = columnInfo();
    if (hasColumns()) {
        if (!pageHeight) {
            // We need to go ahead and set our explicit page height if one exists, so that we can
            // avoid doing two layout passes.
            calcHeight();
            int columnHeight = contentHeight();
            if (columnHeight > 0) {
                pageHeight = columnHeight;
                hasSpecifiedPageHeight = true;
            }
            setHeight(0);
        }
        if (colInfo->columnHeight() != pageHeight && m_everHadLayout) {
            colInfo->setColumnHeight(pageHeight);
            markDescendantBlocksAndLinesForLayout(); // We need to dirty all descendant blocks and lines, since the column height is different now.
        }
    }

    LayoutRepainter repainter(*this, m_everHadLayout && checkForRepaintDuringLayout());
    LayoutStateMaintainer statePusher(view(), this, IntSize(x(), y()), hasColumns() || hasTransform() || hasReflection(), pageHeight, colInfo);

    // We use four values, maxTopPos, maxTopNeg, maxBottomPos, and maxBottomNeg, to track
    // our current maximal positive and negative margins.  These values are used when we

    if (floatBottom() > (height() - toAdd) && expandsToEncloseOverhangingFloats())
        setHeight(floatBottom() + toAdd);
    
    if (layoutColumns(hasSpecifiedPageHeight, pageHeight, statePusher))
        return;
 

    // Calculate our new height.
    int oldHeight = height();
    calcHeight();

                }
            }
        }
        
        // We have to rebalance columns to the new height.
        layoutColumns(singleColumnBottom);
    }

    if (previousHeight != height())
        relayoutChildren = true;

    // This check is designed to catch anyone
    // who wasn't going to propagate float information up to the parent and yet could potentially be painted by its ancestor.
    if (isRoot() || expandsToEncloseOverhangingFloats())
        addOverflowFromFloats();

    // Add overflow from children (unless we're multi-column, since in that case all our child overflow is clipped anyway).
    if (!hasColumns()) {
        // This check is designed to catch anyone
        // who wasn't going to propagate float information up to the parent and yet could potentially be painted by its ancestor.
        if (isRoot() || expandsToEncloseOverhangingFloats())
            addOverflowFromFloats();

        if (childrenInline())
            addOverflowFromInlineChildren();
        else

    
    statePusher.pop();

    if (view()->layoutState()->m_pageHeight)
        setPageY(view()->layoutState()->pageY(y()));

    // Update our scroll information if we're overflow:auto/scroll/hidden now that we know if
    // we overflow or not.
    updateScrollInfoAfterLayout();

    if (marginInfo.quirkContainer() && marginInfo.atTopOfBlock() && (posTop - negTop))
        marginInfo.setTopQuirk(topQuirk);

    int beforeCollapseY = height();
    int ypos = beforeCollapseY;
    if (child->isSelfCollapsingBlock()) {
        // This child has no height.  We need to compute our
        // position before we collapse the child's margins together,

            marginInfo.setBottomQuirk(child->isBottomMarginQuirk() || style()->marginBottomCollapse() == MDISCARD);
    }
    
    // If margins would pull us past the top of the next page, then we need to pull back and pretend like the margins
    // collapsed into the page edge.
    bool paginated = view()->layoutState()->paginated();
    if (paginated && ypos > beforeCollapseY) {
        int oldY = ypos;
        ypos = min(ypos, nextPageTop(beforeCollapseY));
        setHeight(height() + (ypos - oldY));
    }
    return ypos;
}


        int childMarginTop = child->selfNeedsLayout() ? child->marginTop() : child->collapsedMarginTop();
        yPosEstimate += max(marginInfo.margin(), childMarginTop);
    }
    
    bool paginated = view()->layoutState()->paginated();

    // Adjust yPosEstimate down to the next page if the margins are so large that we don't fit on the current
    // page.
    if (paginated && yPosEstimate > height())
        yPosEstimate = min(yPosEstimate, nextPageTop(height()));

    yPosEstimate += getClearDelta(child, yPosEstimate);
    
    if (paginated) {
        // If the object has a page or column break value of "before", then we should shift to the top of the next page.
        yPosEstimate = applyBeforeBreak(child, yPosEstimate);
    
        // For replaced elements and scrolled elements, we want to shift them to the next page if they don't fit on the current one.
        yPosEstimate = adjustForUnsplittableChild(child, yPosEstimate);
    }

    return yPosEstimate;
}


    view()->addLayoutDelta(IntSize(0, child->y() - yPosEstimate));
    child->setLocation(child->x(), yPosEstimate);

    RenderBlock* childBlockFlow = child->isBlockFlow() ? toRenderBlock(child) : 0;
    bool markDescendantsWithFloats = false;
    if (yPosEstimate != oldRect.y() && !child->avoidsFloats() && childBlockFlow && childBlockFlow->containsFloats())
        markDescendantsWithFloats = true;
    else if (!child->avoidsFloats() || child->shrinkToAvoidFloats()) {
        // If an element might be affected by the presence of floats, then always mark it for

            markDescendantsWithFloats = true;
    }

    if (childBlockFlow) {
        if (markDescendantsWithFloats)
            childBlockFlow->markAllDescendantsWithFloatsForLayout();

        previousFloatBottom = max(previousFloatBottom, oldRect.y() + toRenderBlock(child)->floatBottom());
    }

    bool paginated = view()->layoutState()->paginated();
    if (paginated && view()->layoutState()->m_pageHeight && childBlockFlow && view()->layoutState()->pageY(child->y()) != childBlockFlow->pageY())
        childBlockFlow->setChildNeedsLayout(true, false);

    bool childHadLayout = child->m_everHadLayout;
    bool childNeededLayout = child->needsLayout();
    if (childNeededLayout)
        child->layout();

    // Cache if we are at the top of the block right now.
    bool atTopOfBlock = marginInfo.atTopOfBlock();

    // Now determine the correct ypos based off examination of collapsing margin
    // values.
    int yBeforeClear = collapseMargins(child, marginInfo);

    // Now check for clear.
    int yAfterClear = clearFloatsIfNeeded(child, marginInfo, oldTopPosMargin, oldTopNegMargin, yBeforeClear);
    
    if (paginated) {
        int oldY = yAfterClear;
        
        // If the object has a page or column break value of "before", then we should shift to the top of the next page.
        yAfterClear = applyBeforeBreak(child, yAfterClear);
    
        // For replaced elements and scrolled elements, we want to shift them to the next page if they don't fit on the current one.
        yAfterClear = adjustForUnsplittableChild(child, yAfterClear);
        
        if (childBlockFlow->paginationStrut()) {
            // We are willing to propagate out to our parent block as long as we were at the top of the block prior
            // to collapsing our margins, and as long as we didn't clear or move as a result of other pagination.
            if (atTopOfBlock && oldY == yBeforeClear && !isPositioned() && !isTableCell()) {
                // FIXME: Should really check if we're exceeding the page height before propagating the strut, but we don't
                // have all the information to do so (the strut only has the remaining amount to push).  Gecko gets this wrong too
                // and pushes to the next page anyway, so not too concerned about it.
                setPaginationStrut(yAfterClear + childBlockFlow->paginationStrut());
                childBlockFlow->setPaginationStrut(0);
            } else
                yAfterClear += childBlockFlow->paginationStrut();
        }

        // Similar to how we apply clearance.  Go ahead and boost height() to be the place where we're going to position the child.
        setHeight(height() + (yAfterClear - oldY));
    }

    view()->addLayoutDelta(IntSize(0, yPosEstimate - yAfterClear));
    child->setLocation(child->x(), yAfterClear);


            // So go ahead and mark the item as dirty.
            child->setChildNeedsLayout(true, false);
        }
        if (childBlockFlow) {
            if (!child->avoidsFloats() && childBlockFlow->containsFloats())
                childBlockFlow->markAllDescendantsWithFloatsForLayout();
            if (paginated && !child->needsLayout() && view()->layoutState()->m_pageHeight && view()->layoutState()->pageY(child->y()) != childBlockFlow->pageY())
                child->setChildNeedsLayout(true, false);
        }

        // Our guess was wrong. Make the child lay itself out again.
        child->layoutIfNeeded();
    }

    }
    // If the child has overhanging floats that intrude into following siblings (or possibly out
    // of this block), then the parent gets notified of the floats now.
    if (childBlockFlow && childBlockFlow->containsFloats())
        maxFloatBottom = max(maxFloatBottom, addOverhangingFloats(toRenderBlock(child), -child->x(), -child->y(), !childNeededLayout));

    IntSize childOffset(child->x() - oldRect.x(), child->y() - oldRect.y());

        child->repaintOverhangingFloats(true);
    }

    if (paginated) {
        // Check for an after page/column break.
        int newHeight = applyAfterBreak(child, height(), marginInfo);
        if (newHeight != height())
            setHeight(newHeight);
    }

    ASSERT(oldLayoutDelta == view()->layoutDelta());
}


void RenderBlock::layoutPositionedObjects(bool relayoutChildren)
{
    if (m_positionedObjects) {
        if (hasColumns())
            view()->layoutState()->clearPaginationInformation(); // Positioned objects are not part of the column flow, so they don't paginate with the columns.

        RenderBox* r;
        Iterator end = m_positionedObjects->end();
        for (Iterator it = m_positionedObjects->begin(); it != end; ++it) {

                r->tryLayoutDoingPositionedMovementOnly();
            r->layoutIfNeeded();
        }
        
        if (hasColumns())
            view()->layoutState()->m_columnInfo = columnInfo(); // FIXME: Kind of gross. We just put this back into the layout state so that pop() will work.
    }
}



    // We need to do multiple passes, breaking up our child painting into strips.
    ColumnInfo* colInfo = columnInfo();
    unsigned colCount = columnCount(colInfo);
    int currXOffset = style()->direction() == LTR ? 0 : contentWidth();
    int ruleAdd = borderLeft() + paddingLeft();
    int ruleX = style()->direction() == LTR ? 0 : contentWidth();
    for (unsigned i = 0; i < colCount; i++) {
        IntRect colRect = columnRectAt(colInfo, i);

        // Move to the next position.
        if (style()->direction() == LTR) {

    GraphicsContext* context = paintInfo.context;
    int colGap = columnGap();
    ColumnInfo* colInfo = columnInfo();
    unsigned colCount = columnCount(colInfo);
    if (!colCount)
        return;
    int currXOffset = style()->direction() == LTR ? 0 : contentWidth() - columnRectAt(colInfo, 0).width();
    int currYOffset = 0;
    for (unsigned i = 0; i < colCount; i++) {
        // For each rect, we clip to the rect, and then we adjust our coords.
        IntRect colRect = columnRectAt(colInfo, i);
        colRect.move(tx, ty);
        PaintInfo info(paintInfo);
        info.rect.intersect(colRect);

    info.updatePaintingRootForChildren(this);
    
    RenderView* renderView = view();
    bool usePrintRect = !renderView->printRect().isEmpty();
    
    bool checkPageBreaks = document()->paginated() && !document()->settings()->paginateDuringLayoutEnabled();
    bool checkColumnBreaks = !checkPageBreaks && usePrintRect;

    for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {        
        // Check for page-break-before: always, and if it's set, break and bail.
        bool checkBeforeAlways = !childrenInline() && (checkPageBreaks && child->style()->pageBreakBefore() == PBALWAYS);
        if (checkBeforeAlways
            && (ty + child->y()) > paintInfo.rect.y()
            && (ty + child->y()) < paintInfo.rect.bottom()) {

            child->paint(info, tx, ty);

        // Check for page-break-after: always, and if it's set, break and bail.
        bool checkAfterAlways = !childrenInline() && (checkPageBreaks && child->style()->pageBreakAfter() == PBALWAYS);
        if (checkAfterAlways
            && (ty + child->y() + child->height()) > paintInfo.rect.y()
            && (ty + child->y() + child->height()) < paintInfo.rect.bottom()) {

        m_positionedObjects->remove(deadObjects.at(i));
}

RenderBlock::FloatingObject* RenderBlock::insertFloatingObject(RenderBox* o)
{
    ASSERT(o->isFloating());


        DeprecatedPtrListIterator<FloatingObject> it(*m_floatingObjects);
        FloatingObject* f;
        while ( (f = it.current()) ) {
            if (f->m_renderer == o)
                return f;
            ++it;
        }
    }

    // Create the special object entry & append it to the list

    o->layoutIfNeeded();

    FloatingObject* newObj = new FloatingObject(o->style()->floating() == FLEFT ? FloatingObject::FloatLeft : FloatingObject::FloatRight);

    newObj->m_top = -1;
    newObj->m_bottom = -1;
    
    // Our location is irrelevant if we're unsplittable or no pagination is in effect.  Just go ahead
    // and lay out the float.
    bool affectedByPagination = o->isRenderBlock() && view()->layoutState()->m_pageHeight;
    if (!affectedByPagination)
        o->layoutIfNeeded();
    else {
        o->calcWidth();
        o->calcVerticalMargins();
    }
    newObj->m_width = o->width() + o->marginLeft() + o->marginRight();

    newObj->m_shouldPaint = !o->hasSelfPaintingLayer(); // If a layer exists, the float will paint itself.  Otherwise someone else will.
    newObj->m_isDescendant = true;
    newObj->m_renderer = o;

    m_floatingObjects->append(newObj);
    
    return newObj;
}

void RenderBlock::removeFloatingObject(RenderBox* o)

    }
}

void RenderBlock::removeFloatingObjects(FloatingObject* f, int y)
{
    if (!m_floatingObjects)
        return;
    
    FloatingObject* curr = m_floatingObjects->last();
    while (curr != f && (curr->m_top == -1 || curr->m_top >= y)) {
        m_floatingObjects->removeLast();
        curr = m_floatingObjects->last();
    }
}

bool RenderBlock::positionNewFloats()
{
    if (!m_floatingObjects)

        }

        RenderBox* o = f->m_renderer;
        int _height = o->height() + o->marginTop() + o->marginBottom();

        int ro = rightOffset(); // Constant part of right offset.
        int lo = leftOffset(); // Constant part of left offset.
        int fwidth = f->m_width; // The width we look for.
        if (ro - lo < fwidth)
            fwidth = ro - lo; // Never look for more than what will be available.
        
        IntRect oldRect(o->x(), o->y() , o->width(), o->height());

        if (o->style()->clear() & CLEFT)
            y = max(leftBottom(), y);
        if (o->style()->clear() & CRIGHT)

            o->setLocation(fx - o->marginRight() - o->width(), y + o->marginTop());
        }

        if (view()->layoutState()->paginated()) {
            RenderBlock* childBlock = o->isRenderBlock() ? toRenderBlock(o) : 0;

            if (childBlock && view()->layoutState()->m_pageHeight && view()->layoutState()->pageY(o->y()) != childBlock->pageY())
                childBlock->setChildNeedsLayout(true, false);
            o->layoutIfNeeded();

            // If we are unsplittable and don't fit, then we need to move down.
            // We include our margins as part of the unsplittable area.
            int newY = adjustForUnsplittableChild(o, y, true);
            
            // See if we have a pagination strut that is making us move down further.
            // Note that an unsplittable child can't also have a pagination strut, so this is
            // exclusive with the case above.
            if (childBlock && childBlock->paginationStrut()) {
                newY += childBlock->paginationStrut();
                childBlock->setPaginationStrut(0);
            }
            
            if (newY != y) {
                f->m_paginationStrut = newY - y;
                y = newY;
                o->setY(y + o->marginTop());
                if (childBlock)
                    childBlock->setChildNeedsLayout(true, false);
                o->layoutIfNeeded();
            }
        }

        f->m_top = y;
        f->m_bottom = f->m_top + o->marginTop() + o->height() + o->marginBottom();
        
        // If the child moved, we have to repaint it.
        if (o->checkForRepaintDuringLayout())
            o->repaintDuringLayoutIfMoved(oldRect);

    return true;
}

bool RenderBlock::positionNewFloatOnLine(FloatingObject* newFloat, FloatingObject* lastFloatFromPreviousLine)
{
    bool didPosition = positionNewFloats();
    if (!didPosition || !newFloat->m_paginationStrut)
        return didPosition;
    
    int floatTop = newFloat->m_top;
    int paginationStrut = newFloat->m_paginationStrut;
    FloatingObject* f = m_floatingObjects->last();
    
    ASSERT(f == newFloat);

    if (floatTop - paginationStrut != height())
        return didPosition;

    for (f = m_floatingObjects->prev(); f && f != lastFloatFromPreviousLine; f = m_floatingObjects->prev()) {
        if (f->m_top == height()) {
            ASSERT(!f->m_paginationStrut);
            f->m_paginationStrut = paginationStrut;
            RenderBox* o = f->m_renderer;
            o->setY(o->y() + o->marginTop() + paginationStrut);
            if (o->isRenderBlock())
                toRenderBlock(o)->setChildNeedsLayout(true, false);
            o->layoutIfNeeded();
            f->m_top += f->m_paginationStrut;
            f->m_bottom += f->m_paginationStrut;
        }
    }
        
    setHeight(height() + paginationStrut);
    
    return didPosition;
}

void RenderBlock::newLine(EClear clear)
{
    positionNewFloats();


    if (hasColumns()) {
        ColumnInfo* colInfo = columnInfo();
        for (unsigned i = 0; i < columnCount(colInfo); i++)
            bottom = max(bottom, columnRectAt(colInfo, i).bottom() + relativeOffset);
        return bottom;
    }


        // This only matters for LTR
        if (style()->direction() == LTR) {
            ColumnInfo* colInfo = columnInfo();
            unsigned count = columnCount(colInfo);
            if (count)
                right = max(columnRectAt(colInfo, count - 1).right() + relativeOffset, right);
        }
        return right;
    }

        // This only matters for RTL
        if (style()->direction() == RTL) {
            ColumnInfo* colInfo = columnInfo();
            unsigned count = columnCount(colInfo);
            if (count)
                left = min(columnRectAt(colInfo, count - 1).x() + relativeOffset, left);
        }
        return left;
    }


void RenderBlock::markAllDescendantsWithFloatsForLayout(RenderBox* floatToRemove, bool inLayout)
{
    if (!m_everHadLayout)
        return;

    setChildNeedsLayout(true, !inLayout);

    if (floatToRemove)

    }
}

void RenderBlock::markDescendantBlocksAndLinesForLayout(bool inLayout)
{
    if (!m_everHadLayout)
        return;

    setChildNeedsLayout(true, !inLayout);
            RenderBox* floatingBox = floatingObject->m_renderer;
            IntRect visibleOverflow = floatingBox->visibleOverflowRect();
            visibleOverflow.move(floatingBox->x(), floatingBox->y());
            if (visibleOverflow.y() < top && visibleOverflow.bottom() > bottom && visibleOverflow.height() <= maxHeight && floatingBox->containingBlock() == this)
                top = visibleOverflow.y();
        }
    }

    // Iterate over our children and mark them as needed.
    if (!childrenInline()) {
        for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
            if (child->isFloatingOrPositioned() || !child->isRenderBlock())
                continue;
            toRenderBlock(child)->markDescendantBlocksAndLinesForLayout(inLayout);
        }
    }
    
    // Walk our floating objects and mark them too.
    if (m_floatingObjects) {
        DeprecatedPtrListIterator<FloatingObject> it(*m_floatingObjects);
        while (it.current()) {
            if (it.current()->m_renderer->isRenderBlock())
                toRenderBlock(it.current()->m_renderer)->markDescendantBlocksAndLinesForLayout(inLayout);
            ++it;
        }
    }

    if (m_positionedObjects) {
        // FIXME: Technically we don't have to mark the positioned objects if we're the block
        // that established the columns, but we don't really have that information here.
        RenderBox* r;
        Iterator end = m_positionedObjects->end();
        for (Iterator it = m_positionedObjects->begin(); it != end; ++it) {
            r = *it;
            if (r->isRenderBlock())
                toRenderBlock(r)->markDescendantBlocksAndLinesForLayout();
        }
    }

    // FIXME: If we're a table, then we have to mark every single cell.
}

int RenderBlock::getClearDelta(RenderBox* child, int yPos)

{
    // We need to do multiple passes, breaking up our hit testing into strips.
    ColumnInfo* colInfo = columnInfo();
    int colCount = columnCount(colInfo);
    if (!colCount)
        return false;
    int left = borderLeft() + paddingLeft();
    int currYOffset = 0;
    int i;
    for (i = 0; i < colCount; i++)
        currYOffset -= columnRectAt(colInfo, i).height();
    for (i = colCount - 1; i >= 0; i--) {
        IntRect colRect = columnRectAt(colInfo, i);
        int currXOffset = colRect.x() - left;
        currYOffset += colRect.height();
        colRect.move(tx, ty);

    bool destroyColumns = !firstChild()
                          || (count == 1 && style()->hasAutoColumnWidth())
                          || firstChild()->isAnonymousColumnsBlock()
                          || firstChild()->isAnonymousColumnSpanBlock();
                          || document()->settings()->paginateDuringLayoutEnabled();
    if (destroyColumns) {
        if (hasColumns()) {
            delete gColumnInfoMap->take(this);

    return gColumnInfoMap->get(this);    
}

unsigned RenderBlock::columnCount(ColumnInfo* colInfo) const
{
    ASSERT(hasColumns() && gColumnInfoMap->get(this) == colInfo);
    return colInfo->columnCount();
}

IntRect RenderBlock::columnRectAt(ColumnInfo* colInfo, unsigned index) const
{
    ASSERT(hasColumns() && gColumnInfoMap->get(this) == colInfo);
    
    bool computeIntrinsicHeight = (endOfContent == -1);

    // Fill the columns in to the available height.  Attempt to balance the height of the columns.
    // Add in half our line-height to help with best-guess initial balancing.
    int columnSlop = lineHeight(false) / 2;
    int remainingSlopSpace = columnSlop * desiredColumnCount;
    int availableHeight = contentHeight();
    int colHeight;
    if (computeIntrinsicHeight && requestedColumnHeight >= 0)
        colHeight = requestedColumnHeight;
    else if (computeIntrinsicHeight)
        colHeight = min(availableHeight, availableHeight / desiredColumnCount + columnSlop);
    else
        colHeight = availableHeight;
    int originalColHeight = colHeight;

    // Compute the appropriate rect based off our information.
    int colWidth = colInfo->desiredColumnWidth();
    int colHeight = colInfo->columnHeight();
    int colTop = borderTop() + paddingTop();
    int colGap = columnGap();
    int colLeft = style()->direction() == LTR ? 
                      borderLeft() + paddingLeft() + (index * (colWidth + colGap))
                      : borderLeft() + paddingLeft() + contentWidth() - colWidth - (index * (colWidth + colGap));
    return IntRect(colLeft, colTop, colWidth, colHeight);
}

bool RenderBlock::layoutColumns(bool hasSpecifiedPageHeight, int pageHeight, LayoutStateMaintainer& statePusher)
{
    if (hasColumns()) {
        ColumnInfo* colInfo = columnInfo();
        int desiredColumnCount = colInfo->desiredColumnCount();
        if (!hasSpecifiedPageHeight && contentHeight() > pageHeight * desiredColumnCount) {
            // Now that we know the intrinsic height of the columns, we have to rebalance them.
            int columnHeight = max(colInfo->minimumColumnHeight(), (int)ceilf((float)contentHeight() / desiredColumnCount));
            if (columnHeight > 0) {
                statePusher.pop();
                m_everHadLayout = true;
                layoutBlock(false, columnHeight);
                return true;
            }
        } 
    for (unsigned i = 0; i < colCount; i++) {
        // If we aren't constrained, then the last column can just get all the remaining space.
        if (computeIntrinsicHeight && i == colCount - 1)
            colHeight = availableHeight;

        // This represents the real column position.
        IntRect colRect(currX, top, desiredColumnWidth, colHeight);

        int truncationPoint = visibleTopOfHighestFloatExtendingBelow(currY + colHeight, colHeight);

        // For the simulated paint, we pretend like everything is in one long strip.
        IntRect pageRect(left, currY, contentWidth(), truncationPoint - currY);
        v->setPrintRect(pageRect);
        v->setTruncatedAt(truncationPoint);
        GraphicsContext context((PlatformGraphicsContext*)0);
        PaintInfo paintInfo(&context, pageRect, PaintPhaseForeground, false, 0, 0);
        
        setHasColumns(false);
        paintObject(paintInfo, 0, 0);
        setHasColumns(true);

        if (computeIntrinsicHeight && v->minimumColumnHeight() > originalColHeight) {
            // The initial column height was too small to contain one line of text.
            minimumColumnHeight = max(minimumColumnHeight, v->minimumColumnHeight());
        }

        int adjustedBottom = v->bestTruncatedAt();
        if (adjustedBottom <= currY)
            adjustedBottom = truncationPoint;
        
        colRect.setHeight(adjustedBottom - currY);
        
        // Add in the lost space to the subsequent columns.
        // FIXME: This will create a "staircase" effect if there are enough columns, but the effect should be pretty subtle.
        if (computeIntrinsicHeight) {
            int lostSpace = colHeight - colRect.height();
            if (lostSpace > remainingSlopSpace) {
                // Redestribute the space among the remaining columns.
                int spaceToRedistribute = lostSpace - remainingSlopSpace;
                int remainingColumns = colCount - i + 1;
                colHeight += spaceToRedistribute / remainingColumns;
            } 
            remainingSlopSpace = max(0, remainingSlopSpace - lostSpace);
        }
        
        if (pageHeight) // FIXME: Should we use lowestPosition (excluding our positioned objects) instead of contentHeight()?
            colInfo->setColumnCountAndHeight(ceilf((float)contentHeight() / pageHeight), pageHeight);
        else
            currX -= (desiredColumnWidth + colGap);

        currY += colRect.height();
        availableHeight -= colRect.height();

        maxColBottom = max(colRect.bottom(), maxColBottom);

        if (columnCount(colInfo)) {
            IntRect lastRect = columnRectAt(colInfo, columnCount(colInfo) - 1);
            int overflowLeft = style()->direction() == RTL ? min(0, lastRect.x()) : 0;
            int overflowRight = style()->direction() == LTR ? max(width(), lastRect.x() + lastRect.width()) : 0;
            int overflowHeight = borderTop() + paddingTop() + colInfo->columnHeight();
            
            setHeight(overflowHeight + borderBottom() + paddingBottom() + horizontalScrollbarHeight());

            m_overflow.clear();
            addLayoutOverflow(IntRect(overflowLeft, 0, overflowRight - overflowLeft, overflowHeight));
        }
    }

    int overflowRight = max(width(), currX - colGap);
    int overflowLeft = min(0, currX + desiredColumnWidth + colGap);
    int overflowHeight = maxColBottom;
    int toAdd = borderBottom() + paddingBottom() + horizontalScrollbarHeight();
        
    if (computeIntrinsicHeight)
        setHeight(maxColBottom + toAdd);

    m_overflow.clear();
    addLayoutOverflow(IntRect(overflowLeft, 0, overflowRight - overflowLeft, overflowHeight));

    v->setPrintRect(IntRect());
    v->setTruncatedAt(0);
    
    ASSERT(colCount == info->columnCount());
    
    return false;
}

void RenderBlock::adjustPointToColumnContents(IntPoint& point) const

        return;
    
    ColumnInfo* colInfo = columnInfo();
    if (!columnCount(colInfo))
        return;

    // Determine which columns we intersect.
    int colGap = columnGap();
    int leftGap = colGap / 2;
    IntPoint columnPoint(columnRectAt(colInfo, 0).location());
    int yOffset = 0;
    for (unsigned i = 0; i < colInfo->columnCount(); i++) {
        // Add in half the column gap to the left and right of the rect.
        IntRect colRect = columnRectAt(colInfo, i);
        IntRect gapAndColumnRect(colRect.x() - leftGap, colRect.y(), colRect.width() + colGap, colRect.height());

        if (point.x() >= gapAndColumnRect.x() && point.x() < gapAndColumnRect.right()) {

    IntRect result;
    
    // Determine which columns we intersect.
    unsigned colCount = columnCount(colInfo);
    if (!colCount)
        return;
    

    
    int currYOffset = 0;
    for (unsigned i = 0; i < colCount; i++) {
        IntRect colRect = columnRectAt(colInfo, i);
        int currXOffset = colRect.x() - left;
        
        IntRect repaintRect = r;


    int left = borderLeft() + paddingLeft();
    int yOffset = 0;
    size_t colCount = columnCount(colInfo);
    for (size_t i = 0; i < colCount; ++i) {
        IntRect columnRect = columnRectAt(colInfo, i);
        int xOffset = columnRect.x() - left;
        if (point.y() < columnRect.bottom() + yOffset) {
            offset.expand(xOffset, -yOffset);


void RenderBlock::setMaxTopMargins(int pos, int neg)
{
    if (!m_rareData) {
        if (pos == RenderBlockRareData::topPosDefault(this) && neg == RenderBlockRareData::topNegDefault(this))
            return;
        m_rareData = new RenderBlockRareData(this);
    }
    m_rareData->m_topPos = pos;
    m_rareData->m_topNeg = neg;
}

void RenderBlock::setMaxBottomMargins(int pos, int neg)
{
    if (!m_rareData) {
        if (pos == RenderBlockRareData::bottomPosDefault(this) && neg == RenderBlockRareData::bottomNegDefault(this))
            return;
        m_rareData = new RenderBlockRareData(this);
    }
    m_rareData->m_bottomPos = pos;
    m_rareData->m_bottomNeg = neg;
}

void RenderBlock::setPaginationStrut(int strut)
{
    if (!m_rareData) {
        if (strut == 0)
            return;
        m_rareData = new RenderBlockRareData(this);
    }
    m_rareData->m_paginationStrut = strut;
}

void RenderBlock::setPageY(int y)
{
    if (!m_rareData) {
        if (y == 0)
            return;
        m_rareData = new RenderBlockRareData(this);
    }
    m_rareData->m_pageY = y;
}

void RenderBlock::absoluteRects(Vector<IntRect>& rects, int tx, int ty)

    return newBox;
}

int RenderBlock::nextPageTop(int yPos) const
{
    LayoutState* layoutState = view()->layoutState();
    if (!layoutState->m_pageHeight)
        return yPos;
    
    // The yPos is in our coordinate space.  We can add in our pushed offset.
    int pageHeight = layoutState->m_pageHeight;
    int remainingHeight = pageHeight - ((layoutState->m_layoutOffset - layoutState->m_pageOffset).height() + yPos) % pageHeight;
    return yPos + remainingHeight;
}

int RenderBlock::applyBeforeBreak(RenderBox* child, int yPos)
{
    bool checkPageBreaks = document()->paginated() && document()->settings()->paginateDuringLayoutEnabled();
    bool checkColumnBreaks = view()->layoutState()->paginatingColumns();
    bool checkBeforeAlways = (checkPageBreaks && child->style()->pageBreakBefore() == PBALWAYS) || (checkColumnBreaks && child->style()->columnBreakBefore() == PBALWAYS);
    if (checkBeforeAlways)
        return nextPageTop(yPos);
    return yPos;
}

int RenderBlock::applyAfterBreak(RenderBox* child, int yPos, MarginInfo& marginInfo)
{
    bool checkPageBreaks = document()->paginated() && document()->settings()->paginateDuringLayoutEnabled();
    bool checkColumnBreaks = view()->layoutState()->paginatingColumns();
    bool checkAfterAlways = (checkPageBreaks && child->style()->pageBreakAfter() == PBALWAYS) || (checkColumnBreaks && child->style()->columnBreakAfter() == PBALWAYS);
    if (checkAfterAlways) {
        marginInfo.setBottomQuirk(true); // Cause margins to be discarded for any following content.
        return nextPageTop(yPos);
    }
    return yPos;
}

int RenderBlock::adjustForUnsplittableChild(RenderBox* child, int yPos, bool includeMargins)
{
    bool isUnsplittable = child->isReplaced() || child->scrollsOverflow();
    if (!isUnsplittable)
        return yPos;
    int childHeight = child->height() + (includeMargins ? child->marginTop() + child->marginBottom() : 0);
    LayoutState* layoutState = view()->layoutState();
    if (layoutState->m_columnInfo)
        layoutState->m_columnInfo->updateMinimumColumnHeight(childHeight);
    int pageHeight = layoutState->m_pageHeight;
    if (!pageHeight || childHeight > pageHeight)
        return yPos;
    int remainingHeight = pageHeight - ((layoutState->m_layoutOffset - layoutState->m_pageOffset).height() + yPos) % pageHeight;
    if (remainingHeight < childHeight)
        return yPos + remainingHeight;
    return yPos;
}

void RenderBlock::adjustLinePositionForPagination(RootInlineBox* lineBox, int& delta)
{
    // FIXME: For now we paginate using line overflow.  This ensures that lines don't overlap at all when we
    // put a strut between them for pagination purposes.  However, this really isn't the desired rendering, since
    // the line on the top of the next page will appear too far down relative to the same kind of line at the top
    // of the first column.
    //
    // The rendering we would like to see is one where the lineTop is at the top of the column, and any line overflow
    // simply spills out above the top of the column.  This effect would match what happens at the top of the first column.
    // We can't achieve this rendering, however, until we stop columns from clipping to the column bounds (thus allowing
    // for overflow to occur), and then cache visible overflow for each column rect.
    //
    // Furthermore, the paint we have to do when a column has overflow has to be special.  We need to exclude
    // content that paints in a previous column (and content that paints in the following column).
    //
    // FIXME: Another problem with simply moving lines is that the available line width may change (because of floats).
    // Technically if the location we move the line to has a different line width than our old position, then we need to dirty the
    // line and all following lines.
    LayoutState* layoutState = view()->layoutState();
    int pageHeight = layoutState->m_pageHeight;
    int yPos = lineBox->topVisibleOverflow();
    int lineHeight = lineBox->bottomVisibleOverflow() - yPos;
    if (layoutState->m_columnInfo)
        layoutState->m_columnInfo->updateMinimumColumnHeight(lineHeight);
    yPos += delta;
    lineBox->setPaginationStrut(0);
    if (!pageHeight || lineHeight > pageHeight)
        return;
    int remainingHeight = pageHeight - ((layoutState->m_layoutOffset - layoutState->m_pageOffset).height() + yPos) % pageHeight;
    if (remainingHeight < lineHeight) {
        int totalHeight = lineHeight + max(0, yPos);
        if (lineBox == firstRootBox() && totalHeight < pageHeight && !isPositioned() && !isTableCell())
            setPaginationStrut(remainingHeight + max(0, yPos));
        else {
            delta += remainingHeight;
            lineBox->setPaginationStrut(remainingHeight);
        }
    }  
}
 
const char* RenderBlock::renderName() const
{
    if (isBody())




class ColumnInfo;
class InlineIterator;
class LayoutStateMaintainer;
class RenderInline;

struct BidiRun;

    virtual void addChild(RenderObject* newChild, RenderObject* beforeChild = 0);
    virtual void removeChild(RenderObject*);

    virtual void layoutBlock(bool relayoutChildren, int pageHeight = 0);

    void insertPositionedObject(RenderBox*);
    void removePositionedObject(RenderBox*);


    void markAllDescendantsWithFloatsForLayout(RenderBox* floatToRemove = 0, bool inLayout = true);
    void markPositionedObjectsForLayout();
    void markDescendantBlocksAndLinesForLayout(bool inLayout = true);

    bool containsFloats() { return m_floatingObjects && !m_floatingObjects->isEmpty(); }
    bool containsFloat(RenderObject*);


    ColumnInfo* columnInfo() const;
    int columnGap() const;
    
    // These two functions take the ColumnInfo* to avoid repeated lookups of the info in the global HashMap.
    unsigned columnCount(ColumnInfo*) const;
    IntRect columnRectAt(ColumnInfo*, unsigned) const;

protected:
    // These functions are only used internally to manipulate the render tree structure via remove/insert/appendChildNode.

    }
    void moveChildrenTo(RenderBlock* to, RenderObject* startChild, RenderObject* endChild, RenderObject* beforeChild, bool fullRemoveInsert = false);
    
    int maxTopPosMargin() const { return m_rareData ? m_rareData->m_topPos : RenderBlockRareData::topPosDefault(this); }
    int maxTopNegMargin() const { return m_rareData ? m_rareData->m_topNeg : RenderBlockRareData::topNegDefault(this); }
    int maxBottomPosMargin() const { return m_rareData ? m_rareData->m_bottomPos : RenderBlockRareData::bottomPosDefault(this); }
    int maxBottomNegMargin() const { return m_rareData ? m_rareData->m_bottomNeg : RenderBlockRareData::bottomNegDefault(this); }
    int paginationStrut() const { return m_rareData ? m_rareData->m_paginationStrut : 0; }
    int pageY() const { return m_rareData ? m_rareData->m_pageY : 0; }
    void setMaxTopMargins(int pos, int neg);
    void setMaxBottomMargins(int pos, int neg);
    void setPaginationStrut(int strut);
    void setPageY(int y);

    void initMaxMarginValues()
    {
        if (m_rareData) {
            m_rareData->m_topPos = RenderBlockRareData::topPosDefault(this);
            m_rareData->m_topNeg = RenderBlockRareData::topNegDefault(this);
            m_rareData->m_bottomPos = RenderBlockRareData::bottomPosDefault(this);
            m_rareData->m_bottomNeg = RenderBlockRareData::bottomNegDefault(this);
            m_rareData->m_paginationStrut = 0;
        }
    }


        bool everHadLayout;
    };

    struct FloatingObject : Noncopyable {
        enum Type {
            FloatLeft,
            FloatRight
        };

        FloatingObject(Type type)
            : m_renderer(0)
            , m_top(0)
            , m_bottom(0)
            , m_left(0)
            , m_width(0)
            , m_paginationStrut(0)
            , m_type(type)
            , m_shouldPaint(true)
            , m_isDescendant(false)
        {
        }

        Type type() { return static_cast<Type>(m_type); }

        RenderBox* m_renderer;
        int m_top;
        int m_bottom;
        int m_left;
        int m_width;
        int m_paginationStrut;
        unsigned m_type : 1; // Type (left or right aligned)
        bool m_shouldPaint : 1;
        bool m_isDescendant : 1;
    };

    // The following functions' implementations are in RenderBlockLineLayout.cpp.
    RootInlineBox* determineStartPosition(bool& firstLine, bool& fullLayout, bool& previousLineBrokeCleanly,
                                          InlineBidiResolver&, Vector<FloatWithRect>& floats, unsigned& numCleanFloats,
                                          bool& useRepaintBounds, int& repaintTop, int& repaintBottom);
    RootInlineBox* determineEndPosition(RootInlineBox* startBox, InlineIterator& cleanLineStart,
                                        BidiStatus& cleanLineBidiStatus,
                                        int& yPos);

                        RootInlineBox*& endLine, int& endYPos, int& repaintBottom, int& repaintTop);

    void skipTrailingWhitespace(InlineIterator&, bool isLineEmpty, bool previousLineBrokeCleanly);
    int skipLeadingWhitespace(InlineBidiResolver&, bool firstLine, bool isLineEmpty, bool previousLineBrokeCleanly, FloatingObject* lastFloatFromPreviousLine);
    void fitBelowFloats(int widthToFit, bool firstLine, int& availableWidth);
    InlineIterator findNextLineBreak(InlineBidiResolver&, bool firstLine, bool& isLineEmpty, bool& previousLineBrokeCleanly, bool& hyphenated, EClear*, FloatingObject* lastFloatFromPreviousLine);
    RootInlineBox* constructLine(unsigned runCount, BidiRun* firstRun, BidiRun* lastRun, bool firstLine, bool lastLine, RenderObject* endObject);
    InlineFlowBox* createLineBoxes(RenderObject*, bool firstLine);
    void computeHorizontalPositionsForLine(RootInlineBox*, bool firstLine, BidiRun* firstRun, BidiRun* trailingSpaceRun, bool reachedEnd, GlyphOverflowAndFallbackFontsMap&);

    void paintSelection(PaintInfo&, int tx, int ty);
    void paintCaret(PaintInfo&, int tx, int ty, CaretType);

    FloatingObject* insertFloatingObject(RenderBox*);
    void removeFloatingObject(RenderBox*);
    void removeFloatingObjects(FloatingObject*, int y);
    
    // Called from lineWidth, to position the floats added in the last line.
    // Returns true if and only if it has positioned any floats.
    bool positionNewFloats();
    
    // Positions new floats and also adjust all floats encountered on the line if any of them
    // have to move to the next page/column.
    bool positionNewFloatOnLine(FloatingObject* newFloat, FloatingObject* lastFloatFromPreviousLine);

    void clearFloats();
    int getClearDelta(RenderBox* child, int yPos);


    void offsetForContents(int& tx, int& ty) const;

    void calcColumnWidth();
    bool layoutColumns(bool hasSpecifiedPageHeight, int pageHeight, LayoutStateMaintainer&);
    int visibleTopOfHighestFloatExtendingBelow(int bottom, int maxHeight) const;
    void makeChildrenAnonymousColumnBlocks(RenderObject* beforeChild, RenderBlock* newBlockBox, RenderObject* newChild);

    bool expandsToEncloseOverhangingFloats() const;

    RenderBlock* continuationBefore(RenderObject* beforeChild);
    RenderBlock* containingColumnsBlock(bool allowAnonymousColumnBlock = true);
    RenderBlock* columnsBlockForSpanningElement(RenderObject* newChild);
    
    struct FloatingObject : Noncopyable {
        enum Type {
            FloatLeft,
            FloatRight
        };

        FloatingObject(Type type)
            : m_renderer(0)
            , m_top(0)
            , m_bottom(0)
            , m_left(0)
            , m_width(0)
            , m_type(type)
            , m_shouldPaint(true)
            , m_isDescendant(false)
        {
        }

        Type type() { return static_cast<Type>(m_type); }

        RenderBox* m_renderer;
        int m_top;
        int m_bottom;
        int m_left;
        int m_width;
        unsigned m_type : 1; // Type (left or right aligned)
        bool m_shouldPaint : 1;
        bool m_isDescendant : 1;
    };

    class MarginInfo {
        // Collapsing flags for whether we can collapse our margins with our children's margins.

    void setCollapsedBottomMargin(const MarginInfo&);
    // End helper functions and structs used by layoutBlockChildren.

    // Pagination routines.
    int nextPageTop(int yPos) const; // Returns the top of the next page following yPos.
    int applyBeforeBreak(RenderBox* child, int yPos); // If the child has a before break, then return a new yPos that shifts to the top of the next page/column.
    int applyAfterBreak(RenderBox* child, int yPos, MarginInfo& marginInfo); // If the child has an after break, then return a new yPos that shifts to the top of the next page/column.
    int adjustForUnsplittableChild(RenderBox* child, int yPos, bool includeMargins = false); // If the child is unsplittable and can't fit on the current page, return the top of the next page/column.
    void adjustLinePositionForPagination(RootInlineBox*, int& deltaY); // Computes a deltaY value that put a line at the top of the next page if it doesn't fit on the current page.

    typedef PositionedObjectsListHashSet::const_iterator Iterator;
    DeprecatedPtrList<FloatingObject>* m_floatingObjects;
    

    RenderBoxModelObject* m_continuation;

    // Allocated only when some of these fields have non-default values
    struct RenderBlockRareData : Noncopyable {
        RenderBlockRareData(const RenderBlock* o) 
            : m_topPos(topPosDefault(o))
            , m_topNeg(topNegDefault(o))
            , m_bottomPos(bottomPosDefault(o))
            , m_bottomNeg(bottomNegDefault(o))
            , m_paginationStrut(0)
            , m_pageY(0)
        { 
        }


        static int topNegDefault(const RenderBlock* o) { return o->marginTop() < 0 ? -o->marginTop() : 0; }
        static int bottomPosDefault(const RenderBlock* o) { return o->marginBottom() > 0 ? o->marginBottom() : 0; }
        static int bottomNegDefault(const RenderBlock* o) { return o->marginBottom() < 0 ? -o->marginBottom() : 0; }
        
        int m_topPos;
        int m_topNeg;
        int m_bottomPos;
        int m_bottomNeg;
        int m_paginationStrut;
        int m_pageY;
     };

    RenderBlockRareData* m_rareData;

    RenderObjectChildList m_children;
    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>.



#include "RenderLayer.h"
#include "RenderListMarker.h"
#include "RenderView.h"
#include "Settings.h"
#include "TrailingFloatsRootInlineBox.h"
#include "break_lines.h"
#include <wtf/AlwaysInline.h>

            
                if (o->isPositioned())
                    o->containingBlock()->insertPositionedObject(box);
                else if (o->isFloating())
                    floats.append(FloatWithRect(box));
                else if (fullLayout || o->needsLayout()) {
                    // Replaced elements
                    toRenderBox(o)->dirtyLineBoxes(fullLayout);

                    o->layoutIfNeeded();
                }
            } else if (o->isText() || (o->isRenderInline() && !endOfInline)) {

        unsigned floatIndex;
        bool firstLine = true;
        bool previousLineBrokeCleanly = true;
        RootInlineBox* startLine = determineStartPosition(firstLine, fullLayout, previousLineBrokeCleanly, resolver, floats, floatIndex,
                                                          useRepaintBounds, repaintTop, repaintBottom);

        if (fullLayout && hasInlineChild && !selfNeedsLayout()) {
            setNeedsLayout(true, false);  // Mark ourselves as needing a full layout. This way we'll repaint like

                                 0 : determineEndPosition(startLine, cleanLineStart, cleanLineBidiStatus, endLineYPos);

        if (startLine) {
            if (!useRepaintBounds) {
                useRepaintBounds = true;
                repaintTop = height();
                repaintBottom = height();
            }
            RenderArena* arena = renderArena();
            RootInlineBox* box = startLine;
            while (box) {

        bool checkForFloatsFromLastLine = false;

        bool isLineEmpty = true;
        bool paginated = view()->layoutState()->paginated();

        while (!end.atEnd()) {
            // FIXME: Is this check necessary before the first iteration or can it be moved to the end?

            
            EClear clear = CNONE;
            bool hyphenated;
            
            InlineIterator oldEnd = end;
            FloatingObject* lastFloatFromPreviousLine = m_floatingObjects ? m_floatingObjects->last() : 0;
            end = findNextLineBreak(resolver, firstLine, isLineEmpty, previousLineBrokeCleanly, hyphenated, &clear, lastFloatFromPreviousLine);
            if (resolver.position().atEnd()) {
                resolver.deleteRuns();
                checkForFloatsFromLastLine = true;

                // inline flow boxes.

                RootInlineBox* lineBox = 0;
                int oldHeight = height();
                if (resolver.runCount()) {
                    if (hyphenated)
                        resolver.logicallyLastRun()->m_hasHyphen = true;

                        repaintTop = min(repaintTop, lineBox->topVisibleOverflow());
                        repaintBottom = max(repaintBottom, lineBox->bottomVisibleOverflow());
                    }
                    
                    if (paginated) {
                        int adjustment = 0;
                        adjustLinePositionForPagination(lineBox, adjustment);
                        if (adjustment) {
                            int oldLineWidth = lineWidth(oldHeight, firstLine);
                            lineBox->adjustPosition(0, adjustment);
                            if (useRepaintBounds) // This can only be a positive adjustment, so no need to update repaintTop.
                                repaintBottom = max(repaintBottom, lineBox->bottomVisibleOverflow());
                                
                            if (lineWidth(oldHeight + adjustment, firstLine) != oldLineWidth) {
                                // We have to delete this line, remove all floats that got added, and let line layout re-run.
                                lineBox->deleteLine(renderArena());
                                removeFloatingObjects(lastFloatFromPreviousLine, oldHeight);
                                setHeight(oldHeight + adjustment);
                                resolver.setPosition(oldEnd);
                                end = oldEnd;
                                continue;
                            }

                            setHeight(lineBox->blockHeight());
                        }
                    }
                }

                firstLine = false;

                int delta = height() - endLineYPos;
                for (RootInlineBox* line = endLine; line; line = line->nextRootBox()) {
                    line->attachLine();
                    if (paginated) {
                        delta -= line->paginationStrut();
                        adjustLinePositionForPagination(line, delta);
                    }
                    if (delta) {
                        repaintTop = min(repaintTop, line->topVisibleOverflow() + min(delta, 0));
                        repaintBottom = max(repaintBottom, line->bottomVisibleOverflow() + max(delta, 0));

}

RootInlineBox* RenderBlock::determineStartPosition(bool& firstLine, bool& fullLayout, bool& previousLineBrokeCleanly, 
                                                   InlineBidiResolver& resolver, Vector<FloatWithRect>& floats, unsigned& numCleanFloats,
                                                   bool& useRepaintBounds, int& repaintTop, int& repaintBottom)
{
    RootInlineBox* curr = 0;
    RootInlineBox* last = 0;

    bool dirtiedByFloat = false;
    if (!fullLayout) {
        // Paginate all of the clean lines.
        bool paginated = view()->layoutState()->paginated();
        int paginationDelta = 0;
        size_t floatIndex = 0;
        for (curr = firstRootBox(); curr && !curr->isDirty(); curr = curr->nextRootBox()) {
            if (paginated) {
                paginationDelta -= curr->paginationStrut();
                adjustLinePositionForPagination(curr, paginationDelta);
                if (paginationDelta) {
                    if (containsFloats() || !floats.isEmpty()) {
                        // FIXME: Do better eventually.  For now if we ever shift because of pagination and floats are present just go to a full layout.
                        fullLayout = true; 
                        break;
                    }
                    
                    if (!useRepaintBounds)
                        useRepaintBounds = true;
                        
                    repaintTop = min(repaintTop, curr->topVisibleOverflow() + min(paginationDelta, 0));
                    repaintBottom = max(repaintBottom, curr->bottomVisibleOverflow() + max(paginationDelta, 0));
                    curr->adjustPosition(0, paginationDelta);
                }                
            }
            
            if (Vector<RenderBox*>* cleanLineFloats = curr->floatsPtr()) {
                Vector<RenderBox*>::iterator end = cleanLineFloats->end();
                for (Vector<RenderBox*>::iterator o = cleanLineFloats->begin(); o != end; ++o) {
                    RenderBox* f = *o;
                    f->layoutIfNeeded();
                    IntSize newSize(f->width() + f->marginLeft() + f->marginRight(), f->height() + f->marginTop() + f->marginBottom());
                    ASSERT(floatIndex < floats.size());
                    if (floats[floatIndex].object != f) {
                        // A new float has been inserted before this line or before its last known float.

    }
}

int RenderBlock::skipLeadingWhitespace(InlineBidiResolver& resolver, bool firstLine, bool isLineEmpty, bool previousLineBrokeCleanly,
                                       FloatingObject* lastFloatFromPreviousLine)
{
    int availableWidth = lineWidth(height(), firstLine);
    while (!resolver.position().atEnd() && !requiresLineBox(resolver.position(), isLineEmpty, previousLineBrokeCleanly)) {
        RenderObject* object = resolver.position().obj;
        if (object->isFloating()) {
            positionNewFloatOnLine(insertFloatingObject(toRenderBox(object)), lastFloatFromPreviousLine);
            positionNewFloats();
            availableWidth = lineWidth(height(), firstLine);
        } else if (object->isPositioned()) {
            // FIXME: The math here is actually not really right.  It's a best-guess approximation that

}

InlineIterator RenderBlock::findNextLineBreak(InlineBidiResolver& resolver, bool firstLine,  bool& isLineEmpty, bool& previousLineBrokeCleanly, 
                                              bool& hyphenated, EClear* clear, FloatingObject* lastFloatFromPreviousLine)
{
    ASSERT(resolver.position().block == this);

    bool appliedStartWidth = resolver.position().pos > 0;
    LineMidpointState& lineMidpointState = resolver.midpointState();
    
    int width = skipLeadingWhitespace(resolver, firstLine, isLineEmpty, previousLineBrokeCleanly, lastFloatFromPreviousLine);

    int w = 0;
    int tmpW = 0;

            // add to special objects...
            if (o->isFloating()) {
                RenderBox* floatBox = toRenderBox(o);
                FloatingObject* f = insertFloatingObject(floatBox);
                // check if it fits in the current line.
                // If it does, position it now, otherwise, position
                // it after moving to next line (in newLine() func)
                if (floatsFitOnLine && floatBox->width() + floatBox->marginLeft() + floatBox->marginRight() + w + tmpW <= width) {
                    positionNewFloatOnLine(f, lastFloatFromPreviousLine);
                    width = lineWidth(height(), firstLine);
                } else
                    floatsFitOnLine = false;



    if (RenderView* v = view()) {
        if (v->layoutStateEnabled() && !repaintContainer) {
            LayoutState* layoutState = v->layoutState();
            IntSize offset = layoutState->m_paintOffset;
            offset.expand(x(), y());
            if (style()->position() == RelativePosition && layer())
                offset += layer()->relativePositionOffset();

                rect.move(layer()->relativePositionOffset());

            rect.move(x(), y());
            rect.move(layoutState->m_paintOffset);
            if (layoutState->m_clipped)
                rect.intersect(layoutState->m_clipRect);
            return;

Lines 201-207 void RenderFlexibleBox::calcPrefWidths() WebCore/rendering/RenderFlexibleBox.cpp_sec1
- WebCore/rendering/RenderFlexibleBox.cpp -1 / +1 lines
201	setPrefWidthsDirty(false);	201	setPrefWidthsDirty(false);
202	}	202	}
203		203
204	void RenderFlexibleBox::layoutBlock(bool relayoutChildren)	204	void RenderFlexibleBox::layoutBlock(bool relayoutChildren, int /pageHeight FIXME: Implement /)
205	{	205	{
206	ASSERT(needsLayout());	206	ASSERT(needsLayout());
207		207

Lines 38-44 public: WebCore/rendering/RenderFlexibleBox.h_sec1
- WebCore/rendering/RenderFlexibleBox.h -1 / +1 lines
38	void calcHorizontalPrefWidths();	38	void calcHorizontalPrefWidths();
39	void calcVerticalPrefWidths();	39	void calcVerticalPrefWidths();
40		40
41	virtual void layoutBlock(bool relayoutChildren);	41	virtual void layoutBlock(bool relayoutChildren, int pageHeight);
42	void layoutHorizontalBox(bool relayoutChildren);	42	void layoutHorizontalBox(bool relayoutChildren);
43	void layoutVerticalBox(bool relayoutChildren);	43	void layoutVerticalBox(bool relayoutChildren);
44		44



            LayoutState* layoutState = v->layoutState();
            if (style()->position() == RelativePosition && layer())
                rect.move(layer()->relativePositionOffset());
            rect.move(layoutState->m_paintOffset);
            if (layoutState->m_clipped)
                rect.intersect(layoutState->m_clipRect);
            return;

    if (RenderView *v = view()) {
        if (v->layoutStateEnabled() && !repaintContainer) {
            LayoutState* layoutState = v->layoutState();
            IntSize offset = layoutState->m_paintOffset;
            if (style()->position() == RelativePosition && layer())
                offset += layer()->relativePositionOffset();
            transformState.move(offset);



    columnBlock->layer()->convertToLayerCoords(rootLayer, layerX, layerY);
    
    ColumnInfo* colInfo = columnBlock->columnInfo();
    unsigned colCount = columnBlock->columnCount(colInfo);
    int currYOffset = 0;
    for (unsigned i = 0; i < colCount; i++) {
        // For each rect, we clip to the rect, and then we adjust our coords.
        IntRect colRect = columnBlock->columnRectAt(colInfo, i);
        int currXOffset = colRect.x() - (columnBlock->borderLeft() + columnBlock->paddingLeft());
        colRect.move(layerX, layerY);


    columnBlock->layer()->convertToLayerCoords(rootLayer, layerX, layerY);
    
    ColumnInfo* colInfo = columnBlock->columnInfo();
    int colCount = columnBlock->columnCount(colInfo);
    
    // We have to go backwards from the last column to the first.
    int left = columnBlock->borderLeft() + columnBlock->paddingLeft();
    int currYOffset = 0;
    int i;
    for (i = 0; i < colCount; i++)
        currYOffset -= columnBlock->columnRectAt(colInfo, i).height();
    for (i = colCount - 1; i >= 0; i--) {
        // For each rect, we clip to the rect, and then we adjust our coords.
        IntRect colRect = columnBlock->columnRectAt(colInfo, i);
        int currXOffset = colRect.x() - left;
        currYOffset += colRect.height();
        colRect.move(layerX, layerY);



#include "RenderInline.h"
#include "RenderView.h"
#include "RootInlineBox.h"
#include "Settings.h" // FIXME: This include can be removed when paginateDuringLayoutEnabled is taken out.

using namespace std;


        return;

    RenderView* v = renderer->view();
    bool usePrintRect = !v->printRect().isEmpty();
    
    // We can check the first box and last box and avoid painting if we don't
    // intersect.  This is a quick short-circuit that we can take to avoid walking any lines.

        int bottom = curr->bottomVisibleOverflow() + renderer->maximalOutlineSize(info.phase);
        h = bottom - top;
        yPos = ty + top;
        v->setMinimumColumnHeight(h);
        if (yPos < info.rect.bottom() && yPos + h > info.rect.y())
            curr->paint(info, tx, ty);
    }



    , m_maximalOutlineSize(0)
    , m_bestTruncatedAt(0)
    , m_truncatorWidth(0)
    , m_minimumColumnHeight(0)
    , m_forcedPageBreak(false)
    , m_layoutState(0)
    , m_layoutStateDisableCount(0)


void RenderView::pushLayoutState(RenderObject* root)
{
    ASSERT(!doingFullRepaint());
    ASSERT(m_layoutStateDisableCount == 0);
    ASSERT(m_layoutState == 0);




    IntRect printRect() const { return m_printRect; }
    void setPrintRect(const IntRect& r) { m_printRect = r; }

    void setTruncatedAt(int y) { m_truncatedAt = y; m_bestTruncatedAt = m_truncatorWidth = 0; m_forcedPageBreak = false; }
    void setBestTruncatedAt(int y, RenderBoxModelObject* forRenderer, bool forcedBreak = false);
    void setMinimumColumnHeight(int height) { m_minimumColumnHeight = height; }
    int bestTruncatedAt() const { return m_bestTruncatedAt; }
    

    int truncatedAt() const { return m_truncatedAt; }

    virtual void absoluteRects(Vector<IntRect>&, int tx, int ty);


    bool doingFullRepaint() const { return m_frameView->needsFullRepaint(); }

    void pushLayoutState(RenderBox* renderer, const IntSize& offset, int pageHeight = 0, ColumnInfo* colInfo = 0)
    {
        if (doingFullRepaint())
            return;
        // We push LayoutState even if layoutState is disabled because it stores layoutDelta too.
        if (!doingFullRepaint() || renderer->hasColumns() || m_layoutState->paginated())
            m_layoutState = new (renderArena()) LayoutState(m_layoutState, renderer, offset, pageHeight, colInfo);
    }

    void pushLayoutState(RenderObject*);

    void popLayoutState()
    {
        if (doingFullRepaint())
            return;
        LayoutState* state = m_layoutState;
        if (doingFullRepaint() && !m_layoutState->paginated())
            return;
        m_layoutState = state->m_next;
        state->destroy(renderArena());
    }

private:
    int m_bestTruncatedAt;
    int m_truncatorWidth;
    int m_minimumColumnHeight;
    bool m_forcedPageBreak;
    LayoutState* m_layoutState;
    unsigned m_layoutStateDisableCount;

class LayoutStateMaintainer : public Noncopyable {
public:
    // ctor to push now
    LayoutStateMaintainer(RenderView* view, RenderBox* root, IntSize offset, bool disableState = false, int pageHeight = 0, ColumnInfo* colInfo = 0)
        : m_view(view)
        , m_disabled(disableState)
        , m_didStart(false)
        , m_didEnd(false)
    {
        push(root, offset, pageHeight, colInfo);
    }
    
    // ctor to maybe push later

        ASSERT(m_didStart == m_didEnd);   // if this fires, it means that someone did a push(), but forgot to pop().
    }

    void push(RenderBox* root, IntSize offset, int pageHeight = 0, ColumnInfo* colInfo = 0)
    {
        ASSERT(!m_didStart);
        // We push state even if disabled, because we still need to store layoutDelta
        m_view->pushLayoutState(root, offset, pageHeight, colInfo);
        if (m_disabled)
            m_view->disableLayoutState();
        m_didStart = true;

Lines 40-45 public: WebCore/rendering/RootInlineBox.h_sec1
- WebCore/rendering/RootInlineBox.h +6 lines
40	, m_lineBreakPos(0)	40	, m_lineBreakPos(0)
41	, m_lineTop(0)	41	, m_lineTop(0)
42	, m_lineBottom(0)	42	, m_lineBottom(0)
		43	, m_paginationStrut(0)
43	{	44	{
44	}	45	}
45		46
Lines 57-62 public: WebCore/rendering/RootInlineBox.h_sec2
57	int lineTop() const { return m_lineTop; }	58	int lineTop() const { return m_lineTop; }
58	int lineBottom() const { return m_lineBottom; }	59	int lineBottom() const { return m_lineBottom; }
59		60
		61	int paginationStrut() const { return m_paginationStrut; }
		62	void setPaginationStrut(int s) { m_paginationStrut = s; }
		63
60	int selectionTop() const;	64	int selectionTop() const;
61	int selectionBottom() const { return lineBottom(); }	65	int selectionBottom() const { return lineBottom(); }
62	int selectionHeight() const { return max(0, selectionBottom() - selectionTop()); }	66	int selectionHeight() const { return max(0, selectionBottom() - selectionTop()); }
Lines 141-146 private: WebCore/rendering/RootInlineBox.h_sec3
141	int m_lineTop;	145	int m_lineTop;
142	int m_lineBottom;	146	int m_lineBottom;
143		147
		148	int m_paginationStrut;
		149
144	// Floats hanging off the line are pushed into this vector during layout. It is only	150	// Floats hanging off the line are pushed into this vector during layout. It is only
145	// good for as long as the line has not been marked dirty.	151	// good for as long as the line has not been marked dirty.
146	OwnPtr<Vector<RenderBox*> > m_floats;	152	OwnPtr<Vector<RenderBox*> > m_floats;

Return to Bug 38402

Lines 33-38 WebCore/rendering/RenderBlockLineLayout.cpp_sec1
- WebCore/rendering/RenderBlockLineLayout.cpp -20 / +79 lines
33	#include "RenderLayer.h"	33	#include "RenderLayer.h"
34	#include "RenderListMarker.h"	34	#include "RenderListMarker.h"
35	#include "RenderView.h"	35	#include "RenderView.h"
		36	#include "Settings.h"
36	#include "TrailingFloatsRootInlineBox.h"	37	#include "TrailingFloatsRootInlineBox.h"
37	#include "break_lines.h"	38	#include "break_lines.h"
38	#include <wtf/AlwaysInline.h>	39	#include <wtf/AlwaysInline.h>
Lines 570-581 void RenderBlock::layoutInlineChildren(b WebCore/rendering/RenderBlockLineLayout.cpp_sec2
570		571
571	if (o->isPositioned())	572	if (o->isPositioned())
572	o->containingBlock()->insertPositionedObject(box);	573	o->containingBlock()->insertPositionedObject(box);
573	else {	574	else if (o->isFloating())
574	if (o->isFloating())	575	floats.append(FloatWithRect(box));
575	floats.append(FloatWithRect(box));	576	else if (fullLayout \|\| o->needsLayout()) {
576	else if (fullLayout \|\| o->needsLayout()) // Replaced elements	577	// Replaced elements
577	toRenderBox(o)->dirtyLineBoxes(fullLayout);	578	toRenderBox(o)->dirtyLineBoxes(fullLayout);
578
579	o->layoutIfNeeded();	579	o->layoutIfNeeded();
580	}	580	}
581	} else if (o->isText() \|\| (o->isRenderInline() && !endOfInline)) {	581	} else if (o->isText() \|\| (o->isRenderInline() && !endOfInline)) {
Lines 594-600 void RenderBlock::layoutInlineChildren(b WebCore/rendering/RenderBlockLineLayout.cpp_sec3
594	unsigned floatIndex;	594	unsigned floatIndex;
595	bool firstLine = true;	595	bool firstLine = true;
596	bool previousLineBrokeCleanly = true;	596	bool previousLineBrokeCleanly = true;
597	RootInlineBox* startLine = determineStartPosition(firstLine, fullLayout, previousLineBrokeCleanly, resolver, floats, floatIndex);	597	RootInlineBox* startLine = determineStartPosition(firstLine, fullLayout, previousLineBrokeCleanly, resolver, floats, floatIndex,
		598	useRepaintBounds, repaintTop, repaintBottom);
598		599
599	if (fullLayout && hasInlineChild && !selfNeedsLayout()) {	600	if (fullLayout && hasInlineChild && !selfNeedsLayout()) {
600	setNeedsLayout(true, false); // Mark ourselves as needing a full layout. This way we'll repaint like	601	setNeedsLayout(true, false); // Mark ourselves as needing a full layout. This way we'll repaint like
Lines 622-630 void RenderBlock::layoutInlineChildren(b WebCore/rendering/RenderBlockLineLayout.cpp_sec4
622	0 : determineEndPosition(startLine, cleanLineStart, cleanLineBidiStatus, endLineYPos);	623	0 : determineEndPosition(startLine, cleanLineStart, cleanLineBidiStatus, endLineYPos);
623		624
624	if (startLine) {	625	if (startLine) {
625	useRepaintBounds = true;	626	if (!useRepaintBounds) {
626	repaintTop = height();	627	useRepaintBounds = true;
627	repaintBottom = height();	628	repaintTop = height();
		629	repaintBottom = height();
		630	}
628	RenderArena* arena = renderArena();	631	RenderArena* arena = renderArena();
629	RootInlineBox* box = startLine;	632	RootInlineBox* box = startLine;
630	while (box) {	633	while (box) {
Lines 659-664 void RenderBlock::layoutInlineChildren(b WebCore/rendering/RenderBlockLineLayout.cpp_sec5
659	bool checkForFloatsFromLastLine = false;	662	bool checkForFloatsFromLastLine = false;
660		663
661	bool isLineEmpty = true;	664	bool isLineEmpty = true;
		665	bool paginated = view()->layoutState()->paginated();
662		666
663	while (!end.atEnd()) {	667	while (!end.atEnd()) {
664	// FIXME: Is this check necessary before the first iteration or can it be moved to the end?	668	// FIXME: Is this check necessary before the first iteration or can it be moved to the end?
Lines 671-677 void RenderBlock::layoutInlineChildren(b WebCore/rendering/RenderBlockLineLayout.cpp_sec6
671		675
672	EClear clear = CNONE;	676	EClear clear = CNONE;
673	bool hyphenated;	677	bool hyphenated;
674	end = findNextLineBreak(resolver, firstLine, isLineEmpty, previousLineBrokeCleanly, hyphenated, &clear);	678
		679	InlineIterator oldEnd = end;
		680	FloatingObject* lastFloatFromPreviousLine = m_floatingObjects ? m_floatingObjects->last() : 0;
		681	end = findNextLineBreak(resolver, firstLine, isLineEmpty, previousLineBrokeCleanly, hyphenated, &clear, lastFloatFromPreviousLine);
675	if (resolver.position().atEnd()) {	682	if (resolver.position().atEnd()) {
676	resolver.deleteRuns();	683	resolver.deleteRuns();
677	checkForFloatsFromLastLine = true;	684	checkForFloatsFromLastLine = true;
Lines 736-741 void RenderBlock::layoutInlineChildren(b WebCore/rendering/RenderBlockLineLayout.cpp_sec7
736	// inline flow boxes.	743	// inline flow boxes.
737		744
738	RootInlineBox* lineBox = 0;	745	RootInlineBox* lineBox = 0;
		746	int oldHeight = height();
739	if (resolver.runCount()) {	747	if (resolver.runCount()) {
740	if (hyphenated)	748	if (hyphenated)
741	resolver.logicallyLastRun()->m_hasHyphen = true;	749	resolver.logicallyLastRun()->m_hasHyphen = true;
Lines 786-791 void RenderBlock::layoutInlineChildren(b WebCore/rendering/RenderBlockLineLayout.cpp_sec8
786	repaintTop = min(repaintTop, lineBox->topVisibleOverflow());	794	repaintTop = min(repaintTop, lineBox->topVisibleOverflow());
787	repaintBottom = max(repaintBottom, lineBox->bottomVisibleOverflow());	795	repaintBottom = max(repaintBottom, lineBox->bottomVisibleOverflow());
788	}	796	}
		797
		798	if (paginated) {
		799	int adjustment = 0;
		800	adjustLinePositionForPagination(lineBox, adjustment);
		801	if (adjustment) {
		802	int oldLineWidth = lineWidth(oldHeight, firstLine);
		803	lineBox->adjustPosition(0, adjustment);
		804	if (useRepaintBounds) // This can only be a positive adjustment, so no need to update repaintTop.
		805	repaintBottom = max(repaintBottom, lineBox->bottomVisibleOverflow());
		806
		807	if (lineWidth(oldHeight + adjustment, firstLine) != oldLineWidth) {
		808	// We have to delete this line, remove all floats that got added, and let line layout re-run.
		809	lineBox->deleteLine(renderArena());
		810	removeFloatingObjects(lastFloatFromPreviousLine, oldHeight);
		811	setHeight(oldHeight + adjustment);
		812	resolver.setPosition(oldEnd);
		813	end = oldEnd;
		814	continue;
		815	}
		816
		817	setHeight(lineBox->blockHeight());
		818	}
		819	}
789	}	820	}
790		821
791	firstLine = false;	822	firstLine = false;
Lines 820-825 void RenderBlock::layoutInlineChildren(b WebCore/rendering/RenderBlockLineLayout.cpp_sec9
820	int delta = height() - endLineYPos;	851	int delta = height() - endLineYPos;
821	for (RootInlineBox* line = endLine; line; line = line->nextRootBox()) {	852	for (RootInlineBox* line = endLine; line; line = line->nextRootBox()) {
822	line->attachLine();	853	line->attachLine();
		854	if (paginated) {
		855	delta -= line->paginationStrut();
		856	adjustLinePositionForPagination(line, delta);
		857	}
823	if (delta) {	858	if (delta) {
824	repaintTop = min(repaintTop, line->topVisibleOverflow() + min(delta, 0));	859	repaintTop = min(repaintTop, line->topVisibleOverflow() + min(delta, 0));
825	repaintBottom = max(repaintBottom, line->bottomVisibleOverflow() + max(delta, 0));	860	repaintBottom = max(repaintBottom, line->bottomVisibleOverflow() + max(delta, 0));
Lines 900-919 void RenderBlock::layoutInlineChildren(b WebCore/rendering/RenderBlockLineLayout.cpp_sec10
900	}	935	}
901		936
902	RootInlineBox* RenderBlock::determineStartPosition(bool& firstLine, bool& fullLayout, bool& previousLineBrokeCleanly,	937	RootInlineBox* RenderBlock::determineStartPosition(bool& firstLine, bool& fullLayout, bool& previousLineBrokeCleanly,
903	InlineBidiResolver& resolver, Vector<FloatWithRect>& floats, unsigned& numCleanFloats)	938	InlineBidiResolver& resolver, Vector<FloatWithRect>& floats, unsigned& numCleanFloats,
		939	bool& useRepaintBounds, int& repaintTop, int& repaintBottom)
904	{	940	{
905	RootInlineBox* curr = 0;	941	RootInlineBox* curr = 0;
906	RootInlineBox* last = 0;	942	RootInlineBox* last = 0;
907		943
908	bool dirtiedByFloat = false;	944	bool dirtiedByFloat = false;
909	if (!fullLayout) {	945	if (!fullLayout) {
		946	// Paginate all of the clean lines.
		947	bool paginated = view()->layoutState()->paginated();
		948	int paginationDelta = 0;
910	size_t floatIndex = 0;	949	size_t floatIndex = 0;
911	for (curr = firstRootBox(); curr && !curr->isDirty(); curr = curr->nextRootBox()) {	950	for (curr = firstRootBox(); curr && !curr->isDirty(); curr = curr->nextRootBox()) {
		951	if (paginated) {
		952	paginationDelta -= curr->paginationStrut();
		953	adjustLinePositionForPagination(curr, paginationDelta);
		954	if (paginationDelta) {
		955	if (containsFloats() \|\| !floats.isEmpty()) {
		956	// FIXME: Do better eventually. For now if we ever shift because of pagination and floats are present just go to a full layout.
		957	fullLayout = true;
		958	break;
		959	}
		960
		961	if (!useRepaintBounds)
		962	useRepaintBounds = true;
		963
		964	repaintTop = min(repaintTop, curr->topVisibleOverflow() + min(paginationDelta, 0));
		965	repaintBottom = max(repaintBottom, curr->bottomVisibleOverflow() + max(paginationDelta, 0));
		966	curr->adjustPosition(0, paginationDelta);
		967	}
		968	}
		969
912	if (Vector<RenderBox> cleanLineFloats = curr->floatsPtr()) {	970	if (Vector<RenderBox> cleanLineFloats = curr->floatsPtr()) {
913	Vector<RenderBox*>::iterator end = cleanLineFloats->end();	971	Vector<RenderBox*>::iterator end = cleanLineFloats->end();
914	for (Vector<RenderBox*>::iterator o = cleanLineFloats->begin(); o != end; ++o) {	972	for (Vector<RenderBox*>::iterator o = cleanLineFloats->begin(); o != end; ++o) {
915	RenderBox* f = *o;	973	RenderBox* f = *o;
916	IntSize newSize(f->width() + f->marginLeft() +f->marginRight(), f->height() + f->marginTop() + f->marginBottom());	974	f->layoutIfNeeded();
		975	IntSize newSize(f->width() + f->marginLeft() + f->marginRight(), f->height() + f->marginTop() + f->marginBottom());
917	ASSERT(floatIndex < floats.size());	976	ASSERT(floatIndex < floats.size());
918	if (floats[floatIndex].object != f) {	977	if (floats[floatIndex].object != f) {
919	// A new float has been inserted before this line or before its last known float.	978	// A new float has been inserted before this line or before its last known float.
Lines 1236-1249 void RenderBlock::skipTrailingWhitespace WebCore/rendering/RenderBlockLineLayout.cpp_sec11
1236	}	1295	}
1237	}	1296	}
1238		1297
1239	int RenderBlock::skipLeadingWhitespace(InlineBidiResolver& resolver, bool firstLine, bool isLineEmpty, bool previousLineBrokeCleanly)	1298	int RenderBlock::skipLeadingWhitespace(InlineBidiResolver& resolver, bool firstLine, bool isLineEmpty, bool previousLineBrokeCleanly,
		1299	FloatingObject* lastFloatFromPreviousLine)
1240	{	1300	{
1241	int availableWidth = lineWidth(height(), firstLine);	1301	int availableWidth = lineWidth(height(), firstLine);
1242	while (!resolver.position().atEnd() && !requiresLineBox(resolver.position(), isLineEmpty, previousLineBrokeCleanly)) {	1302	while (!resolver.position().atEnd() && !requiresLineBox(resolver.position(), isLineEmpty, previousLineBrokeCleanly)) {
1243	RenderObject* object = resolver.position().obj;	1303	RenderObject* object = resolver.position().obj;
1244	if (object->isFloating()) {	1304	if (object->isFloating()) {
1245	insertFloatingObject(toRenderBox(object));	1305	positionNewFloatOnLine(insertFloatingObject(toRenderBox(object)), lastFloatFromPreviousLine);
1246	positionNewFloats();
1247	availableWidth = lineWidth(height(), firstLine);	1306	availableWidth = lineWidth(height(), firstLine);
1248	} else if (object->isPositioned()) {	1307	} else if (object->isPositioned()) {
1249	// FIXME: The math here is actually not really right. It's a best-guess approximation that	1308	// FIXME: The math here is actually not really right. It's a best-guess approximation that
Lines 1349-1362 static void tryHyphenating(RenderText* t WebCore/rendering/RenderBlockLineLayout.cpp_sec12
1349	}	1408	}
1350		1409
1351	InlineIterator RenderBlock::findNextLineBreak(InlineBidiResolver& resolver, bool firstLine, bool& isLineEmpty, bool& previousLineBrokeCleanly,	1410	InlineIterator RenderBlock::findNextLineBreak(InlineBidiResolver& resolver, bool firstLine, bool& isLineEmpty, bool& previousLineBrokeCleanly,
1352	bool& hyphenated, EClear* clear)	1411	bool& hyphenated, EClear* clear, FloatingObject* lastFloatFromPreviousLine)
1353	{	1412	{
1354	ASSERT(resolver.position().block == this);	1413	ASSERT(resolver.position().block == this);
1355		1414
1356	bool appliedStartWidth = resolver.position().pos > 0;	1415	bool appliedStartWidth = resolver.position().pos > 0;
1357	LineMidpointState& lineMidpointState = resolver.midpointState();	1416	LineMidpointState& lineMidpointState = resolver.midpointState();
1358		1417
1359	int width = skipLeadingWhitespace(resolver, firstLine, isLineEmpty, previousLineBrokeCleanly);	1418	int width = skipLeadingWhitespace(resolver, firstLine, isLineEmpty, previousLineBrokeCleanly, lastFloatFromPreviousLine);
1360		1419
1361	int w = 0;	1420	int w = 0;
1362	int tmpW = 0;	1421	int tmpW = 0;
Lines 1441-1452 InlineIterator RenderBlock::findNextLine WebCore/rendering/RenderBlockLineLayout.cpp_sec13
1441	// add to special objects...	1500	// add to special objects...
1442	if (o->isFloating()) {	1501	if (o->isFloating()) {
1443	RenderBox* floatBox = toRenderBox(o);	1502	RenderBox* floatBox = toRenderBox(o);
1444	insertFloatingObject(floatBox);	1503	FloatingObject* f = insertFloatingObject(floatBox);
1445	// check if it fits in the current line.	1504	// check if it fits in the current line.
1446	// If it does, position it now, otherwise, position	1505	// If it does, position it now, otherwise, position
1447	// it after moving to next line (in newLine() func)	1506	// it after moving to next line (in newLine() func)
1448	if (floatsFitOnLine && floatBox->width() + floatBox->marginLeft() + floatBox->marginRight() + w + tmpW <= width) {	1507	if (floatsFitOnLine && floatBox->width() + floatBox->marginLeft() + floatBox->marginRight() + w + tmpW <= width) {
1449	positionNewFloats();	1508	positionNewFloatOnLine(f, lastFloatFromPreviousLine);
1450	width = lineWidth(height(), firstLine);	1509	width = lineWidth(height(), firstLine);
1451	} else	1510	} else
1452	floatsFitOnLine = false;	1511	floatsFitOnLine = false;

Lines 973-979 void RenderBox::mapLocalToContainer(Rend WebCore/rendering/RenderBox.cpp_sec1
- WebCore/rendering/RenderBox.cpp -2 / +2 lines
973	if (RenderView* v = view()) {	973	if (RenderView* v = view()) {
974	if (v->layoutStateEnabled() && !repaintContainer) {	974	if (v->layoutStateEnabled() && !repaintContainer) {
975	LayoutState* layoutState = v->layoutState();	975	LayoutState* layoutState = v->layoutState();
976	IntSize offset = layoutState->m_offset;	976	IntSize offset = layoutState->m_paintOffset;
977	offset.expand(x(), y());	977	offset.expand(x(), y());
978	if (style()->position() == RelativePosition && layer())	978	if (style()->position() == RelativePosition && layer())
979	offset += layer()->relativePositionOffset();	979	offset += layer()->relativePositionOffset();
Lines 1170-1176 void RenderBox::computeRectForRepaint(Re WebCore/rendering/RenderBox.cpp_sec2
1170	rect.move(layer()->relativePositionOffset());	1170	rect.move(layer()->relativePositionOffset());
1171		1171
1172	rect.move(x(), y());	1172	rect.move(x(), y());
1173	rect.move(layoutState->m_offset);	1173	rect.move(layoutState->m_paintOffset);
1174	if (layoutState->m_clipped)	1174	if (layoutState->m_clipped)
1175	rect.intersect(layoutState->m_clipRect);	1175	rect.intersect(layoutState->m_clipRect);
1176	return;	1176	return;

Lines 647-653 void RenderInline::computeRectForRepaint WebCore/rendering/RenderInline.cpp_sec1
- WebCore/rendering/RenderInline.cpp -2 / +2 lines
647	LayoutState* layoutState = v->layoutState();	647	LayoutState* layoutState = v->layoutState();
648	if (style()->position() == RelativePosition && layer())	648	if (style()->position() == RelativePosition && layer())
649	rect.move(layer()->relativePositionOffset());	649	rect.move(layer()->relativePositionOffset());
650	rect.move(layoutState->m_offset);	650	rect.move(layoutState->m_paintOffset);
651	if (layoutState->m_clipped)	651	if (layoutState->m_clipped)
652	rect.intersect(layoutState->m_clipRect);	652	rect.intersect(layoutState->m_clipRect);
653	return;	653	return;
Lines 734-740 void RenderInline::mapLocalToContainer(R WebCore/rendering/RenderInline.cpp_sec2
734	if (RenderView *v = view()) {	734	if (RenderView *v = view()) {
735	if (v->layoutStateEnabled() && !repaintContainer) {	735	if (v->layoutStateEnabled() && !repaintContainer) {
736	LayoutState* layoutState = v->layoutState();	736	LayoutState* layoutState = v->layoutState();
737	IntSize offset = layoutState->m_offset;	737	IntSize offset = layoutState->m_paintOffset;
738	if (style()->position() == RelativePosition && layer())	738	if (style()->position() == RelativePosition && layer())
739	offset += layer()->relativePositionOffset();	739	offset += layer()->relativePositionOffset();
740	transformState.move(offset);	740	transformState.move(offset);

Lines 2541-2551 void RenderLayer::paintChildLayerIntoCol WebCore/rendering/RenderLayer.cpp_sec1
- WebCore/rendering/RenderLayer.cpp -5 / +5 lines
2541	columnBlock->layer()->convertToLayerCoords(rootLayer, layerX, layerY);	2541	columnBlock->layer()->convertToLayerCoords(rootLayer, layerX, layerY);
2542		2542
2543	ColumnInfo* colInfo = columnBlock->columnInfo();	2543	ColumnInfo* colInfo = columnBlock->columnInfo();
2544	unsigned colCount = colInfo->columnCount();	2544	unsigned colCount = columnBlock->columnCount(colInfo);
2545	int currYOffset = 0;	2545	int currYOffset = 0;
2546	for (unsigned i = 0; i < colCount; i++) {	2546	for (unsigned i = 0; i < colCount; i++) {
2547	// For each rect, we clip to the rect, and then we adjust our coords.	2547	// For each rect, we clip to the rect, and then we adjust our coords.
2548	IntRect colRect = colInfo->columnRectAt(i);	2548	IntRect colRect = columnBlock->columnRectAt(colInfo, i);
2549	int currXOffset = colRect.x() - (columnBlock->borderLeft() + columnBlock->paddingLeft());	2549	int currXOffset = colRect.x() - (columnBlock->borderLeft() + columnBlock->paddingLeft());
2550	colRect.move(layerX, layerY);	2550	colRect.move(layerX, layerY);
2551		2551
Lines 3007-3023 RenderLayer* RenderLayer::hitTestChildLa WebCore/rendering/RenderLayer.cpp_sec2
3007	columnBlock->layer()->convertToLayerCoords(rootLayer, layerX, layerY);	3007	columnBlock->layer()->convertToLayerCoords(rootLayer, layerX, layerY);
3008		3008
3009	ColumnInfo* colInfo = columnBlock->columnInfo();	3009	ColumnInfo* colInfo = columnBlock->columnInfo();
3010	int colCount = colInfo->columnCount();	3010	int colCount = columnBlock->columnCount(colInfo);
3011		3011
3012	// We have to go backwards from the last column to the first.	3012	// We have to go backwards from the last column to the first.
3013	int left = columnBlock->borderLeft() + columnBlock->paddingLeft();	3013	int left = columnBlock->borderLeft() + columnBlock->paddingLeft();
3014	int currYOffset = 0;	3014	int currYOffset = 0;
3015	int i;	3015	int i;
3016	for (i = 0; i < colCount; i++)	3016	for (i = 0; i < colCount; i++)
3017	currYOffset -= colInfo->columnRectAt(i).height();	3017	currYOffset -= columnBlock->columnRectAt(colInfo, i).height();
3018	for (i = colCount - 1; i >= 0; i--) {	3018	for (i = colCount - 1; i >= 0; i--) {
3019	// For each rect, we clip to the rect, and then we adjust our coords.	3019	// For each rect, we clip to the rect, and then we adjust our coords.
3020	IntRect colRect = colInfo->columnRectAt(i);	3020	IntRect colRect = columnBlock->columnRectAt(colInfo, i);
3021	int currXOffset = colRect.x() - left;	3021	int currXOffset = colRect.x() - left;
3022	currYOffset += colRect.height();	3022	currYOffset += colRect.height();
3023	colRect.move(layerX, layerY);	3023	colRect.move(layerX, layerY);

Lines 83-94 public: WebCore/rendering/RenderView.h_sec1
- WebCore/rendering/RenderView.h -15 / +11 lines
83	IntRect printRect() const { return m_printRect; }	83	IntRect printRect() const { return m_printRect; }
84	void setPrintRect(const IntRect& r) { m_printRect = r; }	84	void setPrintRect(const IntRect& r) { m_printRect = r; }
85		85
86	void setTruncatedAt(int y) { m_truncatedAt = y; m_bestTruncatedAt = m_truncatorWidth = 0; m_minimumColumnHeight = 0; m_forcedPageBreak = false; }	86	void setTruncatedAt(int y) { m_truncatedAt = y; m_bestTruncatedAt = m_truncatorWidth = 0; m_forcedPageBreak = false; }
87	void setBestTruncatedAt(int y, RenderBoxModelObject* forRenderer, bool forcedBreak = false);	87	void setBestTruncatedAt(int y, RenderBoxModelObject* forRenderer, bool forcedBreak = false);
88	void setMinimumColumnHeight(int height) { m_minimumColumnHeight = height; }
89	int bestTruncatedAt() const { return m_bestTruncatedAt; }	88	int bestTruncatedAt() const { return m_bestTruncatedAt; }
90	int minimumColumnHeight() const { return m_minimumColumnHeight; }	89
91
92	int truncatedAt() const { return m_truncatedAt; }	90	int truncatedAt() const { return m_truncatedAt; }
93		91
94	virtual void absoluteRects(Vector<IntRect>&, int tx, int ty);	92	virtual void absoluteRects(Vector<IntRect>&, int tx, int ty);
Lines 122-142 public: WebCore/rendering/RenderView.h_sec2
122		120
123	bool doingFullRepaint() const { return m_frameView->needsFullRepaint(); }	121	bool doingFullRepaint() const { return m_frameView->needsFullRepaint(); }
124		122
125	void pushLayoutState(RenderBox* renderer, const IntSize& offset)	123	void pushLayoutState(RenderBox* renderer, const IntSize& offset, int pageHeight = 0, ColumnInfo* colInfo = 0)
126	{	124	{
127	if (doingFullRepaint())
128	return;
129	// We push LayoutState even if layoutState is disabled because it stores layoutDelta too.	125	// We push LayoutState even if layoutState is disabled because it stores layoutDelta too.
130	m_layoutState = new (renderArena()) LayoutState(m_layoutState, renderer, offset);	126	if (!doingFullRepaint() \|\| renderer->hasColumns() \|\| m_layoutState->paginated())
		127	m_layoutState = new (renderArena()) LayoutState(m_layoutState, renderer, offset, pageHeight, colInfo);
131	}	128	}
132		129
133	void pushLayoutState(RenderObject*);	130	void pushLayoutState(RenderObject*);
134		131
135	void popLayoutState()	132	void popLayoutState()
136	{	133	{
137	if (doingFullRepaint())
138	return;
139	LayoutState* state = m_layoutState;	134	LayoutState* state = m_layoutState;
		135	if (doingFullRepaint() && !m_layoutState->paginated())
		136	return;
140	m_layoutState = state->m_next;	137	m_layoutState = state->m_next;
141	state->destroy(renderArena());	138	state->destroy(renderArena());
142	}	139	}
Lines 198-204 protected: WebCore/rendering/RenderView.h_sec3
198	private:	195	private:
199	int m_bestTruncatedAt;	196	int m_bestTruncatedAt;
200	int m_truncatorWidth;	197	int m_truncatorWidth;
201	int m_minimumColumnHeight;
202	bool m_forcedPageBreak;	198	bool m_forcedPageBreak;
203	LayoutState* m_layoutState;	199	LayoutState* m_layoutState;
204	unsigned m_layoutStateDisableCount;	200	unsigned m_layoutStateDisableCount;
Lines 227-239 void toRenderView(const RenderView*); WebCore/rendering/RenderView.h_sec4
227	class LayoutStateMaintainer : public Noncopyable {	223	class LayoutStateMaintainer : public Noncopyable {
228	public:	224	public:
229	// ctor to push now	225	// ctor to push now
230	LayoutStateMaintainer(RenderView* view, RenderBox* root, IntSize offset, bool disableState = false)	226	LayoutStateMaintainer(RenderView* view, RenderBox* root, IntSize offset, bool disableState = false, int pageHeight = 0, ColumnInfo* colInfo = 0)
231	: m_view(view)	227	: m_view(view)
232	, m_disabled(disableState)	228	, m_disabled(disableState)
233	, m_didStart(false)	229	, m_didStart(false)
234	, m_didEnd(false)	230	, m_didEnd(false)
235	{	231	{
236	push(root, offset);	232	push(root, offset, pageHeight, colInfo);
237	}	233	}
238		234
239	// ctor to maybe push later	235	// ctor to maybe push later
Lines 250-260 public: WebCore/rendering/RenderView.h_sec5
250	ASSERT(m_didStart == m_didEnd); // if this fires, it means that someone did a push(), but forgot to pop().	246	ASSERT(m_didStart == m_didEnd); // if this fires, it means that someone did a push(), but forgot to pop().
251	}	247	}
252		248
253	void push(RenderBox* root, IntSize offset)	249	void push(RenderBox* root, IntSize offset, int pageHeight = 0, ColumnInfo* colInfo = 0)
254	{	250	{
255	ASSERT(!m_didStart);	251	ASSERT(!m_didStart);
256	// We push state even if disabled, because we still need to store layoutDelta	252	// We push state even if disabled, because we still need to store layoutDelta
257	m_view->pushLayoutState(root, offset);	253	m_view->pushLayoutState(root, offset, pageHeight, colInfo);
258	if (m_disabled)	254	if (m_disabled)
259	m_view->disableLayoutState();	255	m_view->disableLayoutState();
260	m_didStart = true;	256	m_didStart = true;

Lines 36-41 public: WebCore/rendering/ColumnInfo.h_sec1
- WebCore/rendering/ColumnInfo.h -8 / +20 lines
36	ColumnInfo()	36	ColumnInfo()
37	: m_desiredColumnWidth(0)	37	: m_desiredColumnWidth(0)
38	, m_desiredColumnCount(1)	38	, m_desiredColumnCount(1)
		39	, m_columnCount(1)
		40	, m_columnHeight(0)
		41	, m_minimumColumnHeight(0)
39	{ }	42	{ }
40		43
41	int desiredColumnWidth() const { return m_desiredColumnWidth; }	44	int desiredColumnWidth() const { return m_desiredColumnWidth; }
Lines 44-62 public: WebCore/rendering/ColumnInfo.h_sec2
44	unsigned desiredColumnCount() const { return m_desiredColumnCount; }	47	unsigned desiredColumnCount() const { return m_desiredColumnCount; }
45	void setDesiredColumnCount(unsigned count) { m_desiredColumnCount = count; }	48	void setDesiredColumnCount(unsigned count) { m_desiredColumnCount = count; }
46		49
47	// Encapsulated for the future where we can avoid storing the rects and just compute them dynamically.	50	unsigned columnCount() const { return m_columnCount; }
48	size_t columnCount() const { return m_columnRects.size(); }	51	int columnHeight() const { return m_columnHeight; }
49	const IntRect& columnRectAt(size_t i) const { return m_columnRects[i]; }
50		52
51	void clearColumns() { m_columnRects.clear(); }	53	// Set our count and height. This is enough info for a RenderBlock to compute page rects
		54	// dynamically.
		55	void setColumnCountAndHeight(int c, int h)
		56	{
		57	m_columnCount = c;
		58	m_columnHeight = h;
		59	}
		60	void setColumnHeight(int h) { m_columnHeight = h; }
		61
		62	void updateMinimumColumnHeight(int h) { m_minimumColumnHeight = max(h, m_minimumColumnHeight); }
		63	int minimumColumnHeight() const { return m_minimumColumnHeight; }
52		64
53	// FIXME: Will go away once we don't use the Vector.
54	void addColumnRect(const IntRect& rect) { m_columnRects.append(rect); }
55
56	private:	65	private:
57	int m_desiredColumnWidth;	66	int m_desiredColumnWidth;
58	unsigned m_desiredColumnCount;	67	unsigned m_desiredColumnCount;
59	Vector<IntRect> m_columnRects;	68
		69	unsigned m_columnCount;
		70	int m_columnHeight;
		71	int m_minimumColumnHeight;
60	};	72	};
61		73
62	}	74	}

Lines 33-40 WebCore/rendering/LayoutState.cpp_sec1
- WebCore/rendering/LayoutState.cpp -15 / +55 lines
33		33
34	namespace WebCore {	34	namespace WebCore {
35		35
36	LayoutState::LayoutState(LayoutState* prev, RenderBox* renderer, const IntSize& offset)	36	LayoutState::LayoutState(LayoutState* prev, RenderBox* renderer, const IntSize& offset, int pageHeight, ColumnInfo* colInfo)
37	: m_next(prev)	37	: m_columnInfo(colInfo)
		38	, m_next(prev)
38	#ifndef NDEBUG	39	#ifndef NDEBUG
39	, m_renderer(renderer)	40	, m_renderer(renderer)
40	#endif	41	#endif
Lines 45-87 LayoutState::LayoutState(LayoutState* pr WebCore/rendering/LayoutState.cpp_sec2
45	if (fixed) {	46	if (fixed) {
46	// FIXME: This doesn't work correctly with transforms.	47	// FIXME: This doesn't work correctly with transforms.
47	FloatPoint fixedOffset = renderer->view()->localToAbsolute(FloatPoint(), true);	48	FloatPoint fixedOffset = renderer->view()->localToAbsolute(FloatPoint(), true);
48	m_offset = IntSize(fixedOffset.x(), fixedOffset.y()) + offset;	49	m_paintOffset = IntSize(fixedOffset.x(), fixedOffset.y()) + offset;
49	} else	50	} else
50	m_offset = prev->m_offset + offset;	51	m_paintOffset = prev->m_paintOffset + offset;
51		52
52	if (renderer->isRelPositioned()) {	53	if (renderer->isPositioned() && !fixed) {
53	if (renderer->hasLayer())
54	m_offset += renderer->layer()->relativePositionOffset();
55	} else if (renderer->isPositioned() && !fixed) {
56	if (RenderObject* container = renderer->container()) {	54	if (RenderObject* container = renderer->container()) {
57	if (container->isRelPositioned() && container->isRenderInline())	55	if (container->isRelPositioned() && container->isRenderInline())
58	m_offset += toRenderInline(container)->relativePositionedInlineOffset(renderer);	56	m_paintOffset += toRenderInline(container)->relativePositionedInlineOffset(renderer);
59	}	57	}
60	}	58	}
61		59
		60	m_layoutOffset = m_paintOffset;
		61
		62	if (renderer->isRelPositioned() && renderer->hasLayer())
		63	m_paintOffset += renderer->layer()->relativePositionOffset();
		64
62	m_clipped = !fixed && prev->m_clipped;	65	m_clipped = !fixed && prev->m_clipped;
63	if (m_clipped)	66	if (m_clipped)
64	m_clipRect = prev->m_clipRect;	67	m_clipRect = prev->m_clipRect;
65		68
66	if (renderer->hasOverflowClip()) {	69	if (renderer->hasOverflowClip()) {
67	RenderLayer* layer = renderer->layer();	70	RenderLayer* layer = renderer->layer();
68	IntRect clipRect(toPoint(m_offset) + renderer->view()->layoutDelta(), layer->size());	71	IntRect clipRect(toPoint(m_paintOffset) + renderer->view()->layoutDelta(), layer->size());
69	if (m_clipped)	72	if (m_clipped)
70	m_clipRect.intersect(clipRect);	73	m_clipRect.intersect(clipRect);
71	else {	74	else {
72	m_clipRect = clipRect;	75	m_clipRect = clipRect;
73	m_clipped = true;	76	m_clipped = true;
74	}	77	}
75	m_offset -= layer->scrolledContentOffset();	78
		79	m_paintOffset -= layer->scrolledContentOffset();
76	}	80	}
77		81
78	m_layoutDelta = m_next->m_layoutDelta;	82	// Disable pagination for objects we don't support. For now this includes overflow:scroll/auto and inline blocks.
		83	if (renderer->isReplaced() \|\| renderer->scrollsOverflow())
		84	m_pageHeight = 0;
		85
		86	// If we establish a new page height, then cache the offset to the top of the first page.
		87	// We can compare this later on to figure out what part of the page we're actually on,
		88	if (pageHeight) {
		89	m_pageHeight = pageHeight;
		90	m_pageOffset = IntSize(m_paintOffset.width() + renderer->borderLeft() + renderer->paddingLeft(),
		91	m_paintOffset.height() + renderer->borderTop() + renderer->paddingTop());
		92	} else {
		93	// If we don't establish a new page height, then propagate the old page height and offset down.
		94	m_pageHeight = m_next->m_pageHeight;
		95	m_pageOffset = m_next->m_pageOffset;
		96	}
		97
		98	if (!m_columnInfo)
		99	m_columnInfo = m_next->m_columnInfo;
79		100
		101	m_layoutDelta = m_next->m_layoutDelta;
		102
80	// FIXME: <http://bugs.webkit.org/show_bug.cgi?id=13443> Apply control clip if present.	103	// FIXME: <http://bugs.webkit.org/show_bug.cgi?id=13443> Apply control clip if present.
81	}	104	}
82		105
83	LayoutState::LayoutState(RenderObject* root)	106	LayoutState::LayoutState(RenderObject* root)
84	: m_clipped(false)	107	: m_clipped(false)
		108	, m_pageHeight(0)
		109	, m_columnInfo(0)
85	, m_next(0)	110	, m_next(0)
86	#ifndef NDEBUG	111	#ifndef NDEBUG
87	, m_renderer(root)	112	, m_renderer(root)
Lines 89-101 LayoutState::LayoutState(RenderObject* r WebCore/rendering/LayoutState.cpp_sec3
89	{	114	{
90	RenderObject* container = root->container();	115	RenderObject* container = root->container();
91	FloatPoint absContentPoint = container->localToAbsolute(FloatPoint(), false, true);	116	FloatPoint absContentPoint = container->localToAbsolute(FloatPoint(), false, true);
92	m_offset = IntSize(absContentPoint.x(), absContentPoint.y());	117	m_paintOffset = IntSize(absContentPoint.x(), absContentPoint.y());
93		118
94	if (container->hasOverflowClip()) {	119	if (container->hasOverflowClip()) {
95	RenderLayer* layer = toRenderBoxModelObject(container)->layer();	120	RenderLayer* layer = toRenderBoxModelObject(container)->layer();
96	m_clipped = true;	121	m_clipped = true;
97	m_clipRect = IntRect(toPoint(m_offset), layer->size());	122	m_clipRect = IntRect(toPoint(m_paintOffset), layer->size());
98	m_offset -= layer->scrolledContentOffset();	123	m_paintOffset -= layer->scrolledContentOffset();
99	}	124	}
100	}	125	}
101		126
Lines 126-129 void LayoutState::operator delete(void* WebCore/rendering/LayoutState.cpp_sec4
126	(size_t)ptr = sz;	151	(size_t)ptr = sz;
127	}	152	}
128		153
		154	void LayoutState::clearPaginationInformation()
		155	{
		156	m_pageHeight = m_next->m_pageHeight;
		157	m_pageOffset = m_next->m_pageOffset;
		158	m_columnInfo = m_next->m_columnInfo;
		159	}
		160
		161	int LayoutState::pageY(int childY) const
		162	{
		163	ASSERT(m_pageHeight);
		164	int layoutY = m_layoutOffset.height() + childY;
		165	int pageY = m_pageOffset.height();
		166	return layoutY - pageY;
		167	}
		168
129	} // namespace WebCore	169	} // namespace WebCore

Lines 34-39 namespace WebCore { WebCore/rendering/RenderBlock.h_sec1
- WebCore/rendering/RenderBlock.h -53 / +83 lines
34		34
35	class ColumnInfo;	35	class ColumnInfo;
36	class InlineIterator;	36	class InlineIterator;
		37	class LayoutStateMaintainer;
37	class RenderInline;	38	class RenderInline;
38		39
39	struct BidiRun;	40	struct BidiRun;
Lines 70-76 public: WebCore/rendering/RenderBlock.h_sec2
70	virtual void addChild(RenderObject* newChild, RenderObject* beforeChild = 0);	71	virtual void addChild(RenderObject* newChild, RenderObject* beforeChild = 0);
71	virtual void removeChild(RenderObject*);	72	virtual void removeChild(RenderObject*);
72		73
73	virtual void layoutBlock(bool relayoutChildren);	74	virtual void layoutBlock(bool relayoutChildren, int pageHeight = 0);
74		75
75	void insertPositionedObject(RenderBox*);	76	void insertPositionedObject(RenderBox*);
76	void removePositionedObject(RenderBox*);	77	void removePositionedObject(RenderBox*);
Lines 89-94 public: WebCore/rendering/RenderBlock.h_sec3
89		90
90	void markAllDescendantsWithFloatsForLayout(RenderBox* floatToRemove = 0, bool inLayout = true);	91	void markAllDescendantsWithFloatsForLayout(RenderBox* floatToRemove = 0, bool inLayout = true);
91	void markPositionedObjectsForLayout();	92	void markPositionedObjectsForLayout();
		93	void markDescendantBlocksAndLinesForLayout(bool inLayout = true);
92		94
93	bool containsFloats() { return m_floatingObjects && !m_floatingObjects->isEmpty(); }	95	bool containsFloats() { return m_floatingObjects && !m_floatingObjects->isEmpty(); }
94	bool containsFloat(RenderObject*);	96	bool containsFloat(RenderObject*);
Lines 151-156 public: WebCore/rendering/RenderBlock.h_sec4
151		153
152	ColumnInfo* columnInfo() const;	154	ColumnInfo* columnInfo() const;
153	int columnGap() const;	155	int columnGap() const;
		156
		157	// These two functions take the ColumnInfo* to avoid repeated lookups of the info in the global HashMap.
		158	unsigned columnCount(ColumnInfo*) const;
		159	IntRect columnRectAt(ColumnInfo*, unsigned) const;
154		160
155	protected:	161	protected:
156	// These functions are only used internally to manipulate the render tree structure via remove/insert/appendChildNode.	162	// These functions are only used internally to manipulate the render tree structure via remove/insert/appendChildNode.
Lines 177-196 protected: WebCore/rendering/RenderBlock.h_sec5
177	}	183	}
178	void moveChildrenTo(RenderBlock* to, RenderObject* startChild, RenderObject* endChild, RenderObject* beforeChild, bool fullRemoveInsert = false);	184	void moveChildrenTo(RenderBlock* to, RenderObject* startChild, RenderObject* endChild, RenderObject* beforeChild, bool fullRemoveInsert = false);
179		185
180	int maxTopPosMargin() const { return m_maxMargin ? m_maxMargin->m_topPos : MaxMargin::topPosDefault(this); }	186	int maxTopPosMargin() const { return m_rareData ? m_rareData->m_topPos : RenderBlockRareData::topPosDefault(this); }
181	int maxTopNegMargin() const { return m_maxMargin ? m_maxMargin->m_topNeg : MaxMargin::topNegDefault(this); }	187	int maxTopNegMargin() const { return m_rareData ? m_rareData->m_topNeg : RenderBlockRareData::topNegDefault(this); }
182	int maxBottomPosMargin() const { return m_maxMargin ? m_maxMargin->m_bottomPos : MaxMargin::bottomPosDefault(this); }	188	int maxBottomPosMargin() const { return m_rareData ? m_rareData->m_bottomPos : RenderBlockRareData::bottomPosDefault(this); }
183	int maxBottomNegMargin() const { return m_maxMargin ? m_maxMargin->m_bottomNeg : MaxMargin::bottomNegDefault(this); }	189	int maxBottomNegMargin() const { return m_rareData ? m_rareData->m_bottomNeg : RenderBlockRareData::bottomNegDefault(this); }
		190	int paginationStrut() const { return m_rareData ? m_rareData->m_paginationStrut : 0; }
		191	int pageY() const { return m_rareData ? m_rareData->m_pageY : 0; }
184	void setMaxTopMargins(int pos, int neg);	192	void setMaxTopMargins(int pos, int neg);
185	void setMaxBottomMargins(int pos, int neg);	193	void setMaxBottomMargins(int pos, int neg);
186		194	void setPaginationStrut(int strut);
		195	void setPageY(int y);
		196
187	void initMaxMarginValues()	197	void initMaxMarginValues()
188	{	198	{
189	if (m_maxMargin) {	199	if (m_rareData) {
190	m_maxMargin->m_topPos = MaxMargin::topPosDefault(this);	200	m_rareData->m_topPos = RenderBlockRareData::topPosDefault(this);
191	m_maxMargin->m_topNeg = MaxMargin::topNegDefault(this);	201	m_rareData->m_topNeg = RenderBlockRareData::topNegDefault(this);
192	m_maxMargin->m_bottomPos = MaxMargin::bottomPosDefault(this);	202	m_rareData->m_bottomPos = RenderBlockRareData::bottomPosDefault(this);
193	m_maxMargin->m_bottomNeg = MaxMargin::bottomNegDefault(this);	203	m_rareData->m_bottomNeg = RenderBlockRareData::bottomNegDefault(this);
		204	m_rareData->m_paginationStrut = 0;
194	}	205	}
195	}	206	}
196		207
Lines 295-303 private: WebCore/rendering/RenderBlock.h_sec6
295	bool everHadLayout;	306	bool everHadLayout;
296	};	307	};
297		308
		309	struct FloatingObject : Noncopyable {
		310	enum Type {
		311	FloatLeft,
		312	FloatRight
		313	};
		314
		315	FloatingObject(Type type)
		316	: m_renderer(0)
		317	, m_top(0)
		318	, m_bottom(0)
		319	, m_left(0)
		320	, m_width(0)
		321	, m_paginationStrut(0)
		322	, m_type(type)
		323	, m_shouldPaint(true)
		324	, m_isDescendant(false)
		325	{
		326	}
		327
		328	Type type() { return static_cast<Type>(m_type); }
		329
		330	RenderBox* m_renderer;
		331	int m_top;
		332	int m_bottom;
		333	int m_left;
		334	int m_width;
		335	int m_paginationStrut;
		336	unsigned m_type : 1; // Type (left or right aligned)
		337	bool m_shouldPaint : 1;
		338	bool m_isDescendant : 1;
		339	};
		340
298	// The following functions' implementations are in RenderBlockLineLayout.cpp.	341	// The following functions' implementations are in RenderBlockLineLayout.cpp.
299	RootInlineBox* determineStartPosition(bool& firstLine, bool& fullLayout, bool& previousLineBrokeCleanly,	342	RootInlineBox* determineStartPosition(bool& firstLine, bool& fullLayout, bool& previousLineBrokeCleanly,
300	InlineBidiResolver&, Vector<FloatWithRect>& floats, unsigned& numCleanFloats);	343	InlineBidiResolver&, Vector<FloatWithRect>& floats, unsigned& numCleanFloats,
		344	bool& useRepaintBounds, int& repaintTop, int& repaintBottom);
301	RootInlineBox* determineEndPosition(RootInlineBox* startBox, InlineIterator& cleanLineStart,	345	RootInlineBox* determineEndPosition(RootInlineBox* startBox, InlineIterator& cleanLineStart,
302	BidiStatus& cleanLineBidiStatus,	346	BidiStatus& cleanLineBidiStatus,
303	int& yPos);	347	int& yPos);
Lines 305-313 private: WebCore/rendering/RenderBlock.h_sec7
305	RootInlineBox*& endLine, int& endYPos, int& repaintBottom, int& repaintTop);	349	RootInlineBox*& endLine, int& endYPos, int& repaintBottom, int& repaintTop);
306		350
307	void skipTrailingWhitespace(InlineIterator&, bool isLineEmpty, bool previousLineBrokeCleanly);	351	void skipTrailingWhitespace(InlineIterator&, bool isLineEmpty, bool previousLineBrokeCleanly);
308	int skipLeadingWhitespace(InlineBidiResolver&, bool firstLine, bool isLineEmpty, bool previousLineBrokeCleanly);	352	int skipLeadingWhitespace(InlineBidiResolver&, bool firstLine, bool isLineEmpty, bool previousLineBrokeCleanly, FloatingObject* lastFloatFromPreviousLine);
309	void fitBelowFloats(int widthToFit, bool firstLine, int& availableWidth);	353	void fitBelowFloats(int widthToFit, bool firstLine, int& availableWidth);
310	InlineIterator findNextLineBreak(InlineBidiResolver&, bool firstLine, bool& isLineEmpty, bool& previousLineBrokeCleanly, bool& hyphenated, EClear* = 0);	354	InlineIterator findNextLineBreak(InlineBidiResolver&, bool firstLine, bool& isLineEmpty, bool& previousLineBrokeCleanly, bool& hyphenated, EClear, FloatingObject lastFloatFromPreviousLine);
311	RootInlineBox* constructLine(unsigned runCount, BidiRun* firstRun, BidiRun* lastRun, bool firstLine, bool lastLine, RenderObject* endObject);	355	RootInlineBox* constructLine(unsigned runCount, BidiRun* firstRun, BidiRun* lastRun, bool firstLine, bool lastLine, RenderObject* endObject);
312	InlineFlowBox* createLineBoxes(RenderObject*, bool firstLine);	356	InlineFlowBox* createLineBoxes(RenderObject*, bool firstLine);
313	void computeHorizontalPositionsForLine(RootInlineBox, bool firstLine, BidiRun firstRun, BidiRun* trailingSpaceRun, bool reachedEnd, GlyphOverflowAndFallbackFontsMap&);	357	void computeHorizontalPositionsForLine(RootInlineBox, bool firstLine, BidiRun firstRun, BidiRun* trailingSpaceRun, bool reachedEnd, GlyphOverflowAndFallbackFontsMap&);
Lines 329-340 private: WebCore/rendering/RenderBlock.h_sec8
329	void paintSelection(PaintInfo&, int tx, int ty);	373	void paintSelection(PaintInfo&, int tx, int ty);
330	void paintCaret(PaintInfo&, int tx, int ty, CaretType);	374	void paintCaret(PaintInfo&, int tx, int ty, CaretType);
331		375
332	void insertFloatingObject(RenderBox*);	376	FloatingObject* insertFloatingObject(RenderBox*);
333	void removeFloatingObject(RenderBox*);	377	void removeFloatingObject(RenderBox*);
334		378	void removeFloatingObjects(FloatingObject*, int y);
		379
335	// Called from lineWidth, to position the floats added in the last line.	380	// Called from lineWidth, to position the floats added in the last line.
336	// Returns ture if and only if it has positioned any floats.	381	// Returns true if and only if it has positioned any floats.
337	bool positionNewFloats();	382	bool positionNewFloats();
		383
		384	// Positions new floats and also adjust all floats encountered on the line if any of them
		385	// have to move to the next page/column.
		386	bool positionNewFloatOnLine(FloatingObject* newFloat, FloatingObject* lastFloatFromPreviousLine);
		387
338	void clearFloats();	388	void clearFloats();
339	int getClearDelta(RenderBox* child, int yPos);	389	int getClearDelta(RenderBox* child, int yPos);
340		390
Lines 416-423 private: WebCore/rendering/RenderBlock.h_sec9
416	void offsetForContents(int& tx, int& ty) const;	466	void offsetForContents(int& tx, int& ty) const;
417		467
418	void calcColumnWidth();	468	void calcColumnWidth();
419	int layoutColumns(int endOfContent = -1, int requestedColumnHeight = -1);	469	bool layoutColumns(bool hasSpecifiedPageHeight, int pageHeight, LayoutStateMaintainer&);
420	int visibleTopOfHighestFloatExtendingBelow(int bottom, int maxHeight) const;
421	void makeChildrenAnonymousColumnBlocks(RenderObject* beforeChild, RenderBlock* newBlockBox, RenderObject* newChild);	470	void makeChildrenAnonymousColumnBlocks(RenderObject* beforeChild, RenderBlock* newBlockBox, RenderObject* newChild);
422		471
423	bool expandsToEncloseOverhangingFloats() const;	472	bool expandsToEncloseOverhangingFloats() const;
Lines 433-468 private: WebCore/rendering/RenderBlock.h_sec10
433	RenderBlock* continuationBefore(RenderObject* beforeChild);	482	RenderBlock* continuationBefore(RenderObject* beforeChild);
434	RenderBlock* containingColumnsBlock(bool allowAnonymousColumnBlock = true);	483	RenderBlock* containingColumnsBlock(bool allowAnonymousColumnBlock = true);
435	RenderBlock* columnsBlockForSpanningElement(RenderObject* newChild);	484	RenderBlock* columnsBlockForSpanningElement(RenderObject* newChild);
436
437	struct FloatingObject : Noncopyable {
438	enum Type {
439	FloatLeft,
440	FloatRight
441	};
442
443	FloatingObject(Type type)
444	: m_renderer(0)
445	, m_top(0)
446	, m_bottom(0)
447	, m_left(0)
448	, m_width(0)
449	, m_type(type)
450	, m_shouldPaint(true)
451	, m_isDescendant(false)
452	{
453	}
454
455	Type type() { return static_cast<Type>(m_type); }
456
457	RenderBox* m_renderer;
458	int m_top;
459	int m_bottom;
460	int m_left;
461	int m_width;
462	unsigned m_type : 1; // Type (left or right aligned)
463	bool m_shouldPaint : 1;
464	bool m_isDescendant : 1;
465	};
466		485
467	class MarginInfo {	486	class MarginInfo {
468	// Collapsing flags for whether we can collapse our margins with our children's margins.	487	// Collapsing flags for whether we can collapse our margins with our children's margins.
Lines 539-544 private: WebCore/rendering/RenderBlock.h_sec11
539	void setCollapsedBottomMargin(const MarginInfo&);	558	void setCollapsedBottomMargin(const MarginInfo&);
540	// End helper functions and structs used by layoutBlockChildren.	559	// End helper functions and structs used by layoutBlockChildren.
541		560
		561	// Pagination routines.
		562	int nextPageTop(int yPos) const; // Returns the top of the next page following yPos.
		563	int applyBeforeBreak(RenderBox* child, int yPos); // If the child has a before break, then return a new yPos that shifts to the top of the next page/column.
		564	int applyAfterBreak(RenderBox* child, int yPos, MarginInfo& marginInfo); // If the child has an after break, then return a new yPos that shifts to the top of the next page/column.
		565	int adjustForUnsplittableChild(RenderBox* child, int yPos, bool includeMargins = false); // If the child is unsplittable and can't fit on the current page, return the top of the next page/column.
		566	void adjustLinePositionForPagination(RootInlineBox*, int& deltaY); // Computes a deltaY value that put a line at the top of the next page if it doesn't fit on the current page.
		567
542	typedef PositionedObjectsListHashSet::const_iterator Iterator;	568	typedef PositionedObjectsListHashSet::const_iterator Iterator;
543	DeprecatedPtrList<FloatingObject>* m_floatingObjects;	569	DeprecatedPtrList<FloatingObject>* m_floatingObjects;
544		570
Lines 551-562 private: WebCore/rendering/RenderBlock.h_sec12
551	RenderBoxModelObject* m_continuation;	577	RenderBoxModelObject* m_continuation;
552		578
553	// Allocated only when some of these fields have non-default values	579	// Allocated only when some of these fields have non-default values
554	struct MaxMargin : Noncopyable {	580	struct RenderBlockRareData : Noncopyable {
555	MaxMargin(const RenderBlock* o)	581	RenderBlockRareData(const RenderBlock* o)
556	: m_topPos(topPosDefault(o))	582	: m_topPos(topPosDefault(o))
557	, m_topNeg(topNegDefault(o))	583	, m_topNeg(topNegDefault(o))
558	, m_bottomPos(bottomPosDefault(o))	584	, m_bottomPos(bottomPosDefault(o))
559	, m_bottomNeg(bottomNegDefault(o))	585	, m_bottomNeg(bottomNegDefault(o))
		586	, m_paginationStrut(0)
		587	, m_pageY(0)
560	{	588	{
561	}	589	}
562		590
Lines 564-577 private: WebCore/rendering/RenderBlock.h_sec13
564	static int topNegDefault(const RenderBlock* o) { return o->marginTop() < 0 ? -o->marginTop() : 0; }	592	static int topNegDefault(const RenderBlock* o) { return o->marginTop() < 0 ? -o->marginTop() : 0; }
565	static int bottomPosDefault(const RenderBlock* o) { return o->marginBottom() > 0 ? o->marginBottom() : 0; }	593	static int bottomPosDefault(const RenderBlock* o) { return o->marginBottom() > 0 ? o->marginBottom() : 0; }
566	static int bottomNegDefault(const RenderBlock* o) { return o->marginBottom() < 0 ? -o->marginBottom() : 0; }	594	static int bottomNegDefault(const RenderBlock* o) { return o->marginBottom() < 0 ? -o->marginBottom() : 0; }
567		595
568	int m_topPos;	596	int m_topPos;
569	int m_topNeg;	597	int m_topNeg;
570	int m_bottomPos;	598	int m_bottomPos;
571	int m_bottomNeg;	599	int m_bottomNeg;
		600	int m_paginationStrut;
		601	int m_pageY;
572	};	602	};
573		603
574	MaxMargin* m_maxMargin;	604	RenderBlockRareData* m_rareData;
575		605
576	RenderObjectChildList m_children;	606	RenderObjectChildList m_children;
577	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>.	607	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>.

Lines 35-41 WebCore/rendering/RenderLineBoxList.cpp_sec1
- WebCore/rendering/RenderLineBoxList.cpp -3 / +1 lines
35	#include "RenderInline.h"	35	#include "RenderInline.h"
36	#include "RenderView.h"	36	#include "RenderView.h"
37	#include "RootInlineBox.h"	37	#include "RootInlineBox.h"
38	#include "Settings.h" // FIXME: This include can be removed when paginateDuringLayoutEnabled is taken out.
39		38
40	using namespace std;	39	using namespace std;
41		40
Lines 161-167 void RenderLineBoxList::paint(RenderBoxM WebCore/rendering/RenderLineBoxList.cpp_sec2
161	return;	160	return;
162		161
163	RenderView* v = renderer->view();	162	RenderView* v = renderer->view();
164	bool usePrintRect = !v->printRect().isEmpty() && !renderer->document()->settings()->paginateDuringLayoutEnabled();	163	bool usePrintRect = !v->printRect().isEmpty();
165		164
166	// We can check the first box and last box and avoid painting if we don't	165	// We can check the first box and last box and avoid painting if we don't
167	// intersect. This is a quick short-circuit that we can take to avoid walking any lines.	166	// intersect. This is a quick short-circuit that we can take to avoid walking any lines.
Lines 215-221 void RenderLineBoxList::paint(RenderBoxM WebCore/rendering/RenderLineBoxList.cpp_sec3
215	int bottom = curr->bottomVisibleOverflow() + renderer->maximalOutlineSize(info.phase);	214	int bottom = curr->bottomVisibleOverflow() + renderer->maximalOutlineSize(info.phase);
216	h = bottom - top;	215	h = bottom - top;
217	yPos = ty + top;	216	yPos = ty + top;
218	v->setMinimumColumnHeight(h);
219	if (yPos < info.rect.bottom() && yPos + h > info.rect.y())	217	if (yPos < info.rect.bottom() && yPos + h > info.rect.y())
220	curr->paint(info, tx, ty);	218	curr->paint(info, tx, ty);
221	}	219	}

Lines 52-58 RenderView::RenderView(Node* node, Frame WebCore/rendering/RenderView.cpp_sec1
- WebCore/rendering/RenderView.cpp -2 lines
52	, m_maximalOutlineSize(0)	52	, m_maximalOutlineSize(0)
53	, m_bestTruncatedAt(0)	53	, m_bestTruncatedAt(0)
54	, m_truncatorWidth(0)	54	, m_truncatorWidth(0)
55	, m_minimumColumnHeight(0)
56	, m_forcedPageBreak(false)	55	, m_forcedPageBreak(false)
57	, m_layoutState(0)	56	, m_layoutState(0)
58	, m_layoutStateDisableCount(0)	57	, m_layoutStateDisableCount(0)
Lines 695-701 void RenderView::setBestTruncatedAt(int WebCore/rendering/RenderView.cpp_sec2
695		694
696	void RenderView::pushLayoutState(RenderObject* root)	695	void RenderView::pushLayoutState(RenderObject* root)
697	{	696	{
698	ASSERT(!doingFullRepaint());
699	ASSERT(m_layoutStateDisableCount == 0);	697	ASSERT(m_layoutStateDisableCount == 0);
700	ASSERT(m_layoutState == 0);	698	ASSERT(m_layoutState == 0);
701		699