Attachment #48394 for bug #13430

View Details Raw Unified Return to Bug 13430

| Differences between

and this patch

Lines 4548-4553 WebCore/WebCore.xcodeproj/project.pbxproj_sec1
- WebCore/WebCore.xcodeproj/project.pbxproj +12 lines
4548	BCE65BEA0EACDF16007E4533 /* Length.cpp in Sources / = {isa = PBXBuildFile; fileRef = BCE65BE80EACDF16007E4533 / Length.cpp */; };	4548	BCE65BEA0EACDF16007E4533 /* Length.cpp in Sources / = {isa = PBXBuildFile; fileRef = BCE65BE80EACDF16007E4533 / Length.cpp */; };
4549	BCE65BEB0EACDF16007E4533 /* Length.h in Headers / = {isa = PBXBuildFile; fileRef = BCE65BE90EACDF16007E4533 / Length.h */; settings = {ATTRIBUTES = (Private, ); }; };	4549	BCE65BEB0EACDF16007E4533 /* Length.h in Headers / = {isa = PBXBuildFile; fileRef = BCE65BE90EACDF16007E4533 / Length.h */; settings = {ATTRIBUTES = (Private, ); }; };
4550	BCE65D320EAD1211007E4533 /* Theme.cpp in Sources / = {isa = PBXBuildFile; fileRef = BCE65D310EAD1211007E4533 / Theme.cpp */; };	4550	BCE65D320EAD1211007E4533 /* Theme.cpp in Sources / = {isa = PBXBuildFile; fileRef = BCE65D310EAD1211007E4533 / Theme.cpp */; };
		4551	BCE789161120D6080060ECE5 /* InlineIterator.h in Headers / = {isa = PBXBuildFile; fileRef = BCE789151120D6080060ECE5 / InlineIterator.h */; };
		4552	BCE789861120E7A60060ECE5 /* BidiRun.h in Headers / = {isa = PBXBuildFile; fileRef = BCE789851120E7A60060ECE5 / BidiRun.h */; };
		4553	BCE7898B1120E8020060ECE5 /* BidiRun.cpp in Sources / = {isa = PBXBuildFile; fileRef = BCE7898A1120E8020060ECE5 / BidiRun.cpp */; };
4551	BCE7B1930D4E86960075A539 /* JSHistoryCustom.cpp in Sources / = {isa = PBXBuildFile; fileRef = BCE7B1920D4E86960075A539 / JSHistoryCustom.cpp */; };	4554	BCE7B1930D4E86960075A539 /* JSHistoryCustom.cpp in Sources / = {isa = PBXBuildFile; fileRef = BCE7B1920D4E86960075A539 / JSHistoryCustom.cpp */; };
4552	BCE99EC30DCA624100182683 /* JSXSLTProcessorConstructor.cpp in Sources / = {isa = PBXBuildFile; fileRef = BCE99EC10DCA624100182683 / JSXSLTProcessorConstructor.cpp */; };	4555	BCE99EC30DCA624100182683 /* JSXSLTProcessorConstructor.cpp in Sources / = {isa = PBXBuildFile; fileRef = BCE99EC10DCA624100182683 / JSXSLTProcessorConstructor.cpp */; };
4553	BCE99EC40DCA624100182683 /* JSXSLTProcessorConstructor.h in Headers / = {isa = PBXBuildFile; fileRef = BCE99EC20DCA624100182683 / JSXSLTProcessorConstructor.h */; };	4556	BCE99EC40DCA624100182683 /* JSXSLTProcessorConstructor.h in Headers / = {isa = PBXBuildFile; fileRef = BCE99EC20DCA624100182683 / JSXSLTProcessorConstructor.h */; };
Lines 9810-9815 WebCore/WebCore.xcodeproj/project.pbxproj_sec2
9810	BCE65BE80EACDF16007E4533 /* Length.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Length.cpp; sourceTree = "<group>"; };	9813	BCE65BE80EACDF16007E4533 /* Length.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Length.cpp; sourceTree = "<group>"; };
9811	BCE65BE90EACDF16007E4533 /* Length.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Length.h; sourceTree = "<group>"; };	9814	BCE65BE90EACDF16007E4533 /* Length.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Length.h; sourceTree = "<group>"; };
9812	BCE65D310EAD1211007E4533 /* Theme.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Theme.cpp; sourceTree = "<group>"; };	9815	BCE65D310EAD1211007E4533 /* Theme.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Theme.cpp; sourceTree = "<group>"; };
		9816	BCE789151120D6080060ECE5 /* InlineIterator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InlineIterator.h; sourceTree = "<group>"; };
		9817	BCE789851120E7A60060ECE5 /* BidiRun.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = BidiRun.h; sourceTree = "<group>"; };
		9818	BCE7898A1120E8020060ECE5 /* BidiRun.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = BidiRun.cpp; sourceTree = "<group>"; };
9813	BCE7B1920D4E86960075A539 /* JSHistoryCustom.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSHistoryCustom.cpp; sourceTree = "<group>"; };	9819	BCE7B1920D4E86960075A539 /* JSHistoryCustom.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSHistoryCustom.cpp; sourceTree = "<group>"; };
9814	BCE99EC10DCA624100182683 /* JSXSLTProcessorConstructor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSXSLTProcessorConstructor.cpp; sourceTree = "<group>"; };	9820	BCE99EC10DCA624100182683 /* JSXSLTProcessorConstructor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSXSLTProcessorConstructor.cpp; sourceTree = "<group>"; };
9815	BCE99EC20DCA624100182683 /* JSXSLTProcessorConstructor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSXSLTProcessorConstructor.h; sourceTree = "<group>"; };	9821	BCE99EC20DCA624100182683 /* JSXSLTProcessorConstructor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSXSLTProcessorConstructor.h; sourceTree = "<group>"; };
Lines 15556-15561 WebCore/WebCore.xcodeproj/project.pbxproj_sec3
15556	BC8C8FAA0DDCD2F200B592F4 /* style */,	15562	BC8C8FAA0DDCD2F200B592F4 /* style */,
15557	A8CFF04B0A154F09000A4234 /* AutoTableLayout.cpp */,	15563	A8CFF04B0A154F09000A4234 /* AutoTableLayout.cpp */,
15558	A8CFF0490A154F09000A4234 /* AutoTableLayout.h */,	15564	A8CFF0490A154F09000A4234 /* AutoTableLayout.h */,
		15565	BCE7898A1120E8020060ECE5 /* BidiRun.cpp */,
		15566	BCE789851120E7A60060ECE5 /* BidiRun.h */,
15559	BCEA4815097D93020094C9E4 /* break_lines.cpp */,	15567	BCEA4815097D93020094C9E4 /* break_lines.cpp */,
15560	BCEA4816097D93020094C9E4 /* break_lines.h */,	15568	BCEA4816097D93020094C9E4 /* break_lines.h */,
15561	9392F14F0AD1862300691BD4 /* CounterNode.cpp */,	15569	9392F14F0AD1862300691BD4 /* CounterNode.cpp */,
Lines 15572-15577 WebCore/WebCore.xcodeproj/project.pbxproj_sec4
15572	A8CFF5DE0A155A05000A4234 /* InlineBox.h */,	15580	A8CFF5DE0A155A05000A4234 /* InlineBox.h */,
15573	A8CFF5DD0A155A05000A4234 /* InlineFlowBox.cpp */,	15581	A8CFF5DD0A155A05000A4234 /* InlineFlowBox.cpp */,
15574	A8CFF5DC0A155A05000A4234 /* InlineFlowBox.h */,	15582	A8CFF5DC0A155A05000A4234 /* InlineFlowBox.h */,
		15583	BCE789151120D6080060ECE5 /* InlineIterator.h */,
15575	A8CFF5DB0A155A05000A4234 /* InlineRunBox.h */,	15584	A8CFF5DB0A155A05000A4234 /* InlineRunBox.h */,
15576	BCEA481A097D93020094C9E4 /* InlineTextBox.cpp */,	15585	BCEA481A097D93020094C9E4 /* InlineTextBox.cpp */,
15577	BCEA481B097D93020094C9E4 /* InlineTextBox.h */,	15586	BCEA481B097D93020094C9E4 /* InlineTextBox.h */,
Lines 18505-18510 WebCore/WebCore.xcodeproj/project.pbxproj_sec5
18505	B71FE6DF11091CB300DAEF77 /* PrintContext.h in Headers */,	18514	B71FE6DF11091CB300DAEF77 /* PrintContext.h in Headers */,
18506	9F72304F11184B4100AD0126 /* ScriptProfile.h in Headers */,	18515	9F72304F11184B4100AD0126 /* ScriptProfile.h in Headers */,
18507	9F72305111184B4100AD0126 /* ScriptProfiler.h in Headers */,	18516	9F72305111184B4100AD0126 /* ScriptProfiler.h in Headers */,
		18517	BCE789161120D6080060ECE5 /* InlineIterator.h in Headers */,
		18518	BCE789861120E7A60060ECE5 /* BidiRun.h in Headers */,
18508	);	18519	);
18509	runOnlyForDeploymentPostprocessing = 0;	18520	runOnlyForDeploymentPostprocessing = 0;
18510	};	18521	};
Lines 20683-20688 WebCore/WebCore.xcodeproj/project.pbxproj_sec6
20683	84D0C4041115F1D40018AA34 /* AffineTransform.cpp in Sources */,	20694	84D0C4041115F1D40018AA34 /* AffineTransform.cpp in Sources */,
20684	B776D43D1104527500BEB0EC /* PrintContext.cpp in Sources */,	20695	B776D43D1104527500BEB0EC /* PrintContext.cpp in Sources */,
20685	9F72305011184B4100AD0126 /* ScriptProfiler.cpp in Sources */,	20696	9F72305011184B4100AD0126 /* ScriptProfiler.cpp in Sources */,
		20697	BCE7898B1120E8020060ECE5 /* BidiRun.cpp in Sources */,
20686	);	20698	);
20687	runOnlyForDeploymentPostprocessing = 0;	20699	runOnlyForDeploymentPostprocessing = 0;
20688	};	20700	};



    RenderObject* currRenderer;
    
    // Search up the render tree for a RenderObject with a DOM node.  Defer to an earlier continuation, though.
    for (currRenderer = m_renderer; currRenderer && !currRenderer->node(); currRenderer = currRenderer->parent())
    {
            RenderInline* continuation = toRenderBlock(currRenderer)->inlineContinuation();
            if (continuation)
                return cache->getOrCreate(continuation)->anchorElement();
        }
    }
    
    // bail if none found



/**
 * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
 *           (C) 1999 Antti Koivisto (koivisto@kde.org)
 * Copyright (C) 2003, 2004, 2005, 2006, 2010 Apple Inc. All rights reserved.
 * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public License
 * along with this library; see the file COPYING.LIB.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 *
 */

#include "config.h"
#include "BidiRun.h"
#include "InlineBox.h"
#include "RenderArena.h"
#include <wtf/RefCountedLeakCounter.h>

using namespace WTF;

namespace WebCore {

#ifndef NDEBUG
static RefCountedLeakCounter bidiRunCounter("BidiRun");

static bool inBidiRunDestroy;
#endif

void BidiRun::destroy()
{
#ifndef NDEBUG
    inBidiRunDestroy = true;
#endif
    RenderArena* renderArena = m_object->renderArena();
    delete this;
#ifndef NDEBUG
    inBidiRunDestroy = false;
#endif

    // Recover the size left there for us by operator delete and free the memory.
    renderArena->free(*reinterpret_cast<size_t*>(this), this);
}

void* BidiRun::operator new(size_t sz, RenderArena* renderArena) throw()
{
#ifndef NDEBUG
    bidiRunCounter.increment();
#endif
    return renderArena->allocate(sz);
}

void BidiRun::operator delete(void* ptr, size_t sz)
{
#ifndef NDEBUG
    bidiRunCounter.decrement();
#endif
    ASSERT(inBidiRunDestroy);

    // Stash size where destroy() can find it.
    *(size_t*)ptr = sz;
}

}



/**
 * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
 *           (C) 1999 Antti Koivisto (koivisto@kde.org)
 * Copyright (C) 2003, 2004, 2005, 2006, 2010 Apple Inc. All rights reserved.
 * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public License
 * along with this library; see the file COPYING.LIB.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 *
 */

#ifndef BidiRun_h
#define BidiRun_h

#include <wtf/StdLibExtras.h>
#include "BidiResolver.h"
#include "RenderText.h"

namespace WebCore {

class BidiContext;
class InlineBox;

struct BidiRun : BidiCharacterRun {
    BidiRun(int start, int stop, RenderObject* object, BidiContext* context, WTF::Unicode::Direction dir)
        : BidiCharacterRun(start, stop, context, dir)
        , m_object(object)
        , m_box(0)
    {
    }

    void destroy();

    // Overloaded new operator.
    void* operator new(size_t, RenderArena*) throw();

    // Overridden to prevent the normal delete from being called.
    void operator delete(void*, size_t);

    BidiRun* next() { return static_cast<BidiRun*>(m_next); }

private:
    // The normal operator new is disallowed.
    void* operator new(size_t) throw();

public:
    RenderObject* m_object;
    InlineBox* m_box;
};

}

#endif // BidiRun_h




#include "RenderLayer.h"
#include "RenderListMarker.h"
#include "RenderTableCell.h"
#include "RenderView.h"
#include "RootInlineBox.h"
#include "Text.h"


        // (3) The line may end on the inline.  If we are the last child (climbing up
        // the end object's chain), then we just closed as well.
        if (!lineBoxList->lastLineBox()->isConstructed()) {
            RenderInline* inlineFlow = toRenderInline(renderer());
            if (ltr) {
                if (!nextLineBox() &&
                    (lastLine || nextOnLineExists() || onEndChain(endObject)))
                    includeRightEdge = true;
            } else {
                if ((!prevLineBox() || prevLineBox()->isConstructed()) &&
                    (lastLine || prevOnLineExists() || onEndChain(endObject)))
                    includeLeftEdge = true;
            }
        }

                newY -= curr->boxModelObject()->borderTop() + curr->boxModelObject()->paddingTop();
        } else if (!curr->renderer()->isBR()) {
            RenderBox* box = toRenderBox(curr->renderer());
            newY += curr->renderer()->isAnonymousInlineBlock() ? 0 : box->marginTop();
        }

        curr->setY(newY);

            // outlines.
            if (renderer()->style()->visibility() == VISIBLE && renderer()->hasOutline() && !isRootInlineBox()) {
                RenderInline* inlineFlow = toRenderInline(renderer());
                paintInfo.outlineObjects->add(inlineFlow);
                    // Add ourselves to the containing block of the entire continuation so that it can
                    // paint us atomically.
                    RenderBlock* block = renderer()->containingBlock()->containingBlock();
                    block->addContinuationWithOutline(toRenderInline(renderer()->node()->renderer()));
                } else if (!inlineFlow->isInlineContinuation())
                    paintInfo.outlineObjects->add(inlineFlow);
            }
        } else if (paintInfo.phase == PaintPhaseMask) {
            paintMask(paintInfo, tx, ty);



/*
 * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
 * Copyright (C) 2003, 2004, 2006, 2007, 2008, 2009, 2010 Apple Inc. All right reserved.
 * Copyright (C) 2010 Google Inc. All rights reserved.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public License
 * along with this library; see the file COPYING.LIB.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 *
 */

#ifndef InlineIterator_h
#define InlineIterator_h

#include "BidiRun.h"
#include "RenderBlock.h"
#include "RenderText.h"
#include <wtf/AlwaysInline.h>
#include <wtf/StdLibExtras.h>

namespace WebCore {

class InlineIterator {
public:
    InlineIterator()
        : block(0)
        , obj(0)
        , pos(0)
        , nextBreakablePosition(-1)
    {
    }

    InlineIterator(RenderBlock* b, RenderObject* o, unsigned p)
        : block(b)
        , obj(o)
        , pos(p)
        , nextBreakablePosition(-1)
    {
    }

    void increment(InlineBidiResolver* resolver = 0);
    bool atEnd() const;

    UChar current() const;
    WTF::Unicode::Direction direction() const;

    RenderBlock* block;
    RenderObject* obj;
    unsigned pos;
    int nextBreakablePosition;
};

inline bool operator==(const InlineIterator& it1, const InlineIterator& it2)
{
    return it1.pos == it2.pos && it1.obj == it2.obj;
}

inline bool operator!=(const InlineIterator& it1, const InlineIterator& it2)
{
    return it1.pos != it2.pos || it1.obj != it2.obj;
}

static inline RenderObject* bidiNext(RenderBlock* block, RenderObject* current, InlineBidiResolver* resolver = 0, bool skipInlines = true, bool* endOfInlinePtr = 0)
{
    RenderObject* next = 0;
    bool oldEndOfInline = endOfInlinePtr ? *endOfInlinePtr : false;
    bool endOfInline = false;

    while (current) {
        next = 0;
        if (!oldEndOfInline && !current->isFloating() && !current->isReplaced() && !current->isPositioned() && !current->isText()) {
            next = current->firstChild();
            if (next && resolver && next->isRenderInline()) {
                EUnicodeBidi ub = next->style()->unicodeBidi();
                if (ub != UBNormal) {
                    TextDirection dir = next->style()->direction();
                    WTF::Unicode::Direction d = (ub == Embed
                        ? (dir == RTL ? WTF::Unicode::RightToLeftEmbedding : WTF::Unicode::LeftToRightEmbedding)
                        : (dir == RTL ? WTF::Unicode::RightToLeftOverride : WTF::Unicode::LeftToRightOverride));
                    resolver->embed(d);
                }
            }
        }

        if (!next) {
            if (!skipInlines && !oldEndOfInline && current->isRenderInline()) {
                next = current;
                endOfInline = true;
                break;
            }

            while (current && current != block) {
                if (resolver && current->isRenderInline() && current->style()->unicodeBidi() != UBNormal)
                    resolver->embed(WTF::Unicode::PopDirectionalFormat);

                next = current->nextSibling();
                if (next) {
                    if (resolver && next->isRenderInline()) {
                        EUnicodeBidi ub = next->style()->unicodeBidi();
                        if (ub != UBNormal) {
                            TextDirection dir = next->style()->direction();
                            WTF::Unicode::Direction d = (ub == Embed
                                ? (dir == RTL ? WTF::Unicode::RightToLeftEmbedding: WTF::Unicode::LeftToRightEmbedding)
                                : (dir == RTL ? WTF::Unicode::RightToLeftOverride : WTF::Unicode::LeftToRightOverride));
                            resolver->embed(d);
                        }
                    }
                    break;
                }
                
                current = current->parent();
                if (!skipInlines && current && current != block && current->isRenderInline()) {
                    next = current;
                    endOfInline = true;
                    break;
                }
            }
        }

        if (!next)
            break;

        if (next->isText() || next->isFloating() || next->isReplaced() || next->isPositioned()
            || ((!skipInlines || !next->firstChild()) // Always return EMPTY inlines.
                && next->isRenderInline()))
            break;
        current = next;
    }

    if (endOfInlinePtr)
        *endOfInlinePtr = endOfInline;

    return next;
}

static inline RenderObject* bidiFirst(RenderBlock* block, InlineBidiResolver* resolver, bool skipInlines = true)
{
    if (!block->firstChild())
        return 0;
    
    RenderObject* o = block->firstChild();
    if (o->isRenderInline()) {
        if (resolver) {
            EUnicodeBidi ub = o->style()->unicodeBidi();
            if (ub != UBNormal) {
                TextDirection dir = o->style()->direction();
                WTF::Unicode::Direction d = (ub == Embed
                    ? (dir == RTL ? WTF::Unicode::RightToLeftEmbedding : WTF::Unicode::LeftToRightEmbedding)
                    : (dir == RTL ? WTF::Unicode::RightToLeftOverride : WTF::Unicode::LeftToRightOverride));
                resolver->embed(d);
            }
        }
        if (skipInlines && o->firstChild())
            o = bidiNext(block, o, resolver, skipInlines);
        else {
            // Never skip empty inlines.
            if (resolver)
                resolver->commitExplicitEmbedding();
            return o; 
        }
    }

    if (o && !o->isText() && !o->isReplaced() && !o->isFloating() && !o->isPositioned())
        o = bidiNext(block, o, resolver, skipInlines);

    if (resolver)
        resolver->commitExplicitEmbedding();
    return o;
}

inline void InlineIterator::increment(InlineBidiResolver* resolver)
{
    if (!obj)
        return;
    if (obj->isText()) {
        pos++;
        if (pos >= toRenderText(obj)->textLength()) {
            obj = bidiNext(block, obj, resolver);
            pos = 0;
            nextBreakablePosition = -1;
        }
    } else {
        obj = bidiNext(block, obj, resolver);
        pos = 0;
        nextBreakablePosition = -1;
    }
}

inline bool InlineIterator::atEnd() const
{
    return !obj;
}

inline UChar InlineIterator::current() const
{
    if (!obj || !obj->isText())
        return 0;

    RenderText* text = toRenderText(obj);
    if (pos >= text->textLength())
        return 0;

    return text->characters()[pos];
}

ALWAYS_INLINE WTF::Unicode::Direction InlineIterator::direction() const
{
    if (UChar c = current())
        return WTF::Unicode::direction(c);

    if (obj && obj->isListMarker())
        return obj->style()->direction() == LTR ? WTF::Unicode::LeftToRight : WTF::Unicode::RightToLeft;

    return WTF::Unicode::OtherNeutral;
}

template<>
inline void InlineBidiResolver::increment()
{
    current.increment(this);
}

template <>
inline void InlineBidiResolver::appendRun()
{
    if (!emptyRun && !eor.atEnd()) {
        int start = sor.pos;
        RenderObject *obj = sor.obj;
        while (obj && obj != eor.obj && obj != endOfLine.obj) {
            RenderBlock::appendRunsForObject(start, obj->length(), obj, *this);        
            start = 0;
            obj = bidiNext(sor.block, obj);
        }
        if (obj) {
            unsigned pos = obj == eor.obj ? eor.pos : UINT_MAX;
            if (obj == endOfLine.obj && endOfLine.pos <= pos) {
                reachedEndOfLine = true;
                pos = endOfLine.pos;
            }
            // It's OK to add runs for zero-length RenderObjects, just don't make the run larger than it should be
            int end = obj->length() ? pos+1 : 0;
            RenderBlock::appendRunsForObject(start, end, obj, *this);
        }
        
        eor.increment();
        sor = eor;
    }

    m_direction = WTF::Unicode::OtherNeutral;
    m_status.eor = WTF::Unicode::OtherNeutral;
}

}

#endif // InlineIterator_h





typedef WTF::HashMap<const RenderBox*, HashSet<RenderBlock*>*> PercentHeightContainerMap;
static PercentHeightContainerMap* gPercentHeightContainerMap = 0;
    
typedef WTF::HashMap<RenderBlock*, ListHashSet<RenderInline*>*> ContinuationOutlineTableMap;

typedef WTF::HashSet<RenderBlock*> DelayedUpdateScrollInfoSet;
static int gDelayUpdateScrollInfo = 0;

    // if we had any border/padding (obviously), if we're the root or HTML elements, or if
    // we're positioned, floating, a table cell.
    m_canCollapseWithChildren = !block->isRenderView() && !block->isRoot() && !block->isPositioned() &&
        !block->isFloating() && !block->isTableCell() && !block->hasOverflowClip() && (!block->isInlineBlockOrInlineTable() || block->isAnonymousInlineBlock());

    m_canCollapseTopWithChildren = m_canCollapseWithChildren && (top == 0) && block->style()->marginTopCollapse() != MSEPARATE;


      : RenderBox(node)
      , m_floatingObjects(0)
      , m_positionedObjects(0)
      , m_inlineContinuation(0)
      , m_maxMargin(0)
      , m_lineHeight(-1)
{

    // Make sure to destroy anonymous children first while they are still connected to the rest of the tree, so that they will
    // properly dirty line boxes that they are removed from. Effects that do :before/:after only on hover could crash otherwise.
    children()->destroyLeftoverChildren();

    // Destroy our continuation before anything other than anonymous children.
    // The reason we don't destroy it before anonymous children is that they may
    // have continuations of their own that are anonymous children of our continuation.
    if (m_inlineContinuation) {
        m_inlineContinuation->destroy();
        m_inlineContinuation = 0;
    }
    
    if (!documentBeingDestroyed()) {
        if (firstLineBox()) {

        }
    } else if (!childrenInline() && (newChild->isFloatingOrPositioned() || newChild->isInline())) {
        // If we're inserting an inline child but all of our children are blocks, then we have to make sure
        // it is put into an anonymous block box. We try to use an existing anonymous box if possible, otherwise
        // a new one is created and inserted into our list of children in the appropriate position.
        RenderObject* afterChild = beforeChild ? beforeChild->previousSibling() : lastChild();


    ASSERT(child->isAnonymousBlock());
    ASSERT(!child->childrenInline());
    
    if (child->inlineContinuation()) 
        return;
    
    RenderObject* firstAnChild = child->m_children.firstChild();
    RenderObject* lastAnChild = child->m_children.lastChild();
    if (firstAnChild) {

    RenderObject* prev = oldChild->previousSibling();
    RenderObject* next = oldChild->nextSibling();
    bool canDeleteAnonymousBlocks = !documentBeingDestroyed() && !isInline() && !oldChild->isInline() && 
                                    !oldChild->isRenderBlock() && 
                                    (!prev || (prev->isAnonymousBlock() && prev->childrenInline())) &&
                                    (!next || (next->isAnonymousBlock() && next->childrenInline()));
    if (canDeleteAnonymousBlocks && prev && next) {

    // on whether we have content that is all self-collapsing or not.
    if (hasAutoHeight || ((style()->height().isFixed() || style()->height().isPercent()) && style()->height().isZero())) {
        // If the block has inline children, see if we generated any line boxes.  If we have any
        // line boxes, then we can only be self-collapsing if we have nothing but anonymous inline blocks
        // that are also self-collapsing inside us.
        if (childrenInline()) {
            for (RootInlineBox* child = firstRootBox(); child; child = child->nextRootBox()) {
                if (!child->anonymousInlineBlock() || !child->anonymousInlineBlock()->isSelfCollapsingBlock())
                    return false;
            }
            return true; // We have no line boxes, so we must be self-collapsing.
        }
        
        // Whether or not we collapse is dependent on whether all our normal flow children
        // are also self-collapsing.


bool RenderBlock::expandsToEncloseOverhangingFloats() const
{
    return isFloatingOrPositioned() || hasOverflowClip() || (parent() && parent()->isFlexibleBox()) || hasColumns() || isTableCell() || isFieldset() ||
           (isInlineBlockOrInlineTable() && !isAnonymousInlineBlock());
}

void RenderBlock::adjustPositionedBlock(RenderBox* child, const MarginInfo& marginInfo)

int RenderBlock::collapseMargins(RenderBox* child, MarginInfo& marginInfo)
{
    // Get our max pos and neg top margins.
    int posTop = child ? child->maxTopMargin(true) : 0;
    int negTop = child ? child->maxTopMargin(false) : 0;

    // For self-collapsing blocks, collapse our bottom margins into our
    // top to get new posTop and negTop values.
    if (child && child->isSelfCollapsingBlock()) {
        posTop = max(posTop, child->maxBottomMargin(true));
        negTop = max(negTop, child->maxBottomMargin(false));
    }
    
    // See if the top margin is quirky. We only care if this child has
    // margins that will collapse with us.
    bool topQuirk = (child && child->isTopMarginQuirk()) || style()->marginTopCollapse() == MDISCARD;

    if (marginInfo.canCollapseWithTop()) {
        // This child is collapsing with the top of the

        // collapse it away, even if the margin is smaller (www.webreference.com
        // has an example of this, a <dt> with 0.8em author-specified inside
        // a <dl> inside a <td>.
        if (!marginInfo.determinedTopQuirk() && !topQuirk && (posTop - negTop)) {
            setTopMarginQuirk(false);
            marginInfo.setDeterminedTopQuirk(true);
        }

        marginInfo.setTopQuirk(topQuirk);

    int ypos = height();
    if (child && child->isSelfCollapsingBlock()) {
        // This child has no height.  We need to compute our
        // position before we collapse the child's margins together,
        // so that we can get an accurate position for the zero-height block.

            // that needs to be positioned correctly (e.g., a block that
            // had a specified height of 0 but that actually had subcontent).
            ypos = height() + collapsedTopPos - collapsedTopNeg;
    } else {
        if (child && child->style()->marginTopCollapse() == MSEPARATE) {
        if (child->style()->marginTopCollapse() == MSEPARATE) {
            setHeight(height() + marginInfo.margin() + child->marginTop());
            ypos = height();
        } else if (!marginInfo.atTopOfBlock() ||
        else if (!marginInfo.atTopOfBlock() ||
            (!marginInfo.canCollapseTopWithChildren()
             && (!style()->htmlHacks() || !marginInfo.quirkContainer() || !marginInfo.topQuirk()))) {
            // We're collapsing with a previous sibling's margins and not

            ypos = height();
        }

        marginInfo.setPosMargin(child ? child->maxBottomMargin(true) : 0);
        marginInfo.setNegMargin(child ? child->maxBottomMargin(false) : 0);

        if (marginInfo.margin())
            marginInfo.setBottomQuirk((child && child->isBottomMarginQuirk()) || style()->marginBottomCollapse() == MDISCARD);
    }
    
    return ypos;

    if ((paintPhase == PaintPhaseOutline || paintPhase == PaintPhaseSelfOutline) && hasOutline() && style()->visibility() == VISIBLE)
        paintOutline(paintInfo.context, tx, ty, width(), height(), style());

    // 6. paint caret.
    if ((paintPhase == PaintPhaseOutline || paintPhase == PaintPhaseChildOutlines)) {
        if (inlineContinuation() && inlineContinuation()->hasOutline() && inlineContinuation()->style()->visibility() == VISIBLE) {
            RenderInline* inlineRenderer = toRenderInline(inlineContinuation()->node()->renderer());
            if (!inlineRenderer->hasSelfPaintingLayer())
                containingBlock()->addContinuationWithOutline(inlineRenderer);
            else if (!inlineRenderer->firstLineBox())
                inlineRenderer->paintOutline(paintInfo.context, tx - x() + inlineRenderer->containingBlock()->x(),
                                             ty - y() + inlineRenderer->containingBlock()->y());
        }
        paintContinuationOutlines(paintInfo, tx, ty);
    }

    // 7. paint caret.
    // If the caret's node's render object's containing block is this block, and the paint action is PaintPhaseForeground,
    // then paint the caret.
    if (paintPhase == PaintPhaseForeground) {        

    }
}

static ContinuationOutlineTableMap* continuationOutlineTable()
{
    DEFINE_STATIC_LOCAL(ContinuationOutlineTableMap, table, ());
    return &table;
}

void RenderBlock::addContinuationWithOutline(RenderInline* flow)
{
    // We can't make this work if the inline is in a layer.  We'll just rely on the broken
    // way of painting.
    ASSERT(!flow->layer() && !flow->isInlineContinuation());
    
    ContinuationOutlineTableMap* table = continuationOutlineTable();
    ListHashSet<RenderInline*>* continuations = table->get(this);
    if (!continuations) {
        continuations = new ListHashSet<RenderInline*>;
        table->set(this, continuations);
    }
    
    continuations->add(flow);
}

void RenderBlock::paintContinuationOutlines(PaintInfo& info, int tx, int ty)
{
    ContinuationOutlineTableMap* table = continuationOutlineTable();
    if (table->isEmpty())
        return;
        
    ListHashSet<RenderInline*>* continuations = table->get(this);
    if (!continuations)
        return;
        
    // Paint each continuation outline.
    ListHashSet<RenderInline*>::iterator end = continuations->end();
    for (ListHashSet<RenderInline*>::iterator it = continuations->begin(); it != end; ++it) {
        // Need to add in the coordinates of the intervening blocks.
        RenderInline* flow = *it;
        RenderBlock* block = flow->containingBlock();
        for ( ; block && block != this; block = block->containingBlock()) {
            tx += block->x();
            ty += block->y();
        }
        ASSERT(block);   
        flow->paintOutline(info.context, tx, ty);
    }
    
    // Delete
    delete continuations;
    table->remove(this);
}

void RenderBlock::setSelectionState(SelectionState s)
{
    if (selectionState() == s)

    // out of flow (like floating/positioned elements), and we also skip over any objects that may have shifted
    // to avoid floats.
    bool parentHasFloats = false;
    RenderObject* prev = 0;
    RenderBlock* parentBlock = 0;
    if (isAnonymousInlineBlock()) {
        parentBlock = containingBlock();
        parentHasFloats = parentBlock->containsFloats();
    } else {    
        while (prev && (prev->isFloatingOrPositioned() || !prev->isBox() || !prev->isRenderBlock() || toRenderBlock(prev)->avoidsFloats())) {
            if (prev->isFloating())
                parentHasFloats = true;
            prev = prev->previousSibling();
        }
        
        parentBlock = parent()->isRenderBlock() ? toRenderBlock(parent()) : 0;
    }

    // First add in floats from the parent.
    int offset = y();
    if (parentHasFloats)
        RenderBlock* parentBlock = toRenderBlock(parent());
        addIntrudingFloats(parentBlock, parentBlock->borderLeft() + parentBlock->paddingLeft(), offset);

    
    int xoffset = 0;
    if (prev)
        offset -= toRenderBox(prev)->y();
    else if (parentBlock) {
        prev = parentBlock;
        xoffset += toRenderBox(prev)->borderLeft() + toRenderBox(prev)->paddingLeft();
    }


                // above.  |xoff| will equal -flow->marginLeft() in this case, so it's already been taken
                // into account.  Only apply this code if |child| is false, since otherwise the left margin
                // will get applied twice.
                if (prev != containingBlock())
                    floatingObj->m_left += prev->marginLeft();
                floatingObj->m_left -= marginLeft();
                floatingObj->m_shouldPaint = false;  // We are not in the direct inheritance chain for this float. We will never paint it.

        removeFloatingObject(floatToRemove);

    // Iterate over our children and mark them as needed.
    if (childrenInline()) {
        for (RootInlineBox* box = firstRootBox(); box; box = box->nextRootBox()) {
            RenderBlock* childBlock = box->anonymousInlineBlock();
            if (childBlock && (floatToRemove ? childBlock->containsFloat(floatToRemove) : childBlock->containsFloats()))
                childBlock->markAllDescendantsWithFloatsForLayout(floatToRemove, inLayout);
        }
    } else {
        for (RenderObject* child = firstChild(); child; child = child->nextSibling()) {
            if ((!floatToRemove && child->isFloatingOrPositioned()) || !child->isRenderBlock())
                continue;

                } else
                    clearPreviousFloat = false;

                bool canBreakReplacedElement = !child->isImage() || allowImagesToBreak || child->isAnonymousInlineBlock();
                if ((canBreakReplacedElement && (autoWrap || oldAutoWrap)) || clearPreviousFloat) {
                    m_minPrefWidth = max(inlineMin, m_minPrefWidth);
                    inlineMin = 0;
                }

                // If we're supposed to clear the previous float, then terminate maxwidth as well.
                // Also do this for anonymous inline blocks.
                if (clearPreviousFloat || child->isAnonymousInlineBlock()) {
                    m_maxPrefWidth = max(inlineMax, m_maxPrefWidth);
                    inlineMax = 0;
                }

                int ti = 0;
                if (!addedTextIndent) {
                    addedTextIndent = true;
                    if (!child->isAnonymousInlineBlock()) {
                        ti = style()->textIndent().calcMinValue(cw);
                        childMin += ti;
                        childMax += ti;
                    }
                }

                // Add our width to the max.
                inlineMax += childMax;

                if ((!autoWrap || !canBreakReplacedElement) && !child->isAnonymousInlineBlock()) {
                    if (child->isFloating())
                        m_minPrefWidth = max(childMin, m_minPrefWidth);
                    else


                    // Now start a new line.
                    inlineMin = 0;
                    
                    if (child->isAnonymousInlineBlock()) {
                        // Terminate max width as well.
                        m_maxPrefWidth = max(childMax, m_maxPrefWidth);
                        inlineMax = 0;
                    }
                }

                // We are no longer stripping whitespace at the start of

    // the base class.  If we're being queried as though we're the root line
    // box, then the fact that we're an inline-block is irrelevant, and we behave
    // just like a block.
    if (isReplaced() && !isRootLineBox) {
        if (isAnonymousInlineBlock())
            return height();
        return height() + marginTop() + marginBottom();
    }

    if (firstLine && document()->usesFirstLineRules()) {
        RenderStyle* s = style(firstLine);
        if (s != style())

        // We also give up on finding a baseline if we have a vertical scrollbar, or if we are scrolled
        // vertically (e.g., an overflow:hidden block that has had scrollTop moved) or if the baseline is outside
        // of our content box.
        if (isAnonymousInlineBlock())
            return height();
        int baselinePos = (layer() && (layer()->marquee() || layer()->verticalScrollbar() || layer()->scrollYOffset() != 0)) ? -1 : lastLineBoxBaseline();
        if (baselinePos != -1 && baselinePos <= borderTop() + paddingTop() + contentHeight())
            return marginTop() + baselinePos;

    m_maxMargin->m_bottomNeg = neg;
}

void RenderBlock::absoluteRects(Vector<IntRect>& rects, int tx, int ty)
{
    // For blocks inside inlines, we go ahead and include margins so that we run right up to the
    // inline boxes above and below us (thus getting merged with them to form a single irregular
    // shape).
    if (inlineContinuation()) {
        rects.append(IntRect(tx, ty - collapsedMarginTop(),
                             width(), height() + collapsedMarginTop() + collapsedMarginBottom()));
        inlineContinuation()->absoluteRects(rects,
                                            tx - x() + inlineContinuation()->containingBlock()->x(),
                                            ty - y() + inlineContinuation()->containingBlock()->y());
    } else
        rects.append(IntRect(tx, ty, width(), height()));
}

void RenderBlock::absoluteQuads(Vector<FloatQuad>& quads)
{
    // For blocks inside inlines, we go ahead and include margins so that we run right up to the
    // inline boxes above and below us (thus getting merged with them to form a single irregular
    // shape).
    if (inlineContinuation()) {
        FloatRect localRect(0, -collapsedMarginTop(),
                            width(), height() + collapsedMarginTop() + collapsedMarginBottom());
        quads.append(localToAbsoluteQuad(localRect));
        inlineContinuation()->absoluteQuads(quads);
    } else
        quads.append(RenderBox::localToAbsoluteQuad(FloatRect(0, 0, width(), height())));
}

IntRect RenderBlock::rectWithOutlineForRepaint(RenderBoxModelObject* repaintContainer, int outlineWidth)
{
    IntRect r(RenderBox::rectWithOutlineForRepaint(repaintContainer, outlineWidth));
    if (inlineContinuation())
        r.inflateY(collapsedMarginTop());
    return r;
}

RenderObject* RenderBlock::hoverAncestor() const
{
    return inlineContinuation() ? inlineContinuation() : RenderBox::hoverAncestor();
}

void RenderBlock::updateDragState(bool dragOn)
{
    RenderBox::updateDragState(dragOn);
    if (inlineContinuation())
        inlineContinuation()->updateDragState(dragOn);
}

RenderStyle* RenderBlock::outlineStyleForRepaint() const
{
    return inlineContinuation() ? inlineContinuation()->style() : style();
}

void RenderBlock::childBecameNonInline(RenderObject*)
{
    makeChildrenNonInline();

    // |this| may be dead here
}

void RenderBlock::updateHitTestResult(HitTestResult& result, const IntPoint& point)
{
    if (result.innerNode())
        return;

    Node* n = node();
    if (inlineContinuation())
        // We are in the margins of block elements that are part of a continuation.  In
        // this case we're actually still inside the enclosing inline element that was
        // split.  Go ahead and set our inner node accordingly.
        n = inlineContinuation()->node();

    if (n) {
        result.setInnerNode(n);
        if (!result.innerNonSharedNode())
            result.setInnerNonSharedNode(n);
        result.setLocalPoint(point);
    }
}

IntRect RenderBlock::localCaretRect(InlineBox* inlineBox, int caretOffset, int* extraWidthToEndOfLine)
{
    // Do the normal calculation in most cases.


void RenderBlock::addFocusRingRects(Vector<IntRect>& rects, int tx, int ty)
{
    if (width() || height())
    // inline boxes above and below us (thus getting merged with them to form a single irregular
    // shape).
    if (inlineContinuation()) {
        // FIXME: This check really isn't accurate. 
        bool nextInlineHasLineBox = inlineContinuation()->firstLineBox();
        // FIXME: This is wrong. The principal renderer may not be the continuation preceding this block.
        bool prevInlineHasLineBox = toRenderInline(inlineContinuation()->node()->renderer())->firstLineBox(); 
        int topMargin = prevInlineHasLineBox ? collapsedMarginTop() : 0;
        int bottomMargin = nextInlineHasLineBox ? collapsedMarginBottom() : 0;
        IntRect rect(tx, ty - topMargin, width(), height() + topMargin + bottomMargin);
        if (!rect.isEmpty())
            rects.append(rect);
    } else if (width() && height())
        rects.append(IntRect(tx, ty, width(), height()));

    if (!hasOverflowClip() && !hasControlClip()) {

            }
        }
    }

    if (inlineContinuation())
        inlineContinuation()->addFocusRingRects(rects, 
                                                tx - x() + inlineContinuation()->containingBlock()->x(),
                                                ty - y() + inlineContinuation()->containingBlock()->y());
}

RenderBlock* RenderBlock::createAnonymousBlock(bool isFlexibleBox) const

        return "RenderBlock (positioned)";
    if (isAnonymousBlock())
        return "RenderBlock (anonymous)";
    else if (isAnonymousInlineBlock())
        return "RenderBlock (anonymous inline-block)";
    else if (isAnonymous())
        return "RenderBlock (generated)";
    if (isRelPositioned())




    void adjustRectForColumns(IntRect&) const;

    void addContinuationWithOutline(RenderInline*);

    RenderInline* inlineContinuation() const { return m_inlineContinuation; }
    void setInlineContinuation(RenderInline* c) { m_inlineContinuation = c; }

    // This function is a convenience helper for creating an anonymous block that inherits its
    // style from this RenderBlock.
    RenderBlock* createAnonymousBlock(bool isFlexibleBox = false) const;

    virtual void paint(PaintInfo&, int tx, int ty);
    virtual void paintObject(PaintInfo&, int tx, int ty);

    bool inRootBlockContext() const;

    static void appendRunsForObject(int start, int end, RenderObject*, InlineBidiResolver&);    
    static bool requiresLineBox(const InlineIterator&, bool isLineEmpty = true, bool previousLineBrokeCleanly = true);

protected:
    void moveChildTo(RenderObject* to, RenderObjectChildList* toChildList, RenderObject* child);
    void moveChildTo(RenderObject* to, RenderObjectChildList* toChildList, RenderObject* beforeChild, RenderObject* child);


    void layoutPositionedObjects(bool relayoutChildren);

    virtual void paint(PaintInfo&, int tx, int ty);
    virtual void paintObject(PaintInfo&, int tx, int ty);

    int rightRelOffset(int y, int fixedOffset, bool applyTextIndent = true, int* heightRemaining = 0) const;
    int leftRelOffset(int y, int fixedOffset, bool applyTextIndent = true, int* heightRemaining = 0) const;



    virtual void updateFirstLetter();

    virtual void updateHitTestResult(HitTestResult&, const IntPoint&);

    // Delay update scrollbar until finishDelayRepaint() will be
    // called. This function is used when a flexbox is laying out its
    // descendant. If multiple calls are made to startDelayRepaint(),

        bool everHadLayout;
    };

    class MarginInfo;

    // The following functions' implementations are in RenderBlockLineLayout.cpp.    
    void bidiReorderLine(InlineBidiResolver&, const InlineIterator& end, bool previousLineBrokeCleanly);
    RootInlineBox* determineStartPosition(bool& firstLine, bool& fullLayout, bool& previousLineBrokeCleanly,
                                          InlineBidiResolver&, Vector<FloatWithRect>& floats, unsigned& numCleanFloats);

    void skipTrailingWhitespace(InlineIterator&, bool isLineEmpty, bool previousLineBrokeCleanly);
    int skipLeadingWhitespace(InlineBidiResolver&, bool firstLine, bool isLineEmpty, bool previousLineBrokeCleanly);
    void fitBelowFloats(int widthToFit, bool firstLine, int& availableWidth);
    InlineIterator findNextLineBreak(InlineBidiResolver&, bool firstLine, bool& isLineEmpty, bool& previousLineBrokeCleanly, MarginInfo&, EClear* clear = 0);
    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);

    // Obtains the nearest enclosing block (including this block) that contributes a first-line style to our inline
    // children.
    virtual RenderBlock* firstLineBlock() const;
    bool inRootBlockContext() const;

    virtual IntRect rectWithOutlineForRepaint(RenderBoxModelObject* repaintContainer, int outlineWidth);
    virtual RenderStyle* outlineStyleForRepaint() const;
    
    virtual RenderObject* hoverAncestor() const;
    virtual void updateDragState(bool dragOn);
    virtual void childBecameNonInline(RenderObject* child);

    virtual IntRect selectionRectForRepaint(RenderBoxModelObject* repaintContainer, bool /*clipToVisibleContent*/)

    int leftSelectionOffset(RenderBlock* rootBlock, int y);
    int rightSelectionOffset(RenderBlock* rootBlock, int y);

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

    int desiredColumnWidth() const;
    unsigned desiredColumnCount() const;
    Vector<IntRect>* columnRects() const;
    void setDesiredColumnCountAndWidth(int count, int width);
    int columnGap() const;
    
    void paintContinuationOutlines(PaintInfo&, int tx, int ty);

    virtual IntRect localCaretRect(InlineBox*, int caretOffset, int* extraWidthToEndOfLine = 0);


    DeprecatedPtrList<FloatingObject>* m_floatingObjects;
    ListHashSet<RenderBox*>* m_positionedObjects;

    // An inline can be split with blocks occurring in between the inline content.
    // When this occurs we need a pointer to our next object.  We can basically be
    // split into a sequence of inlines and blocks.  The continuation will either be
    // an anonymous block (that houses other blocks) or it will be an inline flow.
    RenderInline* m_inlineContinuation;

    // Allocated only when some of these fields have non-default values
    struct MaxMargin : Noncopyable {
        MaxMargin(const RenderBlock* o) 

    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>.

    mutable int m_lineHeight;

    // RenderRubyBase objects need to be able to split and merge, moving their children around
    // (calling moveChildTo, moveAllChildrenTo, and makeChildrenNonInline).
    friend class RenderRubyBase;




#include "BidiResolver.h"
#include "CharacterNames.h"
#include "InlineIterator.h"
#include "InlineTextBox.h"
#include "Logging.h"
#include "RenderArena.h"

// We don't let our line box tree for a single line get any deeper than this.
const unsigned cMaxLineDepth = 200;

class InlineIterator {
public:
    InlineIterator()
        : block(0)
        , obj(0)
        , pos(0)
        , nextBreakablePosition(-1)
    {
    }

    InlineIterator(RenderBlock* b, RenderObject* o, unsigned p)
        : block(b)
        , obj(o)
        , pos(p)
        , nextBreakablePosition(-1)
    {
    }

    void increment(InlineBidiResolver* resolver = 0);
    bool atEnd() const;

    UChar current() const;
    Direction direction() const;

    RenderBlock* block;
    RenderObject* obj;
    unsigned pos;
    int nextBreakablePosition;
};

static int getBorderPaddingMargin(RenderBoxModelObject* child, bool endOfInline)
{
    bool leftSide = (child->style()->direction() == LTR) ? !endOfInline : endOfInline;

    return extraWidth;
}

struct BidiRun : BidiCharacterRun {
    BidiRun(int start, int stop, RenderObject* object, BidiContext* context, Direction dir)
        : BidiCharacterRun(start, stop, context, dir)
        , m_object(object)
        , m_box(0)
    {
    }

    void destroy();

    // Overloaded new operator.
    void* operator new(size_t, RenderArena*) throw();

    // Overridden to prevent the normal delete from being called.
    void operator delete(void*, size_t);

    BidiRun* next() { return static_cast<BidiRun*>(m_next); }

private:
    // The normal operator new is disallowed.
    void* operator new(size_t) throw();

public:
    RenderObject* m_object;
    InlineBox* m_box;
};

#ifndef NDEBUG
static RefCountedLeakCounter bidiRunCounter("BidiRun");

static bool inBidiRunDestroy;
#endif

void BidiRun::destroy()
{
#ifndef NDEBUG
    inBidiRunDestroy = true;
#endif
    RenderArena* renderArena = m_object->renderArena();
    delete this;
#ifndef NDEBUG
    inBidiRunDestroy = false;
#endif

    // Recover the size left there for us by operator delete and free the memory.
    renderArena->free(*reinterpret_cast<size_t*>(this), this);
}

void* BidiRun::operator new(size_t sz, RenderArena* renderArena) throw()
{
#ifndef NDEBUG
    bidiRunCounter.increment();
#endif
    return renderArena->allocate(sz);
}

void BidiRun::operator delete(void* ptr, size_t sz)
{
#ifndef NDEBUG
    bidiRunCounter.decrement();
#endif
    ASSERT(inBidiRunDestroy);

    // Stash size where destroy() can find it.
    *(size_t*)ptr = sz;
}

// ---------------------------------------------------------------------

inline bool operator==(const InlineIterator& it1, const InlineIterator& it2)
{
    return it1.pos == it2.pos && it1.obj == it2.obj;
}

inline bool operator!=(const InlineIterator& it1, const InlineIterator& it2)
{
    return it1.pos != it2.pos || it1.obj != it2.obj;
}

static inline RenderObject* bidiNext(RenderBlock* block, RenderObject* current, InlineBidiResolver* resolver = 0, bool skipInlines = true, bool* endOfInlinePtr = 0)
{
    RenderObject* next = 0;
    bool oldEndOfInline = endOfInlinePtr ? *endOfInlinePtr : false;
    bool endOfInline = false;

    while (current) {
        next = 0;
        if (!oldEndOfInline && !current->isFloating() && !current->isReplaced() && !current->isPositioned() && !current->isText()) {
            next = current->firstChild();
            if (next && resolver && next->isRenderInline()) {
                EUnicodeBidi ub = next->style()->unicodeBidi();
                if (ub != UBNormal) {
                    TextDirection dir = next->style()->direction();
                    Direction d = (ub == Embed
                        ? (dir == RTL ? RightToLeftEmbedding : LeftToRightEmbedding)
                        : (dir == RTL ? RightToLeftOverride : LeftToRightOverride));
                    resolver->embed(d);
                }
            }
        }

        if (!next) {
            if (!skipInlines && !oldEndOfInline && current->isRenderInline()) {
                next = current;
                endOfInline = true;
                break;
            }

            while (current && current != block) {
                if (resolver && current->isRenderInline() && current->style()->unicodeBidi() != UBNormal)
                    resolver->embed(PopDirectionalFormat);

                next = current->nextSibling();
                if (next) {
                    if (resolver && next->isRenderInline()) {
                        EUnicodeBidi ub = next->style()->unicodeBidi();
                        if (ub != UBNormal) {
                            TextDirection dir = next->style()->direction();
                            Direction d = (ub == Embed
                                ? (dir == RTL ? RightToLeftEmbedding: LeftToRightEmbedding)
                                : (dir == RTL ? RightToLeftOverride : LeftToRightOverride));
                            resolver->embed(d);
                        }
                    }
                    break;
                }
                
                current = current->parent();
                if (!skipInlines && current && current != block && current->isRenderInline()) {
                    next = current;
                    endOfInline = true;
                    break;
                }
            }
        }

        if (!next)
            break;

        if (next->isText() || next->isFloating() || next->isReplaced() || next->isPositioned()
            || ((!skipInlines || !next->firstChild()) // Always return EMPTY inlines.
                && next->isRenderInline()))
            break;
        current = next;
    }

    if (endOfInlinePtr)
        *endOfInlinePtr = endOfInline;

    return next;
}

static RenderObject* bidiFirst(RenderBlock* block, InlineBidiResolver* resolver, bool skipInlines = true)
{
    if (!block->firstChild())
        return 0;
    
    RenderObject* o = block->firstChild();
    if (o->isRenderInline()) {
        if (resolver) {
            EUnicodeBidi ub = o->style()->unicodeBidi();
            if (ub != UBNormal) {
                TextDirection dir = o->style()->direction();
                Direction d = (ub == Embed
                    ? (dir == RTL ? RightToLeftEmbedding : LeftToRightEmbedding)
                    : (dir == RTL ? RightToLeftOverride : LeftToRightOverride));
                resolver->embed(d);
            }
        }
        if (skipInlines && o->firstChild())
            o = bidiNext(block, o, resolver, skipInlines);
        else {
            // Never skip empty inlines.
            if (resolver)
                resolver->commitExplicitEmbedding();
            return o; 
        }
    }

    if (o && !o->isText() && !o->isReplaced() && !o->isFloating() && !o->isPositioned())
        o = bidiNext(block, o, resolver, skipInlines);

    if (resolver)
        resolver->commitExplicitEmbedding();
    return o;
}

inline void InlineIterator::increment(InlineBidiResolver* resolver)
{
    if (!obj)
        return;
    if (obj->isText()) {
        pos++;
        if (pos >= toRenderText(obj)->textLength()) {
            obj = bidiNext(block, obj, resolver);
            pos = 0;
            nextBreakablePosition = -1;
        }
    } else {
        obj = bidiNext(block, obj, resolver);
        pos = 0;
        nextBreakablePosition = -1;
    }
}

template<>
inline void InlineBidiResolver::increment()
{
    current.increment(this);
}

inline bool InlineIterator::atEnd() const
{
    return !obj;
}

inline UChar InlineIterator::current() const
{
    if (!obj || !obj->isText())
        return 0;

    RenderText* text = toRenderText(obj);
    if (pos >= text->textLength())
        return 0;

    return text->characters()[pos];
}

ALWAYS_INLINE Direction InlineIterator::direction() const
{
    if (UChar c = current())
        return Unicode::direction(c);

    if (obj && obj->isListMarker())
        return obj->style()->direction() == LTR ? LeftToRight : RightToLeft;

    return OtherNeutral;
}

// -------------------------------------------------------------------------------------------------

static void chopMidpointsAt(LineMidpointState& lineMidpointState, RenderObject* obj, unsigned pos)
{
    if (!lineMidpointState.numMidpoints)

    midpoints[lineMidpointState.numMidpoints++] = midpoint;
}

void RenderBlock::appendRunsForObject(int start, int end, RenderObject* obj, InlineBidiResolver& resolver)
{
    if (start > end || obj->isFloating() ||
        (obj->isPositioned() && !obj->style()->hasStaticX() && !obj->style()->hasStaticY() && !obj->container()->isRenderInline()))

    }
}

template <>
void InlineBidiResolver::appendRun()
{
    if (!emptyRun && !eor.atEnd()) {
        int start = sor.pos;
        RenderObject *obj = sor.obj;
        while (obj && obj != eor.obj && obj != endOfLine.obj) {
            appendRunsForObject(start, obj->length(), obj, *this);        
            start = 0;
            obj = bidiNext(sor.block, obj);
        }
        if (obj) {
            unsigned pos = obj == eor.obj ? eor.pos : UINT_MAX;
            if (obj == endOfLine.obj && endOfLine.pos <= pos) {
                reachedEndOfLine = true;
                pos = endOfLine.pos;
            }
            // It's OK to add runs for zero-length RenderObjects, just don't make the run larger than it should be
            int end = obj->length() ? pos+1 : 0;
            appendRunsForObject(start, end, obj, *this);
        }
        
        eor.increment();
        sor = eor;
    }

    m_direction = OtherNeutral;
    m_status.eor = OtherNeutral;
}

static inline InlineBox* createInlineBoxForRenderer(RenderObject* obj, bool isRootLineBox, bool isOnlyRun = false)
{
    if (isRootLineBox)

        if (!box)
            continue;

        // Anonymous inline blocks (used to hold blocks inside inlines) don't need to waste time wrapping
        // themselves in those inlines (since we want to pretend like they don't exist on this fake line).
        RenderObject* ancestorRenderer = r->m_object->isAnonymousInlineBlock() ? this : r->m_object->parent();
 
        // If we have no parent box yet, or if the run is not simply a sibling,
        // then we need to construct inline boxes as necessary to properly enclose the
        // run's inline box.
        if (!parentBox || parentBox->renderer() != ancestorRenderer)
            // Create new inline boxes all the way back to the appropriate insertion point.
            parentBox = createLineBoxes(ancestorRenderer, firstLine);

        // Append the inline box to this line.
        parentBox->addToLine(box);

    unsigned numSpaces = 0;
    ETextAlign textAlign = style()->textAlign();

    int x = leftOffset(height(), firstLine);

    for (BidiRun* r = firstRun; r; r = r->next()) {
        if (!r->m_box || r->m_object->isPositioned() || r->m_box->isLineBreak())
            continue; // Positioned objects are only participating to figure out their

            renderBox->calcWidth();
            r->m_box->setWidth(renderBox->width());
            totWidth += renderBox->marginLeft() + renderBox->marginRight();
            
            if (r->m_object->isAnonymousInlineBlock()) {
                // Allow the full available width to be used, since floats will intrude into our space.
                availableWidth = rightOffset() - leftOffset();
                x = leftOffset();
            }
        }

        totWidth += r->m_box->width();

    // we now examine our text-align property in order to determine where to position the
    // objects horizontally.  The total width of the line can be increased if we end up
    // justifying text.
    int x = leftOffset(height(), firstLine);
    switch (textAlign) {
        case LEFT:
        case WEBKIT_LEFT:

    bool useRepaintBounds = false;
    
    m_overflow.clear();
    
    int top = borderTop() + paddingTop();
    int bottom = borderBottom() + paddingBottom() + horizontalScrollbarHeight();

    setHeight(top);

    // The margin struct caches all our current margin collapsing state. We run margin collapsing when we encounter anonymous inline blocks that are being used
    // for the blocks-inside-inlines case (and the inlines are empty), e.g, <span><div>One</div></span>.
    MarginInfo marginInfo(this, top, bottom);

    // Figure out if we should clear out our line boxes.
    // FIXME: Handle resize eventually!

            if (o->isReplaced() || o->isFloating() || o->isPositioned()) {
                RenderBox* box = toRenderBox(o);
                
                // Make sure we layout children if they need it.
                // FIXME: Technically percentage height objects only need a relayout if their percentage isn't going to be turned into
                // an auto value.  Add a method to determine this, so that we can avoid the relayout.
                if (relayoutChildren || ((box->style()->height().isPercent() || box->style()->minHeight().isPercent() || box->style()->maxHeight().isPercent())))
                    box->setChildNeedsLayout(true, false);

                // If relayoutChildren is set and we have percentage padding, we also need to invalidate the child's pref widths.
                if (relayoutChildren && (box->style()->paddingLeft().isPercent() || box->style()->paddingRight().isPercent()))
                    box->setPrefWidthsDirty(true, false);
            
                if (o->isPositioned())
                    o->containingBlock()->insertPositionedObject(box);

                    else if (fullLayout || o->needsLayout()) // Replaced elements
                        toRenderBox(o)->dirtyLineBoxes(fullLayout);

                    if (!o->isReplaced() || !o->isAnonymousInlineBlock())
                        o->layoutIfNeeded();
                }
            } else if (o->isText() || (o->isRenderInline() && !endOfInline)) {
                hasInlineChild = true;

            isLineEmpty = true;
            
            EClear clear = CNONE;
            end = findNextLineBreak(resolver, firstLine, isLineEmpty, previousLineBrokeCleanly, marginInfo, &clear);
            if (resolver.position().atEnd()) {
                resolver.deleteRuns();
                checkForFloatsFromLastLine = true;

                    if (lineBox) {
                        lineBox->setEndsWithBreak(previousLineBrokeCleanly);

                        // If our previous line was an anonymous block and we are not an anonymous block, simulate a margin collapse now so that we get the proper
                        // increased height.  We also have to simulate a margin collapse to propagate margins through to the top of our block.
                        if (!lineBox->anonymousInlineBlock()) {
                            if (!lineBox->prevRootBox() || lineBox->prevRootBox()->anonymousInlineBlock())
                                collapseMargins(0, marginInfo);
                            marginInfo.setAtTopOfBlock(false);
                        }

                        // Now we position all of our text runs horizontally.
                        computeHorizontalPositionsForLine(lineBox, firstLine, resolver.firstRun(), trailingSpaceRun, end.atEnd());


        }
    }

    // Now do the handling of the bottom of the block, adding in our bottom border/padding and
    // determining the correct collapsed bottom margin information.  This collapse is only necessary
    // if our last child was an anonymous inline block that might need to propagate margin information out to
    // us.
    if (lastRootBox() && lastRootBox()->anonymousInlineBlock())
        handleBottomOfBlock(top, bottom, marginInfo);
    else
        setHeight(height() + bottom);

    if (!firstLineBox() && hasLineIfEmpty())
        setHeight(height() + lineHeight(true, true));

    if (!fullLayout) {
        size_t floatIndex = 0;
        for (curr = firstRootBox(); curr && !curr->isDirty(); curr = curr->nextRootBox()) {
            if (curr->anonymousInlineBlock()) {
                // FIXME: We have to do better than this or we will repaint too much as content inside an
                // anonymous inline block comes in.
                fullLayout = true;
                break;
            }
            if (Vector<RenderBox*>* cleanLineFloats = curr->floatsPtr()) {
                Vector<RenderBox*>::iterator end = cleanLineFloats->end();
                for (Vector<RenderBox*>::iterator o = cleanLineFloats->begin(); o != end; ++o) {

    return !flow->firstChild() && flow->hasHorizontalBordersPaddingOrMargin();
}

bool RenderBlock::requiresLineBox(const InlineIterator& it, bool isLineEmpty, bool previousLineBrokeCleanly)
{
    if (it.obj->isFloatingOrPositioned())
        return false;

}

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


    bool autoWrapWasEverTrueOnLine = false;
    bool floatsFitOnLine = true;
    
    bool isBlockInsideInline = false;
    
    int previousBlockFloatBottom = 0;
    int maxBlockFloatBottom = 0;

    // Firefox and Opera will allow a table cell to grow to fit an image inside it under
    // very specific circumstances (in order to match common WinIE renderings). 
    // Not supporting the quirk has caused us to mis-render some real sites. (See Bugzilla 10517.) 

    while (o) {
        currWS = o->isReplaced() ? o->parent()->style()->whiteSpace() : o->style()->whiteSpace();
        lastWS = last->isReplaced() ? last->parent()->style()->whiteSpace() : last->style()->whiteSpace();
        isBlockInsideInline = o->isAnonymousInlineBlock();

        bool autoWrap = RenderStyle::autoWrap(currWS);
        autoWrapWasEverTrueOnLine = autoWrapWasEverTrueOnLine || autoWrap;


#endif

        bool collapseWhiteSpace = RenderStyle::collapseWhiteSpace(currWS);

        if (o->isBR()) {
            if (w + tmpW <= width) {
                lBreak.obj = o;

        } else if (o->isReplaced()) {
            RenderBox* replacedBox = toRenderBox(o);

            // Break on replaced elements if either has normal white-space.  We also always break if we
            // encounter a special anonymous inline block (used to hold blocks inside inlines).
            if ((autoWrap || RenderStyle::autoWrap(lastWS) || isBlockInsideInline)  && (!o->isImage() || allowImagesToBreak)) {
                w += tmpW;
                tmpW = 0;
                lBreak.obj = o;

                lBreak.nextBreakablePosition = -1;
            }

            if (isBlockInsideInline) {
                if (!isLineEmpty)
                    goto end;

                // Reset the width to ignore floats, since we're going to allow them to intrude into our space.
                width = rightOffset() - leftOffset();

                // FIXME: This call will update the height of our block.  It's not clear if that's going to be ok or not yet.
                layoutBlockChild(replacedBox, marginInfo, previousBlockFloatBottom, maxBlockFloatBottom);

                lineMidpointState.betweenMidpoints = false;
            }

            if (ignoringSpaces)
                addMidpoint(lineMidpointState, InlineIterator(0, o, 0));


                    tmpW += replacedBox->width() + replacedBox->marginLeft() + replacedBox->marginRight() + inlineWidth(o);
            } else
                tmpW += replacedBox->width() + replacedBox->marginLeft() + replacedBox->marginRight() + inlineWidth(o);
                
            if (isBlockInsideInline) {
                w += tmpW;
                tmpW = 0;
                lBreak.obj = o;
                lBreak.pos = 0;
                lBreak.nextBreakablePosition = -1;
                goto end;
            }
        } else if (o->isText()) {
            if (!pos)
                appliedStartWidth = false;

        }
        //else if (lBreak.pos > 0)
        //    lBreak.pos--;
        else if ((!lBreak.obj || lBreak.obj->isAnonymousInlineBlock()) && trailingSpaceObject->isText()) {
            // Add a new end midpoint that stops right at the very end.
            RenderText* text = toRenderText(trailingSpaceObject);
            unsigned length = text->textLength();



    }

    if (containerWidth && containerWidth != (width() + m_marginLeft + m_marginRight)
            && !isFloating() && (!isInline() || isAnonymousInlineBlock()) && !cb->isFlexibleBox()) {
        if (cb->style()->direction() == LTR)
            m_marginRight = containerWidth - width() - m_marginLeft;
        else

{
    // Marquees in WinIE are like a mixture of blocks and inline-blocks.  They size as though they're blocks,
    // but they allow text to sit on the same line as the marquee.
    if (isFloating() || (isInlineBlockOrInlineTable() && !isHTMLMarquee() && !isAnonymousInlineBlock()))
        return true;

    // This code may look a bit strange.  Basically width:intrinsic should clamp the size when testing both


bool RenderBox::avoidsFloats() const
{
    return !isAnonymousInlineBlock() && (isReplaced() || hasOverflowClip() || isHR());
}

void RenderBox::addShadowOverflow()




RenderInline::RenderInline(Node* node)
    : RenderBoxModelObject(node)
    , m_continuation(0)
    , m_lineHeight(-1)
    , m_verticalPosition(PositionUndefined)
{

    // Make sure to destroy anonymous children first while they are still connected to the rest of the tree, so that they will
    // properly dirty line boxes that they are removed from.  Effects that do :before/:after only on hover could crash otherwise.
    children()->destroyLeftoverChildren();

    // Destroy our continuation before anything other than anonymous children.
    // The reason we don't destroy it before anonymous children is that they may
    // have continuations of their own that are anonymous children of our continuation.
    if (m_continuation) {
        m_continuation->destroy();
        m_continuation = 0;
    }
    
    if (!documentBeingDestroyed()) {
        if (firstLineBox()) {

    RenderBoxModelObject::destroy();
}

RenderInline* RenderInline::inlineContinuation() const
{
    if (!m_continuation || m_continuation->isInline())
        return toRenderInline(m_continuation);
    return toRenderBlock(m_continuation)->inlineContinuation();
}

void RenderInline::updateBoxModelInfoFromStyle()
{
    RenderBoxModelObject::updateBoxModelInfoFromStyle();

{
    RenderBoxModelObject::styleDidChange(diff, oldStyle);

    // Ensure that all of the split inlines pick up the new style. We
    // only do this if we're an inline, since we don't want to propagate
    // a block's style to the other inlines.
    // e.g., <font>foo <h4>goo</h4> moo</font>.  The <font> inlines before
    // and after the block share the same style, but the block doesn't
    // need to pass its style on to anyone else.
    for (RenderInline* currCont = inlineContinuation(); currCont; currCont = currCont->inlineContinuation()) {
        RenderBoxModelObject* nextCont = currCont->continuation();
        currCont->setContinuation(0);
        currCont->setStyle(style());
        currCont->setContinuation(nextCont);
    }

    m_lineHeight = -1;

    // Update pseudos for :before and :after now.

    }
}

void RenderInline::childBecameNonInline(RenderObject* child)
{
    if (continuation())
        return addChildToContinuation(newChild, beforeChild);
    return addChildIgnoringContinuation(newChild, beforeChild);
}

static RenderBoxModelObject* nextContinuation(RenderObject* renderer)
{
    RenderObject* next = child->nextSibling();
    removeChild(child);
    addChild(child, next);
}

void RenderInline::addChild(RenderObject* newChild, RenderObject* beforeChild)
{
    if (beforeChild && beforeChild->parent() == this)
        return this;

    RenderBoxModelObject* curr = nextContinuation(this);
    RenderBoxModelObject* nextToLast = this;
    RenderBoxModelObject* last = this;
    while (curr) {
        if (beforeChild && beforeChild->parent() == curr) {
            if (curr->firstChild() == beforeChild)
                return last;
            return curr;
        }

        nextToLast = last;
        last = curr;
        curr = nextContinuation(curr);
    }

    if (!beforeChild && !last->firstChild())
        return nextToLast;
    return last;
}

void RenderInline::addChildIgnoringContinuation(RenderObject* newChild, RenderObject* beforeChild)
{
    // Make sure we don't append things after :after-generated content if we have it.
    if (!beforeChild && isAfterContent(lastChild()))
        beforeChild = lastChild();

    // If the requested beforeChild is not one of our children, then this is most likely because
    // there is an anonymous inline-block box within this object that contains the beforeChild. So
    // just insert the child into the anonymous inline-block box instead of here.
    // A second possibility is that the beforeChild is an anonymous block inside the anonymous inline block.
    // This can happen if inlines are inserted in between two of the anonymous inline block's block-level
    // children after it has been created.
    if (beforeChild && beforeChild->parent() != this) {
        ASSERT(beforeChild->parent());
        ASSERT(beforeChild->parent()->isAnonymousInlineBlock() || beforeChild->parent()->isAnonymousBlock());
        if (beforeChild->parent()->isAnonymousInlineBlock()) {
            if (!newChild->isInline() || (newChild->isInline() && beforeChild->parent()->firstChild() != beforeChild))
                beforeChild->parent()->addChild(newChild, beforeChild);
            else
                addChild(newChild, beforeChild->parent());
        } else if (beforeChild->parent()->isAnonymousBlock()) {
            ASSERT(!beforeChild->parent()->parent() || beforeChild->parent()->parent()->isAnonymousInlineBlock());
            ASSERT(beforeChild->isInline());
            if (newChild->isInline() || (!newChild->isInline() && beforeChild->parent()->firstChild() != beforeChild))
                beforeChild->parent()->addChild(newChild, beforeChild);
            else
                addChild(newChild, beforeChild->parent());
        }
                             // point to be 0.  It's just a straight append now.

        splitFlow(beforeChild, newBox, newChild, oldContinuation);
        return;
    }

    if (!newChild->isInline()) {
        // We are placing a block inside an inline. We have to place the block inside an anonymous inline-block.
        // This inline-block can house a sequence of contiguous block-level children, and they will all sit on the
        // same line together.  We try to reuse one first if possible.
        if (beforeChild) {
            if (beforeChild->previousSibling() && beforeChild->previousSibling()->isAnonymousInlineBlock()) {
                beforeChild->previousSibling()->addChild(newChild);
                return;
            }
        } else {
            if (lastChild() && lastChild()->isAnonymousInlineBlock()) {
                lastChild()->addChild(newChild);
                return;
            }
        }
 
        if (!newChild->isFloatingOrPositioned()) {
            // There was no suitable existing anonymous box.  Create a new one.
            RefPtr<RenderStyle> newStyle = RenderStyle::create();
            newStyle->inheritFrom(style());
            newStyle->setDisplay(INLINE_BLOCK);
            RenderBlock* newBox = new (renderArena()) RenderBlock(document());
            newBox->setStyle(newStyle);
            RenderBoxModelObject::addChild(newBox, beforeChild);
            newBox->addChild(newChild);
            return;
        }
    }

    RenderBoxModelObject::addChild(newChild, beforeChild);

    newChild->setNeedsLayoutAndPrefWidthsRecalc();

    return o;
}

void RenderInline::splitInlines(RenderBlock* fromBlock, RenderBlock* toBlock,
                                RenderBlock* middleBlock,
                                RenderObject* beforeChild, RenderBoxModelObject* oldCont)
{
    // Create a clone of this inline.
    RenderInline* clone = cloneInline(this);
    clone->setContinuation(oldCont);

    // Now take all of the children from beforeChild to the end and remove
    // them from |this| and place them in the clone.
    RenderObject* o = beforeChild;
    while (o) {
        RenderObject* tmp = o;
        o = tmp->nextSibling();
        clone->addChildIgnoringContinuation(children()->removeChildNode(this, tmp), 0);
        tmp->setNeedsLayoutAndPrefWidthsRecalc();
    }

    // Hook |clone| up as the continuation of the middle block.
    middleBlock->setInlineContinuation(clone);

    // We have been reparented and are now under the fromBlock.  We need
    // to walk up our inline parent chain until we hit the containing block.
    // Once we hit the containing block we're done.
    RenderBoxModelObject* curr = toRenderBoxModelObject(parent());
    RenderBoxModelObject* currChild = this;
    
    // FIXME: Because splitting is O(n^2) as tags nest pathologically, we cap the depth at which we're willing to clone.
    // There will eventually be a better approach to this problem that will let us nest to a much
    // greater depth (see bugzilla bug 13430) but for now we have a limit.  This *will* result in
    // incorrect rendering, but the alternative is to hang forever.
    unsigned splitDepth = 1;
    const unsigned cMaxSplitDepth = 200; 
    while (curr && curr != fromBlock) {
        ASSERT(curr->isRenderInline());
        if (splitDepth < cMaxSplitDepth) {
            // Create a new clone.
            RenderInline* cloneChild = clone;
            clone = cloneInline(toRenderInline(curr));

            // Insert our child clone as the first child.
            clone->addChildIgnoringContinuation(cloneChild, 0);

            // Hook the clone up as a continuation of |curr|.
            RenderInline* inlineCurr = toRenderInline(curr);
            oldCont = inlineCurr->continuation();
            inlineCurr->setContinuation(clone);
            clone->setContinuation(oldCont);

            // Someone may have indirectly caused a <q> to split.  When this happens, the :after content
            // has to move into the inline continuation.  Call updateBeforeAfterContent to ensure that the inline's :after
            // content gets properly destroyed.
            if (document()->usesBeforeAfterRules())
                inlineCurr->children()->updateBeforeAfterContent(this, AFTER);

            // Now we need to take all of the children starting from the first child
            // *after* currChild and append them all to the clone.
            o = currChild->nextSibling();
            while (o) {
                RenderObject* tmp = o;
                o = tmp->nextSibling();
                clone->addChildIgnoringContinuation(inlineCurr->children()->removeChildNode(curr, tmp), 0);
                tmp->setNeedsLayoutAndPrefWidthsRecalc();
            }
        }
        
        // Keep walking up the chain.
        currChild = curr;
        curr = toRenderBoxModelObject(curr->parent());
        splitDepth++;
    }

    // Now we are at the block level. We need to put the clone into the toBlock.
    toBlock->children()->appendChildNode(toBlock, clone);

    // Now take all the children after currChild and remove them from the fromBlock
    // and put them in the toBlock.
    o = currChild->nextSibling();
    while (o) {
        RenderObject* tmp = o;
        o = tmp->nextSibling();
        toBlock->children()->appendChildNode(toBlock, fromBlock->children()->removeChildNode(fromBlock, tmp));
    }
}

void RenderInline::splitFlow(RenderObject* beforeChild, RenderBlock* newBlockBox,
                             RenderObject* newChild, RenderBoxModelObject* oldCont)
{
    RenderBlock* pre = 0;
    RenderBlock* block = containingBlock();
    
    // Delete our line boxes before we do the inline split into continuations.
    block->deleteLineBoxTree();
    
    bool madeNewBeforeBlock = false;
    if (block->isAnonymousBlock() && (!block->parent() || !block->parent()->createsAnonymousWrapper())) {
        // We can reuse this block and make it the preBlock of the next continuation.
        pre = block;
        pre->removePositionedObjects(0);
        block = block->containingBlock();
    } else {
        // No anonymous block available for use.  Make one.
        pre = block->createAnonymousBlock();
        madeNewBeforeBlock = true;
    }

    RenderBlock* post = block->createAnonymousBlock();

    RenderObject* boxFirst = madeNewBeforeBlock ? block->firstChild() : pre->nextSibling();
    if (madeNewBeforeBlock)
        block->children()->insertChildNode(block, pre, boxFirst);
    block->children()->insertChildNode(block, newBlockBox, boxFirst);
    block->children()->insertChildNode(block, post, boxFirst);
    block->setChildrenInline(false);
    
    if (madeNewBeforeBlock) {
        RenderObject* o = boxFirst;
        while (o) {
            RenderObject* no = o;
            o = no->nextSibling();
            pre->children()->appendChildNode(pre, block->children()->removeChildNode(block, no));
            no->setNeedsLayoutAndPrefWidthsRecalc();
        }
    }

    splitInlines(pre, post, newBlockBox, beforeChild, oldCont);

    // We already know the newBlockBox isn't going to contain inline kids, so avoid wasting
    // time in makeChildrenNonInline by just setting this explicitly up front.
    newBlockBox->setChildrenInline(false);

    // We delayed adding the newChild until now so that the |newBlockBox| would be fully
    // connected, thus allowing newChild access to a renderArena should it need
    // to wrap itself in additional boxes (e.g., table construction).
    newBlockBox->addChild(newChild);

    // Always just do a full layout in order to ensure that line boxes (especially wrappers for images)
    // get deleted properly.  Because objects moves from the pre block into the post block, we want to
    // make new line boxes instead of leaving the old line boxes around.
    pre->setNeedsLayoutAndPrefWidthsRecalc();
    block->setNeedsLayoutAndPrefWidthsRecalc();
    post->setNeedsLayoutAndPrefWidthsRecalc();
}

void RenderInline::addChildToContinuation(RenderObject* newChild, RenderObject* beforeChild)
{
    RenderBoxModelObject* flow = continuationBefore(beforeChild);
    ASSERT(!beforeChild || beforeChild->parent()->isRenderBlock() || beforeChild->parent()->isRenderInline());
    RenderBoxModelObject* beforeChildParent = 0;
    if (beforeChild)
        beforeChildParent = toRenderBoxModelObject(beforeChild->parent());
    else {
        RenderBoxModelObject* cont = nextContinuation(flow);
        if (cont)
            beforeChildParent = cont;
        else
            beforeChildParent = flow;
    }

    if (newChild->isFloatingOrPositioned())
        return beforeChildParent->addChildIgnoringContinuation(newChild, beforeChild);

    // A continuation always consists of two potential candidates: an inline or an anonymous
    // block box holding block children.
    bool childInline = newChild->isInline();
    bool bcpInline = beforeChildParent->isInline();
    bool flowInline = flow->isInline();

    if (flow == beforeChildParent)
        return flow->addChildIgnoringContinuation(newChild, beforeChild);
    else {
        // The goal here is to match up if we can, so that we can coalesce and create the
        // minimal # of continuations needed for the inline.
        if (childInline == bcpInline)
            return beforeChildParent->addChildIgnoringContinuation(newChild, beforeChild);
        else if (flowInline == childInline)
            return flow->addChildIgnoringContinuation(newChild, 0); // Just treat like an append.
        else
            return beforeChildParent->addChildIgnoringContinuation(newChild, beforeChild);
    }
}

void RenderInline::paint(PaintInfo& paintInfo, int tx, int ty)
{
    m_lineBoxes.paint(this, paintInfo, tx, ty);

            rects.append(IntRect(tx + curr->x(), ty + curr->y(), curr->width(), curr->height()));
    } else
        rects.append(IntRect(tx, ty, 0, 0));

    if (continuation()) {
        if (continuation()->isBox()) {
            RenderBox* box = toRenderBox(continuation());
            continuation()->absoluteRects(rects, 
                                          tx - containingBlock()->x() + box->x(),
                                          ty - containingBlock()->y() + box->y());
        } else
            continuation()->absoluteRects(rects, tx - containingBlock()->x(), ty - containingBlock()->y());
    }
}

void RenderInline::absoluteQuads(Vector<FloatQuad>& quads)

        }
    } else
        quads.append(localToAbsoluteQuad(FloatRect()));

    if (continuation())
        continuation()->absoluteQuads(quads);
}

int RenderInline::offsetLeft() const

        // should try to find a result by asking our containing block.
        return cb->positionForPoint(point);
    }

    // Translate the coords from the pre-anonymous block to the post-anonymous block.
    int parentBlockX = cb->x() + point.x();
    int parentBlockY = cb->y() + point.y();
    RenderBoxModelObject* c = continuation();
    while (c) {
        RenderBox* contBlock = c->isInline() ? c->containingBlock() : toRenderBlock(c);
        if (c->isInline() || c->firstChild())
            return c->positionForCoordinates(parentBlockX - contBlock->x(), parentBlockY - contBlock->y());
        c = toRenderBlock(c)->inlineContinuation();
    }
    
    return RenderBoxModelObject::positionForPoint(point);
}


    // Only run-ins are allowed in here during layout.
    ASSERT(!view() || !view()->layoutStateEnabled() || isRunIn());

    if (!firstLineBox())
        return IntRect();

    // Find our leftmost position.

                r.unite(childRect);
            }
        }

        if (continuation() && !continuation()->isInline()) {
            IntRect contRect = continuation()->rectWithOutlineForRepaint(repaintContainer, ow);
            r.unite(contRect);
        }
    }

    return r;

        transformState.move(-containerOffset.width(), -containerOffset.height(), preserve3D ? TransformState::AccumulateTransform : TransformState::FlattenTransform);
}

void RenderInline::updateDragState(bool dragOn)
{
    RenderBoxModelObject::updateDragState(dragOn);
    if (continuation())
        continuation()->updateDragState(dragOn);
}

void RenderInline::childBecameNonInline(RenderObject* child)
{
    // We have to split the parent flow.
    RenderBlock* newBox = containingBlock()->createAnonymousBlock();
    RenderBoxModelObject* oldContinuation = continuation();
    setContinuation(newBox);
    RenderObject* beforeChild = child->nextSibling();
    children()->removeChildNode(this, child);
    splitFlow(beforeChild, newBox, child, oldContinuation);
}

void RenderInline::updateHitTestResult(HitTestResult& result, const IntPoint& point)
{
    if (result.innerNode())
        return;

    Node* n = node();
    IntPoint localPoint(point);
    if (n) {
        if (isInlineContinuation()) {
            // We're in the continuation of a split inline.  Adjust our local point to be in the coordinate space
            // of the principal renderer's containing block.  This will end up being the innerNonSharedNode.
            RenderBlock* firstBlock = n->renderer()->containingBlock();
            
            // Get our containing block.
            RenderBox* block = containingBlock();
            localPoint.move(block->x() - firstBlock->x(), block->y() - firstBlock->y());
        }

        result.setInnerNode(n);
        if (!result.innerNonSharedNode())
            result.setInnerNonSharedNode(n);
        result.setLocalPoint(localPoint);
    }
}

void RenderInline::dirtyLineBoxes(bool fullLayout)
{
    if (fullLayout)

           curr->addFocusRingRects(rects, pos.x(), pos.y());
        }
    }

    if (continuation()) {
        if (continuation()->isInline())
            continuation()->addFocusRingRects(rects, 
                                              tx - containingBlock()->x() + continuation()->containingBlock()->x(),
                                              ty - containingBlock()->y() + continuation()->containingBlock()->y());
        else
            continuation()->addFocusRingRects(rects, 
                                              tx - containingBlock()->x() + toRenderBox(continuation())->x(),
                                              ty - containingBlock()->y() + toRenderBox(continuation())->y());
    }
}

void RenderInline::paintOutline(GraphicsContext* graphicsContext, int tx, int ty)




    InlineFlowBox* firstLineBox() const { return m_lineBoxes.firstLineBox(); }
    InlineFlowBox* lastLineBox() const { return m_lineBoxes.lastLineBox(); }

    RenderBoxModelObject* continuation() const { return m_continuation; }

    virtual void updateDragState(bool dragOn);
    
    IntSize relativePositionedInlineOffset(const RenderBox* child) const;



    virtual bool isRenderInline() const { return true; }

    void addChildToContinuation(RenderObject* newChild, RenderObject* beforeChild);
    virtual void addChildIgnoringContinuation(RenderObject* newChild, RenderObject* beforeChild = 0);

    void splitInlines(RenderBlock* fromBlock, RenderBlock* toBlock, RenderBlock* middleBlock,
                      RenderObject* beforeChild, RenderBoxModelObject* oldCont);
    void splitFlow(RenderObject* beforeChild, RenderBlock* newBlockBox,


    virtual int lineHeight(bool firstLine, bool isRootLineBox = false) const;

    RenderInline* inlineContinuation() const;
    void setContinuation(RenderBoxModelObject* c) { m_continuation = c; }
    
    virtual void childBecameNonInline(RenderObject* child);

    virtual void updateHitTestResult(HitTestResult&, const IntPoint&);

    virtual void imageChanged(WrappedImagePtr, const IntRect* = 0);

#if ENABLE(DASHBOARD_SUPPORT)

    static RenderInline* cloneInline(RenderInline* src);

    void paintOutlineForLine(GraphicsContext*, int tx, int ty, const IntRect& prevLine, const IntRect& thisLine, const IntRect& nextLine);
    RenderBoxModelObject* continuationBefore(RenderObject* beforeChild);

    RenderObjectChildList m_children;
    RenderLineBoxList m_lineBoxes;   // All of the line boxes created for this inline flow.  For example, <i>Hello<br>world.</i> will have two <i> line boxes.

    RenderBoxModelObject* m_continuation; // Can be either a block or an inline. <b><i><p>Hello</p></i></b>. In this example the <i> will have a block as its continuation but the
                                          // <b> will just have an inline as its continuation.
    mutable int m_lineHeight;
    mutable int m_verticalPosition;
};




void RenderLineBoxList::paint(RenderBoxModelObject* renderer, RenderObject::PaintInfo& paintInfo, int tx, int ty) const
{
    // Only paint during the foreground/selection phases.
    if (paintInfo.phase != PaintPhaseForeground && paintInfo.phase != PaintPhaseSelection && paintInfo.phase != PaintPhaseOutline 
        && paintInfo.phase != PaintPhaseSelfOutline && paintInfo.phase != PaintPhaseChildOutlines && paintInfo.phase != PaintPhaseTextClip
        && paintInfo.phase != PaintPhaseMask)
        return;

    ASSERT(renderer->isRenderBlock() || (renderer->isRenderInline() && renderer->hasLayer())); // The only way an inline could paint like this is if it has a layer.

    // If we have no lines then we have no work to do.
    if (!firstLineBox())
        return;

    // Only paint during the foreground/selection phases if we have a layer.  Otherwise we might have an anonymous inline block, so we can't short circuit.
    if (firstLineBox()->parent() && (paintInfo.phase != PaintPhaseForeground && paintInfo.phase != PaintPhaseSelection && paintInfo.phase != PaintPhaseOutline 
        && paintInfo.phase != PaintPhaseSelfOutline && paintInfo.phase != PaintPhaseChildOutlines && paintInfo.phase != PaintPhaseTextClip
        && paintInfo.phase != PaintPhaseMask))
        return;

    // 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.
    // FIXME: This check is flawed in the following extremely obscure way:

Lines 27-32 WebCore/rendering/RenderListItem.cpp_sec1
- WebCore/rendering/RenderListItem.cpp -37 / +51 lines
27	#include "CachedImage.h"	27	#include "CachedImage.h"
28	#include "HTMLNames.h"	28	#include "HTMLNames.h"
29	#include "HTMLOListElement.h"	29	#include "HTMLOListElement.h"
		30	#include "InlineIterator.h"
		31
30	#include "RenderListMarker.h"	32	#include "RenderListMarker.h"
31	#include "RenderView.h"	33	#include "RenderView.h"
32	#include <wtf/StdLibExtras.h>	34	#include <wtf/StdLibExtras.h>
Lines 153-170 bool RenderListItem::isEmpty() const WebCore/rendering/RenderListItem.cpp_sec2
153	return lastChild() == m_marker;	155	return lastChild() == m_marker;
154	}	156	}
155		157
156	static RenderObject* getParentOfFirstLineBox(RenderBlock* curr, RenderObject* marker)	158	void RenderListItem::updateValue()
157	{	159	{
158	RenderObject* firstChild = curr->firstChild();	160	if (!m_hasExplicitValue) {
159	if (!firstChild)	161	m_isValueUpToDate = false;
160	return 0;	162	if (m_marker)
		163	m_marker->setNeedsLayoutAndPrefWidthsRecalc();
		164	}
		165	}
161		166
162	for (RenderObject* currChild = firstChild; currChild; currChild = currChild->nextSibling()) {	167	static RenderObject* firstNonMarkerChild(RenderObject* parent)
		168	{
		169	RenderObject* result = parent->firstChild();
		170	while (result && result->isListMarker())
		171	result = result->nextSibling();
		172	return result;
		173	}
		174
		175
		176	static RenderBlock* listMarkerLocation(RenderBlock* block, RenderListMarker* marker)
		177	{
		178	for (RenderObject* currChild = block->firstChild(); currChild; currChild = currChild->nextSibling()) {
163	if (currChild == marker)	179	if (currChild == marker)
164	continue;	180	continue;
165		181
166	if (currChild->isInline() && (!currChild->isRenderInline() \|\| curr->generatesLineBoxesForInlineChild(currChild)))	182	if (currChild->isInline()) {
167	return curr;	183	if (!currChild->isRenderInline())
		184	return block;
		185	InlineIterator it(block, currChild, 0);
		186	while (!it.atEnd()) {
		187	if (it.obj->isAnonymousInlineBlock()) {
		188	RenderBlock* lineBoxParent = listMarkerLocation(toRenderBlock(it.obj), marker);
		189	if (lineBoxParent)
		190	return lineBoxParent;
		191	} else if (RenderBlock::requiresLineBox(it))
		192	return block;
		193	it.increment();
		194	}
		195	}
168		196
169	if (currChild->isFloating() \|\| currChild->isPositioned())	197	if (currChild->isFloating() \|\| currChild->isPositioned())
170	continue;	198	continue;
Lines 172-212 static RenderObject* getParentOfFirstLin WebCore/rendering/RenderListItem.cpp_sec3
172	if (currChild->isTable() \|\| !currChild->isRenderBlock())	200	if (currChild->isTable() \|\| !currChild->isRenderBlock())
173	break;	201	break;
174		202
175	if (curr->isListItem() && currChild->style()->htmlHacks() && currChild->node() &&	203	if (block->isListItem() && currChild->style()->htmlHacks() && currChild->node() &&
176	(currChild->node()->hasTagName(ulTag)\|\| currChild->node()->hasTagName(olTag)))	204	(currChild->node()->hasTagName(ulTag) \|\| currChild->node()->hasTagName(olTag)))
177	break;	205	break;
178		206
179	RenderObject* lineBox = getParentOfFirstLineBox(toRenderBlock(currChild), marker);	207	RenderBlock* lineBoxParent = listMarkerLocation(toRenderBlock(currChild), marker);
180	if (lineBox)	208	if (lineBoxParent)
181	return lineBox;	209	return lineBoxParent;
182	}	210	}
183		211
184	return 0;	212	return 0;
185	}	213	}
186		214
187	void RenderListItem::updateValue()
188	{
189	if (!m_hasExplicitValue) {
190	m_isValueUpToDate = false;
191	if (m_marker)
192	m_marker->setNeedsLayoutAndPrefWidthsRecalc();
193	}
194	}
195
196	static RenderObject* firstNonMarkerChild(RenderObject* parent)
197	{
198	RenderObject* result = parent->firstChild();
199	while (result && result->isListMarker())
200	result = result->nextSibling();
201	return result;
202	}
203
204	void RenderListItem::updateMarkerLocation()	215	void RenderListItem::updateMarkerLocation()
205	{	216	{
206	// Sanity check the location of our marker.	217	// Sanity check the location of our marker.
207	if (m_marker) {	218	if (m_marker) {
208	RenderObject* markerPar = m_marker->parent();	219	RenderObject* markerPar = m_marker->parent();
209	RenderObject* lineBoxParent = getParentOfFirstLineBox(this, m_marker);	220	RenderObject* lineBoxParent = listMarkerLocation(this, m_marker);
210	if (!lineBoxParent) {	221	if (!lineBoxParent) {
211	// If the marker is currently contained inside an anonymous box,	222	// If the marker is currently contained inside an anonymous box,
212	// then we are the only item in that anonymous box (since no line box	223	// then we are the only item in that anonymous box (since no line box
Lines 257-265 void RenderListItem::positionListMarker( WebCore/rendering/RenderListItem.cpp_sec4
257	int markerOldX = m_marker->x();	268	int markerOldX = m_marker->x();
258	int yOffset = 0;	269	int yOffset = 0;
259	int xOffset = 0;	270	int xOffset = 0;
260	for (RenderBox* o = m_marker->parentBox(); o != this; o = o->parentBox()) {	271	for (RenderObject* o = m_marker->parent(); o != this; o = o->parent()) {
261	yOffset += o->y();	272	if (o->isBox()) {
262	xOffset += o->x();	273	yOffset += toRenderBox(o)->y();
		274	xOffset += toRenderBox(o)->x();
		275	}
263	}	276	}
264		277
265	bool adjustOverflow = false;	278	bool adjustOverflow = false;
Lines 295-307 void RenderListItem::positionListMarker( WebCore/rendering/RenderListItem.cpp_sec5
295		308
296	if (adjustOverflow) {	309	if (adjustOverflow) {
297	IntRect markerRect(markerXPos + xOffset, yOffset, m_marker->width(), m_marker->height());	310	IntRect markerRect(markerXPos + xOffset, yOffset, m_marker->width(), m_marker->height());
298	RenderBox* o = m_marker;	311	RenderObject* o = m_marker;
299	do {	312	do {
300	o = o->parentBox();	313	o = o->parent();
301	if (o->isRenderBlock())	314	if (o->isRenderBlock())
302	toRenderBlock(o)->addLayoutOverflow(markerRect);	315	toRenderBlock(o)->addLayoutOverflow(markerRect);
303	markerRect.move(-o->x(), -o->y());	316	if (o->isBox())
304	} while (o != this && !o->hasSelfPaintingLayer());	317	markerRect.move(-toRenderBox(o)->x(), -toRenderBox(o)->y());
		318	} while (o != this && (!o->isBox() \|\| !toRenderBox(o)->hasSelfPaintingLayer())); // FIXME: Investigate <li><span style="position:relative;left:-100px"><div>text</div></span></li>
305	}	319	}
306	}	320	}
307	}	321	}



            }
        }
        curr = curr->parent();
        if (curr && curr->isRenderBlock() && toRenderBlock(curr)->inlineContinuation())
            curr = toRenderBlock(curr)->inlineContinuation();
    } while (curr && decorations && (!quirksMode || !curr->node() ||
                                     (!curr->node()->hasTagName(aTag) && !curr->node()->hasTagName(fontTag))));


Lines 365-370 public: WebCore/rendering/RenderObject.h_sec1
- WebCore/rendering/RenderObject.h +4 lines
365	{	365	{
366	return m_isAnonymous && style()->display() == BLOCK && style()->styleType() == NOPSEUDO && !isListMarker();	366	return m_isAnonymous && style()->display() == BLOCK && style()->styleType() == NOPSEUDO && !isListMarker();
367	}	367	}
		368	bool isAnonymousInlineBlock() const
		369	{
		370	return m_isAnonymous && style()->display() == INLINE_BLOCK && style()->styleType() == NOPSEUDO && !isRubyRun() && !isRubyBase();
		371	}
368	bool isInlineContinuation() const { return (node() ? node()->renderer() != this : false) && isRenderInline(); }	372	bool isInlineContinuation() const { return (node() ? node()->renderer() != this : false) && isRenderInline(); }
369	bool isFloating() const { return m_floating; }	373	bool isFloating() const { return m_floating; }
370	bool isPositioned() const { return m_positioned; } // absolute or fixed positioning	374	bool isPositioned() const { return m_positioned; } // absolute or fixed positioning




    // Whether or not we now want generated content.  
    bool newContentWanted = pseudoElementStyle && pseudoElementStyle->display() != NONE;

    // For <q><p/></q>, if this object is the inline continuation of the <q>, we only want to generate
    // :after content and not :before content.
    if (newContentWanted && type == BEFORE && owner->isRenderInline() && toRenderInline(owner)->isInlineContinuation())
        newContentWanted = false;

    // Similarly, if we're the beginning of a <q>, and there's an inline continuation for our object,
    // then we don't generate the :after content.
    if (newContentWanted && type == AFTER && owner->isRenderInline() && toRenderInline(owner)->continuation())
        newContentWanted = false;
    
    // If we don't want generated content any longer, or if we have generated content, but it's no longer
    // identical to the new content data we want to build render objects for, then we nuke all



                if (child->isAnonymousBlock()) {
                    RenderBlock* anonBlock = toRenderBlock(child);
                    ASSERT(anonBlock->childrenInline());
                    ASSERT(!anonBlock->inlineContinuation());
                    anonBlock->moveAllChildrenTo(toBase, toBase->children());
                    anonBlock->deleteLineBoxTree();
                    anonBlock->destroy();


                    RenderBlock* anonBlock = toRenderBlock(child);
                    ASSERT(anonBlock->childrenInline());
                    ASSERT(!anonBlock->inlineContinuation());
                    // Move inline children out of anonymous block.
                    anonBlock->moveAllChildrenTo(this, children(), anonBlock);
                    anonBlock->deleteLineBoxTree();



#include "Page.h"
#include "RenderArena.h"
#include "RenderBlock.h"
#include "RenderView.h"

using namespace std;



void RootInlineBox::paint(RenderObject::PaintInfo& paintInfo, int tx, int ty)
{
    RenderBlock* child = anonymousInlineBlock();
    if (child) {
        // Treat painting of a special inline-block line like the painting of a normal block and go through all phases.
        PaintPhase newPhase = (paintInfo.phase == PaintPhaseChildOutlines) ? PaintPhaseOutline : paintInfo.phase;
        newPhase = (newPhase == PaintPhaseChildBlockBackgrounds) ? PaintPhaseChildBlockBackground : newPhase;
    
        // We don't paint our own background, but we do let the child paint its background.
        RenderObject::PaintInfo info(paintInfo);
        info.phase = newPhase;
        info.paintingRoot = renderer()->paintingRootForChildren(paintInfo);
        bool isPrinting = renderer()->document()->printing();
        
        // Check for page-break-before: always, and if it's set, break and bail.
        if (isPrinting && child->style()->pageBreakBefore() == PBALWAYS &&
            block()->inRootBlockContext() && (ty + child->y()) > paintInfo.rect.y() && 
            (ty + child->y()) < paintInfo.rect.bottom()) {
            renderer()->view()->setBestTruncatedAt(ty + child->y(), block(), true);
            return;
        }

        if (!child->hasSelfPaintingLayer())
            child->paint(info, tx, ty);

        // Check for page-break-after: always, and if it's set, break and bail.
        if (isPrinting && child->style()->pageBreakAfter() == PBALWAYS && 
            block()->inRootBlockContext() && (ty + child->y() + child->height()) > paintInfo.rect.y() && 
            (ty + child->y() + child->height()) < paintInfo.rect.bottom()) {
            renderer()->view()->setBestTruncatedAt(ty + child->y() + child->height() + max(0, child->collapsedMarginBottom()), block(), true);
            return;
        }
        
        return;
    }

    // Only paint during the foreground/selection phases if we don't have a special anonymous inline block.
    if (paintInfo.phase != PaintPhaseForeground && paintInfo.phase != PaintPhaseSelection && paintInfo.phase != PaintPhaseOutline 
        && paintInfo.phase != PaintPhaseSelfOutline && paintInfo.phase != PaintPhaseChildOutlines && paintInfo.phase != PaintPhaseTextClip
        && paintInfo.phase != PaintPhaseMask)
        return;

    InlineFlowBox::paint(paintInfo, tx, ty);
    paintEllipsisBox(paintInfo, tx, ty);
#if PLATFORM(MAC)


int RootInlineBox::verticallyAlignBoxes(int heightOfBlock)
{
    RenderBlock* inlineBlock = anonymousInlineBlock();
    if (inlineBlock) {
        int lineTop = inlineBlock->y();
        int lineBottom = inlineBlock->y() + inlineBlock->height();
        firstChild()->setY(lineTop);
        setY(lineTop);
        computeVerticalOverflow(lineTop, lineBottom, true);
        setLineTopBottomPositions(lineTop, lineBottom);
        return heightOfBlock;
    }
    
    int maxPositionTop = 0;
    int maxPositionBottom = 0;
    int maxAscent = 0;

    bool strictMode = (curr && curr->document()->inStrictMode());

    computeLogicalBoxHeights(maxPositionTop, maxPositionBottom, maxAscent, maxDescent, strictMode);

    if (maxAscent + maxDescent < max(maxPositionTop, maxPositionBottom))
        adjustMaxAscentAndDescent(maxAscent, maxDescent, maxPositionTop, maxPositionBottom);


    block()->lineBoxes()->attachLineBox(this);
}

RenderBlock* RootInlineBox::anonymousInlineBlock() const
{
    return firstChild() && firstChild() == lastChild() && !firstChild()->isText() && firstChild()->renderer()->isAnonymousInlineBlock() ? toRenderBlock(firstChild()->renderer()) : 0;
}

} // namespace WebCore

Lines 132-137 public: WebCore/rendering/RootInlineBox.h_sec1
- WebCore/rendering/RootInlineBox.h +2 lines
132	virtual void attachLineBoxToRenderObject();	132	virtual void attachLineBoxToRenderObject();
133	virtual void removeLineBoxFromRenderObject();	133	virtual void removeLineBoxFromRenderObject();
134		134
		135	RenderBlock* anonymousInlineBlock() const;
		136
135	protected:	137	protected:
136	// Where this line ended. The exact object and the position within that object are stored so that	138	// Where this line ended. The exact object and the position within that object are stored so that
137	// we can create an InlineIterator beginning just after the end of this line.	139	// we can create an InlineIterator beginning just after the end of this line.

Return to Bug 13430

Lines 2221-2228 void RenderObject::getTextDecorationColo WebCore/rendering/RenderObject.cpp_sec1
- WebCore/rendering/RenderObject.cpp -2 lines
2221	}	2221	}
2222	}	2222	}
2223	curr = curr->parent();	2223	curr = curr->parent();
2224	if (curr && curr->isRenderBlock() && toRenderBlock(curr)->inlineContinuation())
2225	curr = toRenderBlock(curr)->inlineContinuation();
2226	} while (curr && decorations && (!quirksMode \|\| !curr->node() \|\|	2224	} while (curr && decorations && (!quirksMode \|\| !curr->node() \|\|
2227	(!curr->node()->hasTagName(aTag) && !curr->node()->hasTagName(fontTag))));	2225	(!curr->node()->hasTagName(aTag) && !curr->node()->hasTagName(fontTag))));
2228		2226

Lines 567-578 Element* AccessibilityRenderObject::anch WebCore/accessibility/AccessibilityRenderObject.cpp_sec1
- WebCore/accessibility/AccessibilityRenderObject.cpp -6 / +2 lines
567	RenderObject* currRenderer;	567	RenderObject* currRenderer;
568		568
569	// Search up the render tree for a RenderObject with a DOM node. Defer to an earlier continuation, though.	569	// Search up the render tree for a RenderObject with a DOM node. Defer to an earlier continuation, though.
570	for (currRenderer = m_renderer; currRenderer && !currRenderer->node(); currRenderer = currRenderer->parent()) {	570	for (currRenderer = m_renderer; currRenderer && !currRenderer->node(); currRenderer = currRenderer->parent())
571	if (currRenderer->isRenderBlock()) {	571	{
572	RenderInline* continuation = toRenderBlock(currRenderer)->inlineContinuation();
573	if (continuation)
574	return cache->getOrCreate(continuation)->anchorElement();
575	}
576	}	572	}
577		573
578	// bail if none found	574	// bail if none found

Line 0 WebCore/rendering/BidiRun.cpp_sec1
- WebCore/rendering/BidiRun.cpp +74 lines
		1	/**
		2	* Copyright (C) 1999 Lars Knoll (knoll@kde.org)
		3	* (C) 1999 Antti Koivisto (koivisto@kde.org)
		4	* Copyright (C) 2003, 2004, 2005, 2006, 2010 Apple Inc. All rights reserved.
		5	* Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
		6	*
		7	* This library is free software; you can redistribute it and/or
		8	* modify it under the terms of the GNU Library General Public
		9	* License as published by the Free Software Foundation; either
		10	* version 2 of the License, or (at your option) any later version.
		11	*
		12	* This library is distributed in the hope that it will be useful,
		13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		15	* Library General Public License for more details.
		16	*
		17	* You should have received a copy of the GNU Library General Public License
		18	* along with this library; see the file COPYING.LIB. If not, write to
		19	* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
		20	* Boston, MA 02110-1301, USA.
		21	*
		22	*/
		23
		24	#include "config.h"
		25	#include "BidiRun.h"
		26	#include "InlineBox.h"
		27	#include "RenderArena.h"
		28	#include <wtf/RefCountedLeakCounter.h>
		29
		30	using namespace WTF;
		31
		32	namespace WebCore {
		33
		34	#ifndef NDEBUG
		35	static RefCountedLeakCounter bidiRunCounter("BidiRun");
		36
		37	static bool inBidiRunDestroy;
		38	#endif
		39
		40	void BidiRun::destroy()
		41	{
		42	#ifndef NDEBUG
		43	inBidiRunDestroy = true;
		44	#endif
		45	RenderArena* renderArena = m_object->renderArena();
		46	delete this;
		47	#ifndef NDEBUG
		48	inBidiRunDestroy = false;
		49	#endif
		50
		51	// Recover the size left there for us by operator delete and free the memory.
		52	renderArena->free(reinterpret_cast<size_t>(this), this);
		53	}
		54
		55	void* BidiRun::operator new(size_t sz, RenderArena* renderArena) throw()
		56	{
		57	#ifndef NDEBUG
		58	bidiRunCounter.increment();
		59	#endif
		60	return renderArena->allocate(sz);
		61	}
		62
		63	void BidiRun::operator delete(void* ptr, size_t sz)
		64	{
65	#ifndef NDEBUG
66	bidiRunCounter.decrement();
67	#endif
68	ASSERT(inBidiRunDestroy);
69
70	// Stash size where destroy() can find it.
71	(size_t)ptr = sz;
72	}
73
74	}

Line 0 WebCore/rendering/BidiRun.h_sec1
- WebCore/rendering/BidiRun.h +66 lines
		1	/**
		2	* Copyright (C) 1999 Lars Knoll (knoll@kde.org)
		3	* (C) 1999 Antti Koivisto (koivisto@kde.org)
		4	* Copyright (C) 2003, 2004, 2005, 2006, 2010 Apple Inc. All rights reserved.
		5	* Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
		6	*
		7	* This library is free software; you can redistribute it and/or
		8	* modify it under the terms of the GNU Library General Public
		9	* License as published by the Free Software Foundation; either
		10	* version 2 of the License, or (at your option) any later version.
		11	*
		12	* This library is distributed in the hope that it will be useful,
		13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		15	* Library General Public License for more details.
		16	*
		17	* You should have received a copy of the GNU Library General Public License
		18	* along with this library; see the file COPYING.LIB. If not, write to
		19	* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
		20	* Boston, MA 02110-1301, USA.
		21	*
		22	*/
		23
		24	#ifndef BidiRun_h
		25	#define BidiRun_h
		26
		27	#include <wtf/StdLibExtras.h>
		28	#include "BidiResolver.h"
		29	#include "RenderText.h"
		30
		31	namespace WebCore {
		32
		33	class BidiContext;
		34	class InlineBox;
		35
		36	struct BidiRun : BidiCharacterRun {
		37	BidiRun(int start, int stop, RenderObject* object, BidiContext* context, WTF::Unicode::Direction dir)
		38	: BidiCharacterRun(start, stop, context, dir)
		39	, m_object(object)
		40	, m_box(0)
		41	{
		42	}
		43
		44	void destroy();
		45
		46	// Overloaded new operator.
		47	void* operator new(size_t, RenderArena*) throw();
		48
		49	// Overridden to prevent the normal delete from being called.
		50	void operator delete(void*, size_t);
		51
		52	BidiRun* next() { return static_cast<BidiRun*>(m_next); }
		53
		54	private:
		55	// The normal operator new is disallowed.
		56	void* operator new(size_t) throw();
		57
		58	public:
		59	RenderObject* m_object;
		60	InlineBox* m_box;
		61	};
		62
		63	}
		64
65	#endif // BidiRun_h
66

Lines 32-37 WebCore/rendering/InlineFlowBox.cpp_sec1
- WebCore/rendering/InlineFlowBox.cpp -11 / +5 lines
32	#include "RenderLayer.h"	32	#include "RenderLayer.h"
33	#include "RenderListMarker.h"	33	#include "RenderListMarker.h"
34	#include "RenderTableCell.h"	34	#include "RenderTableCell.h"
		35	#include "RenderView.h"
35	#include "RootInlineBox.h"	36	#include "RootInlineBox.h"
36	#include "Text.h"	37	#include "Text.h"
37		38
Lines 227-240 void InlineFlowBox::determineSpacingForF WebCore/rendering/InlineFlowBox.cpp_sec2
227	// (3) The line may end on the inline. If we are the last child (climbing up	228	// (3) The line may end on the inline. If we are the last child (climbing up
228	// the end object's chain), then we just closed as well.	229	// the end object's chain), then we just closed as well.
229	if (!lineBoxList->lastLineBox()->isConstructed()) {	230	if (!lineBoxList->lastLineBox()->isConstructed()) {
230	RenderInline* inlineFlow = toRenderInline(renderer());
231	if (ltr) {	231	if (ltr) {
232	if (!nextLineBox() &&	232	if (!nextLineBox() &&
233	((lastLine && !inlineFlow->continuation()) \|\| nextOnLineExists() \|\| onEndChain(endObject)))	233	(lastLine \|\| nextOnLineExists() \|\| onEndChain(endObject)))
234	includeRightEdge = true;	234	includeRightEdge = true;
235	} else {	235	} else {
236	if ((!prevLineBox() \|\| prevLineBox()->isConstructed()) &&	236	if ((!prevLineBox() \|\| prevLineBox()->isConstructed()) &&
237	((lastLine && !inlineFlow->continuation()) \|\| prevOnLineExists() \|\| onEndChain(endObject)))	237	(lastLine \|\| prevOnLineExists() \|\| onEndChain(endObject)))
238	includeLeftEdge = true;	238	includeLeftEdge = true;
239	}	239	}
240	}	240	}
Lines 504-510 void InlineFlowBox::placeBoxesVertically WebCore/rendering/InlineFlowBox.cpp_sec3
504	newY -= curr->boxModelObject()->borderTop() + curr->boxModelObject()->paddingTop();	504	newY -= curr->boxModelObject()->borderTop() + curr->boxModelObject()->paddingTop();
505	} else if (!curr->renderer()->isBR()) {	505	} else if (!curr->renderer()->isBR()) {
506	RenderBox* box = toRenderBox(curr->renderer());	506	RenderBox* box = toRenderBox(curr->renderer());
507	newY += box->marginTop();	507	newY += curr->renderer()->isAnonymousInlineBlock() ? 0 : box->marginTop();
508	}	508	}
509		509
510	curr->setY(newY);	510	curr->setY(newY);
Lines 638-650 void InlineFlowBox::paint(RenderObject:: WebCore/rendering/InlineFlowBox.cpp_sec4
638	// outlines.	638	// outlines.
639	if (renderer()->style()->visibility() == VISIBLE && renderer()->hasOutline() && !isRootInlineBox()) {	639	if (renderer()->style()->visibility() == VISIBLE && renderer()->hasOutline() && !isRootInlineBox()) {
640	RenderInline* inlineFlow = toRenderInline(renderer());	640	RenderInline* inlineFlow = toRenderInline(renderer());
641	if ((inlineFlow->continuation() \|\| inlineFlow->isInlineContinuation()) && !boxModelObject()->hasSelfPaintingLayer()) {	641	paintInfo.outlineObjects->add(inlineFlow);
642	// Add ourselves to the containing block of the entire continuation so that it can
643	// paint us atomically.
644	RenderBlock* block = renderer()->containingBlock()->containingBlock();
645	block->addContinuationWithOutline(toRenderInline(renderer()->node()->renderer()));
646	} else if (!inlineFlow->isInlineContinuation())
647	paintInfo.outlineObjects->add(inlineFlow);
648	}	642	}
649	} else if (paintInfo.phase == PaintPhaseMask) {	643	} else if (paintInfo.phase == PaintPhaseMask) {
650	paintMask(paintInfo, tx, ty);	644	paintMask(paintInfo, tx, ty);

Line 0 WebCore/rendering/InlineIterator.h_sec1
- WebCore/rendering/InlineIterator.h +267 lines
		1	/*
		2	* Copyright (C) 2000 Lars Knoll (knoll@kde.org)
		3	* Copyright (C) 2003, 2004, 2006, 2007, 2008, 2009, 2010 Apple Inc. All right reserved.
		4	* Copyright (C) 2010 Google Inc. All rights reserved.
		5	*
		6	* This library is free software; you can redistribute it and/or
		7	* modify it under the terms of the GNU Library General Public
		8	* License as published by the Free Software Foundation; either
		9	* version 2 of the License, or (at your option) any later version.
		10	*
		11	* This library is distributed in the hope that it will be useful,
		12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		14	* Library General Public License for more details.
		15	*
		16	* You should have received a copy of the GNU Library General Public License
		17	* along with this library; see the file COPYING.LIB. If not, write to
		18	* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
		19	* Boston, MA 02110-1301, USA.
		20	*
		21	*/
		22
		23	#ifndef InlineIterator_h
		24	#define InlineIterator_h
		25
		26	#include "BidiRun.h"
		27	#include "RenderBlock.h"
		28	#include "RenderText.h"
		29	#include <wtf/AlwaysInline.h>
		30	#include <wtf/StdLibExtras.h>
		31
		32	namespace WebCore {
		33
		34	class InlineIterator {
		35	public:
		36	InlineIterator()
		37	: block(0)
		38	, obj(0)
		39	, pos(0)
		40	, nextBreakablePosition(-1)
		41	{
		42	}
		43
		44	InlineIterator(RenderBlock* b, RenderObject* o, unsigned p)
		45	: block(b)
		46	, obj(o)
		47	, pos(p)
		48	, nextBreakablePosition(-1)
		49	{
		50	}
		51
		52	void increment(InlineBidiResolver* resolver = 0);
		53	bool atEnd() const;
		54
		55	UChar current() const;
		56	WTF::Unicode::Direction direction() const;
		57
		58	RenderBlock* block;
		59	RenderObject* obj;
		60	unsigned pos;
		61	int nextBreakablePosition;
		62	};
		63
		64	inline bool operator==(const InlineIterator& it1, const InlineIterator& it2)
65	{
66	return it1.pos == it2.pos && it1.obj == it2.obj;
67	}
68
69	inline bool operator!=(const InlineIterator& it1, const InlineIterator& it2)
70	{
71	return it1.pos != it2.pos \|\| it1.obj != it2.obj;
72	}
73
74	static inline RenderObject* bidiNext(RenderBlock* block, RenderObject* current, InlineBidiResolver* resolver = 0, bool skipInlines = true, bool* endOfInlinePtr = 0)
75	{
76	RenderObject* next = 0;
77	bool oldEndOfInline = endOfInlinePtr ? *endOfInlinePtr : false;
78	bool endOfInline = false;
79
80	while (current) {
81	next = 0;
82	if (!oldEndOfInline && !current->isFloating() && !current->isReplaced() && !current->isPositioned() && !current->isText()) {
83	next = current->firstChild();
84	if (next && resolver && next->isRenderInline()) {
85	EUnicodeBidi ub = next->style()->unicodeBidi();
86	if (ub != UBNormal) {
87	TextDirection dir = next->style()->direction();
88	WTF::Unicode::Direction d = (ub == Embed
89	? (dir == RTL ? WTF::Unicode::RightToLeftEmbedding : WTF::Unicode::LeftToRightEmbedding)
90	: (dir == RTL ? WTF::Unicode::RightToLeftOverride : WTF::Unicode::LeftToRightOverride));
91	resolver->embed(d);
92	}
93	}
94	}
95
96	if (!next) {
97	if (!skipInlines && !oldEndOfInline && current->isRenderInline()) {
98	next = current;
99	endOfInline = true;
100	break;
101	}
102
103	while (current && current != block) {
104	if (resolver && current->isRenderInline() && current->style()->unicodeBidi() != UBNormal)
105	resolver->embed(WTF::Unicode::PopDirectionalFormat);
106
107	next = current->nextSibling();
108	if (next) {
109	if (resolver && next->isRenderInline()) {
110	EUnicodeBidi ub = next->style()->unicodeBidi();
111	if (ub != UBNormal) {
112	TextDirection dir = next->style()->direction();
113	WTF::Unicode::Direction d = (ub == Embed
114	? (dir == RTL ? WTF::Unicode::RightToLeftEmbedding: WTF::Unicode::LeftToRightEmbedding)
115	: (dir == RTL ? WTF::Unicode::RightToLeftOverride : WTF::Unicode::LeftToRightOverride));
116	resolver->embed(d);
117	}
118	}
119	break;
120	}
121
122	current = current->parent();
123	if (!skipInlines && current && current != block && current->isRenderInline()) {
124	next = current;
125	endOfInline = true;
126	break;
127	}
128	}
129	}
130
131	if (!next)
132	break;
133
134	if (next->isText() \|\| next->isFloating() \|\| next->isReplaced() \|\| next->isPositioned()
135	\|\| ((!skipInlines \|\| !next->firstChild()) // Always return EMPTY inlines.
136	&& next->isRenderInline()))
137	break;
138	current = next;
139	}
140
141	if (endOfInlinePtr)
142	*endOfInlinePtr = endOfInline;
143
144	return next;
145	}
146
147	static inline RenderObject* bidiFirst(RenderBlock* block, InlineBidiResolver* resolver, bool skipInlines = true)
148	{
149	if (!block->firstChild())
150	return 0;
151
152	RenderObject* o = block->firstChild();
153	if (o->isRenderInline()) {
154	if (resolver) {
155	EUnicodeBidi ub = o->style()->unicodeBidi();
156	if (ub != UBNormal) {
157	TextDirection dir = o->style()->direction();
158	WTF::Unicode::Direction d = (ub == Embed
159	? (dir == RTL ? WTF::Unicode::RightToLeftEmbedding : WTF::Unicode::LeftToRightEmbedding)
160	: (dir == RTL ? WTF::Unicode::RightToLeftOverride : WTF::Unicode::LeftToRightOverride));
161	resolver->embed(d);
162	}
163	}
164	if (skipInlines && o->firstChild())
165	o = bidiNext(block, o, resolver, skipInlines);
166	else {
167	// Never skip empty inlines.
168	if (resolver)
169	resolver->commitExplicitEmbedding();
170	return o;
171	}
172	}
173
174	if (o && !o->isText() && !o->isReplaced() && !o->isFloating() && !o->isPositioned())
175	o = bidiNext(block, o, resolver, skipInlines);
176
177	if (resolver)
178	resolver->commitExplicitEmbedding();
179	return o;
180	}
181
182	inline void InlineIterator::increment(InlineBidiResolver* resolver)
183	{
184	if (!obj)
185	return;
186	if (obj->isText()) {
187	pos++;
188	if (pos >= toRenderText(obj)->textLength()) {
189	obj = bidiNext(block, obj, resolver);
190	pos = 0;
191	nextBreakablePosition = -1;
192	}
193	} else {
194	obj = bidiNext(block, obj, resolver);
195	pos = 0;
196	nextBreakablePosition = -1;
197	}
198	}
199
200	inline bool InlineIterator::atEnd() const
201	{
202	return !obj;
203	}
204
205	inline UChar InlineIterator::current() const
206	{
207	if (!obj \|\| !obj->isText())
208	return 0;
209
210	RenderText* text = toRenderText(obj);
211	if (pos >= text->textLength())
212	return 0;
213
214	return text->characters()[pos];
215	}
216
217	ALWAYS_INLINE WTF::Unicode::Direction InlineIterator::direction() const
218	{
219	if (UChar c = current())
220	return WTF::Unicode::direction(c);
221
222	if (obj && obj->isListMarker())
223	return obj->style()->direction() == LTR ? WTF::Unicode::LeftToRight : WTF::Unicode::RightToLeft;
224
225	return WTF::Unicode::OtherNeutral;
226	}
227
228	template<>
229	inline void InlineBidiResolver::increment()
230	{
231	current.increment(this);
232	}
233
234	template <>
235	inline void InlineBidiResolver::appendRun()
236	{
237	if (!emptyRun && !eor.atEnd()) {
238	int start = sor.pos;
239	RenderObject *obj = sor.obj;
240	while (obj && obj != eor.obj && obj != endOfLine.obj) {
241	RenderBlock::appendRunsForObject(start, obj->length(), obj, *this);
242	start = 0;
243	obj = bidiNext(sor.block, obj);
244	}
245	if (obj) {
246	unsigned pos = obj == eor.obj ? eor.pos : UINT_MAX;
247	if (obj == endOfLine.obj && endOfLine.pos <= pos) {
248	reachedEndOfLine = true;
249	pos = endOfLine.pos;
250	}
251	// It's OK to add runs for zero-length RenderObjects, just don't make the run larger than it should be
252	int end = obj->length() ? pos+1 : 0;
253	RenderBlock::appendRunsForObject(start, end, obj, *this);
254	}
255
256	eor.increment();
257	sor = eor;
258	}
259
260	m_direction = WTF::Unicode::OtherNeutral;
261	m_status.eor = WTF::Unicode::OtherNeutral;
262	}
263
264	}
265
266	#endif // InlineIterator_h
267

Lines 129-143 public: WebCore/rendering/RenderBlock.h_sec1
- WebCore/rendering/RenderBlock.h -30 / +13 lines
129		129
130	void adjustRectForColumns(IntRect&) const;	130	void adjustRectForColumns(IntRect&) const;
131		131
132	void addContinuationWithOutline(RenderInline*);
133
134	RenderInline* inlineContinuation() const { return m_inlineContinuation; }
135	void setInlineContinuation(RenderInline* c) { m_inlineContinuation = c; }
136
137	// This function is a convenience helper for creating an anonymous block that inherits its	132	// This function is a convenience helper for creating an anonymous block that inherits its
138	// style from this RenderBlock.	133	// style from this RenderBlock.
139	RenderBlock* createAnonymousBlock(bool isFlexibleBox = false) const;	134	RenderBlock* createAnonymousBlock(bool isFlexibleBox = false) const;
140		135
		136	virtual void paint(PaintInfo&, int tx, int ty);
		137	virtual void paintObject(PaintInfo&, int tx, int ty);
		138
		139	bool inRootBlockContext() const;
		140
		141	static void appendRunsForObject(int start, int end, RenderObject*, InlineBidiResolver&);
		142	static bool requiresLineBox(const InlineIterator&, bool isLineEmpty = true, bool previousLineBrokeCleanly = true);
		143
141	protected:	144	protected:
142	void moveChildTo(RenderObject* to, RenderObjectChildList* toChildList, RenderObject* child);	145	void moveChildTo(RenderObject* to, RenderObjectChildList* toChildList, RenderObject* child);
143	void moveChildTo(RenderObject* to, RenderObjectChildList* toChildList, RenderObject* beforeChild, RenderObject* child);	146	void moveChildTo(RenderObject* to, RenderObjectChildList* toChildList, RenderObject* beforeChild, RenderObject* child);
Lines 165-173 protected: WebCore/rendering/RenderBlock.h_sec2
165		168
166	void layoutPositionedObjects(bool relayoutChildren);	169	void layoutPositionedObjects(bool relayoutChildren);
167		170
168	virtual void paint(PaintInfo&, int tx, int ty);
169	virtual void paintObject(PaintInfo&, int tx, int ty);
170
171	int rightRelOffset(int y, int fixedOffset, bool applyTextIndent = true, int* heightRemaining = 0) const;	171	int rightRelOffset(int y, int fixedOffset, bool applyTextIndent = true, int* heightRemaining = 0) const;
172	int leftRelOffset(int y, int fixedOffset, bool applyTextIndent = true, int* heightRemaining = 0) const;	172	int leftRelOffset(int y, int fixedOffset, bool applyTextIndent = true, int* heightRemaining = 0) const;
173		173
Lines 180-187 protected: WebCore/rendering/RenderBlock.h_sec3
180		180
181	virtual void updateFirstLetter();	181	virtual void updateFirstLetter();
182		182
183	virtual void updateHitTestResult(HitTestResult&, const IntPoint&);
184
185	// Delay update scrollbar until finishDelayRepaint() will be	183	// Delay update scrollbar until finishDelayRepaint() will be
186	// called. This function is used when a flexbox is laying out its	184	// called. This function is used when a flexbox is laying out its
187	// descendant. If multiple calls are made to startDelayRepaint(),	185	// descendant. If multiple calls are made to startDelayRepaint(),
Lines 245-251 private: WebCore/rendering/RenderBlock.h_sec4
245	bool everHadLayout;	243	bool everHadLayout;
246	};	244	};
247		245
248	// The following functions' implementations are in RenderBlockLineLayout.cpp.	246	class MarginInfo;
		247
		248	// The following functions' implementations are in RenderBlockLineLayout.cpp.
249	void bidiReorderLine(InlineBidiResolver&, const InlineIterator& end, bool previousLineBrokeCleanly);	249	void bidiReorderLine(InlineBidiResolver&, const InlineIterator& end, bool previousLineBrokeCleanly);
250	RootInlineBox* determineStartPosition(bool& firstLine, bool& fullLayout, bool& previousLineBrokeCleanly,	250	RootInlineBox* determineStartPosition(bool& firstLine, bool& fullLayout, bool& previousLineBrokeCleanly,
251	InlineBidiResolver&, Vector<FloatWithRect>& floats, unsigned& numCleanFloats);	251	InlineBidiResolver&, Vector<FloatWithRect>& floats, unsigned& numCleanFloats);
Lines 258-264 private: WebCore/rendering/RenderBlock.h_sec5
258	void skipTrailingWhitespace(InlineIterator&, bool isLineEmpty, bool previousLineBrokeCleanly);	258	void skipTrailingWhitespace(InlineIterator&, bool isLineEmpty, bool previousLineBrokeCleanly);
259	int skipLeadingWhitespace(InlineBidiResolver&, bool firstLine, bool isLineEmpty, bool previousLineBrokeCleanly);	259	int skipLeadingWhitespace(InlineBidiResolver&, bool firstLine, bool isLineEmpty, bool previousLineBrokeCleanly);
260	void fitBelowFloats(int widthToFit, bool firstLine, int& availableWidth);	260	void fitBelowFloats(int widthToFit, bool firstLine, int& availableWidth);
261	InlineIterator findNextLineBreak(InlineBidiResolver&, bool firstLine, bool& isLineEmpty, bool& previousLineBrokeCleanly, EClear* clear = 0);	261	InlineIterator findNextLineBreak(InlineBidiResolver&, bool firstLine, bool& isLineEmpty, bool& previousLineBrokeCleanly, MarginInfo&, EClear* clear = 0);
262	RootInlineBox* constructLine(unsigned runCount, BidiRun* firstRun, BidiRun* lastRun, bool firstLine, bool lastLine, RenderObject* endObject);	262	RootInlineBox* constructLine(unsigned runCount, BidiRun* firstRun, BidiRun* lastRun, bool firstLine, bool lastLine, RenderObject* endObject);
263	InlineFlowBox* createLineBoxes(RenderObject*, bool firstLine);	263	InlineFlowBox* createLineBoxes(RenderObject*, bool firstLine);
264	void computeHorizontalPositionsForLine(RootInlineBox, bool firstLine, BidiRun firstRun, BidiRun* trailingSpaceRun, bool reachedEnd);	264	void computeHorizontalPositionsForLine(RootInlineBox, bool firstLine, BidiRun firstRun, BidiRun* trailingSpaceRun, bool reachedEnd);
Lines 313-325 private: WebCore/rendering/RenderBlock.h_sec6
313	// Obtains the nearest enclosing block (including this block) that contributes a first-line style to our inline	313	// Obtains the nearest enclosing block (including this block) that contributes a first-line style to our inline
314	// children.	314	// children.
315	virtual RenderBlock* firstLineBlock() const;	315	virtual RenderBlock* firstLineBlock() const;
316	bool inRootBlockContext() const;
317
318	virtual IntRect rectWithOutlineForRepaint(RenderBoxModelObject* repaintContainer, int outlineWidth);
319	virtual RenderStyle* outlineStyleForRepaint() const;
320		316
321	virtual RenderObject* hoverAncestor() const;
322	virtual void updateDragState(bool dragOn);
323	virtual void childBecameNonInline(RenderObject* child);	317	virtual void childBecameNonInline(RenderObject* child);
324		318
325	virtual IntRect selectionRectForRepaint(RenderBoxModelObject* repaintContainer, bool /clipToVisibleContent/)	319	virtual IntRect selectionRectForRepaint(RenderBoxModelObject* repaintContainer, bool /clipToVisibleContent/)
Lines 339-354 private: WebCore/rendering/RenderBlock.h_sec7
339	int leftSelectionOffset(RenderBlock* rootBlock, int y);	333	int leftSelectionOffset(RenderBlock* rootBlock, int y);
340	int rightSelectionOffset(RenderBlock* rootBlock, int y);	334	int rightSelectionOffset(RenderBlock* rootBlock, int y);
341		335
342	virtual void absoluteRects(Vector<IntRect>&, int tx, int ty);
343	virtual void absoluteQuads(Vector<FloatQuad>&);
344
345	int desiredColumnWidth() const;	336	int desiredColumnWidth() const;
346	unsigned desiredColumnCount() const;	337	unsigned desiredColumnCount() const;
347	Vector<IntRect>* columnRects() const;	338	Vector<IntRect>* columnRects() const;
348	void setDesiredColumnCountAndWidth(int count, int width);	339	void setDesiredColumnCountAndWidth(int count, int width);
349	int columnGap() const;	340	int columnGap() const;
350
351	void paintContinuationOutlines(PaintInfo&, int tx, int ty);
352		341
353	virtual IntRect localCaretRect(InlineBox, int caretOffset, int extraWidthToEndOfLine = 0);	342	virtual IntRect localCaretRect(InlineBox, int caretOffset, int extraWidthToEndOfLine = 0);
354		343
Lines 484-495 private: WebCore/rendering/RenderBlock.h_sec8
484	DeprecatedPtrList<FloatingObject>* m_floatingObjects;	473	DeprecatedPtrList<FloatingObject>* m_floatingObjects;
485	ListHashSet<RenderBox> m_positionedObjects;	474	ListHashSet<RenderBox> m_positionedObjects;
486		475
487	// An inline can be split with blocks occurring in between the inline content.
488	// When this occurs we need a pointer to our next object. We can basically be
489	// split into a sequence of inlines and blocks. The continuation will either be
490	// an anonymous block (that houses other blocks) or it will be an inline flow.
491	RenderInline* m_inlineContinuation;
492
493	// Allocated only when some of these fields have non-default values	476	// Allocated only when some of these fields have non-default values
494	struct MaxMargin : Noncopyable {	477	struct MaxMargin : Noncopyable {
495	MaxMargin(const RenderBlock* o)	478	MaxMargin(const RenderBlock* o)
Lines 517-523 private: WebCore/rendering/RenderBlock.h_sec9
517	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>.	500	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>.
518		501
519	mutable int m_lineHeight;	502	mutable int m_lineHeight;
520		503
521	// RenderRubyBase objects need to be able to split and merge, moving their children around	504	// RenderRubyBase objects need to be able to split and merge, moving their children around
522	// (calling moveChildTo, moveAllChildrenTo, and makeChildrenNonInline).	505	// (calling moveChildTo, moveAllChildrenTo, and makeChildrenNonInline).
523	friend class RenderRubyBase;	506	friend class RenderRubyBase;

Lines 1334-1340 void RenderBox::calcWidth() WebCore/rendering/RenderBox.cpp_sec1
- WebCore/rendering/RenderBox.cpp -3 / +3 lines
1334	}	1334	}
1335		1335
1336	if (containerWidth && containerWidth != (width() + m_marginLeft + m_marginRight)	1336	if (containerWidth && containerWidth != (width() + m_marginLeft + m_marginRight)
1337	&& !isFloating() && !isInline() && !cb->isFlexibleBox()) {	1337	&& !isFloating() && (!isInline() \|\| isAnonymousInlineBlock()) && !cb->isFlexibleBox()) {
1338	if (cb->style()->direction() == LTR)	1338	if (cb->style()->direction() == LTR)
1339	m_marginRight = containerWidth - width() - m_marginLeft;	1339	m_marginRight = containerWidth - width() - m_marginLeft;
1340	else	1340	else
Lines 1373-1379 bool RenderBox::sizesToIntrinsicWidth(Wi WebCore/rendering/RenderBox.cpp_sec2
1373	{	1373	{
1374	// Marquees in WinIE are like a mixture of blocks and inline-blocks. They size as though they're blocks,	1374	// Marquees in WinIE are like a mixture of blocks and inline-blocks. They size as though they're blocks,
1375	// but they allow text to sit on the same line as the marquee.	1375	// but they allow text to sit on the same line as the marquee.
1376	if (isFloating() \|\| (isInlineBlockOrInlineTable() && !isHTMLMarquee()))	1376	if (isFloating() \|\| (isInlineBlockOrInlineTable() && !isHTMLMarquee() && !isAnonymousInlineBlock()))
1377	return true;	1377	return true;
1378		1378
1379	// This code may look a bit strange. Basically width:intrinsic should clamp the size when testing both	1379	// This code may look a bit strange. Basically width:intrinsic should clamp the size when testing both
Lines 2819-2825 bool RenderBox::shrinkToAvoidFloats() co WebCore/rendering/RenderBox.cpp_sec3
2819		2819
2820	bool RenderBox::avoidsFloats() const	2820	bool RenderBox::avoidsFloats() const
2821	{	2821	{
2822	return isReplaced() \|\| hasOverflowClip() \|\| isHR();	2822	return !isAnonymousInlineBlock() && (isReplaced() \|\| hasOverflowClip() \|\| isHR());
2823	}	2823	}
2824		2824
2825	void RenderBox::addShadowOverflow()	2825	void RenderBox::addShadowOverflow()

Lines 58-67 public: WebCore/rendering/RenderInline.h_sec1
- WebCore/rendering/RenderInline.h -15 lines
58		58
59	InlineFlowBox* firstLineBox() const { return m_lineBoxes.firstLineBox(); }	59	InlineFlowBox* firstLineBox() const { return m_lineBoxes.firstLineBox(); }
60	InlineFlowBox* lastLineBox() const { return m_lineBoxes.lastLineBox(); }	60	InlineFlowBox* lastLineBox() const { return m_lineBoxes.lastLineBox(); }
61
62	RenderBoxModelObject* continuation() const { return m_continuation; }
63
64	virtual void updateDragState(bool dragOn);
65		61
66	IntSize relativePositionedInlineOffset(const RenderBox* child) const;	62	IntSize relativePositionedInlineOffset(const RenderBox* child) const;
67		63
Lines 81-89 private: WebCore/rendering/RenderInline.h_sec2
81		77
82	virtual bool isRenderInline() const { return true; }	78	virtual bool isRenderInline() const { return true; }
83		79
84	void addChildToContinuation(RenderObject* newChild, RenderObject* beforeChild);
85	virtual void addChildIgnoringContinuation(RenderObject* newChild, RenderObject* beforeChild = 0);
86
87	void splitInlines(RenderBlock* fromBlock, RenderBlock* toBlock, RenderBlock* middleBlock,	80	void splitInlines(RenderBlock* fromBlock, RenderBlock* toBlock, RenderBlock* middleBlock,
88	RenderObject* beforeChild, RenderBoxModelObject* oldCont);	81	RenderObject* beforeChild, RenderBoxModelObject* oldCont);
89	void splitFlow(RenderObject* beforeChild, RenderBlock* newBlockBox,	82	void splitFlow(RenderObject* beforeChild, RenderBlock* newBlockBox,
Lines 126-138 private: WebCore/rendering/RenderInline.h_sec3
126		119
127	virtual int lineHeight(bool firstLine, bool isRootLineBox = false) const;	120	virtual int lineHeight(bool firstLine, bool isRootLineBox = false) const;
128		121
129	RenderInline* inlineContinuation() const;
130	void setContinuation(RenderBoxModelObject* c) { m_continuation = c; }
131
132	virtual void childBecameNonInline(RenderObject* child);	122	virtual void childBecameNonInline(RenderObject* child);
133		123
134	virtual void updateHitTestResult(HitTestResult&, const IntPoint&);
135
136	virtual void imageChanged(WrappedImagePtr, const IntRect* = 0);	124	virtual void imageChanged(WrappedImagePtr, const IntRect* = 0);
137		125
138	#if ENABLE(DASHBOARD_SUPPORT)	126	#if ENABLE(DASHBOARD_SUPPORT)
Lines 145-157 private: WebCore/rendering/RenderInline.h_sec4
145	static RenderInline* cloneInline(RenderInline* src);	133	static RenderInline* cloneInline(RenderInline* src);
146		134
147	void paintOutlineForLine(GraphicsContext*, int tx, int ty, const IntRect& prevLine, const IntRect& thisLine, const IntRect& nextLine);	135	void paintOutlineForLine(GraphicsContext*, int tx, int ty, const IntRect& prevLine, const IntRect& thisLine, const IntRect& nextLine);
148	RenderBoxModelObject* continuationBefore(RenderObject* beforeChild);
149		136
150	RenderObjectChildList m_children;	137	RenderObjectChildList m_children;
151	RenderLineBoxList m_lineBoxes; // All of the line boxes created for this inline flow. For example, <i>Hello<br>world.</i> will have two <i> line boxes.	138	RenderLineBoxList m_lineBoxes; // All of the line boxes created for this inline flow. For example, <i>Hello<br>world.</i> will have two <i> line boxes.
152		139
153	RenderBoxModelObject* m_continuation; // Can be either a block or an inline. <b><i><p>Hello</p></i></b>. In this example the <i> will have a block as its continuation but the
154	// <b> will just have an inline as its continuation.
155	mutable int m_lineHeight;	140	mutable int m_lineHeight;
156	mutable int m_verticalPosition;	141	mutable int m_verticalPosition;
157	};	142	};

Lines 146-163 void RenderLineBoxList::dirtyLineBoxes() WebCore/rendering/RenderLineBoxList.cpp_sec1
- WebCore/rendering/RenderLineBoxList.cpp -6 / +6 lines
146		146
147	void RenderLineBoxList::paint(RenderBoxModelObject* renderer, RenderObject::PaintInfo& paintInfo, int tx, int ty) const	147	void RenderLineBoxList::paint(RenderBoxModelObject* renderer, RenderObject::PaintInfo& paintInfo, int tx, int ty) const
148	{	148	{
149	// Only paint during the foreground/selection phases.
150	if (paintInfo.phase != PaintPhaseForeground && paintInfo.phase != PaintPhaseSelection && paintInfo.phase != PaintPhaseOutline
151	&& paintInfo.phase != PaintPhaseSelfOutline && paintInfo.phase != PaintPhaseChildOutlines && paintInfo.phase != PaintPhaseTextClip
152	&& paintInfo.phase != PaintPhaseMask)
153	return;
154
155	ASSERT(renderer->isRenderBlock() \|\| (renderer->isRenderInline() && renderer->hasLayer())); // The only way an inline could paint like this is if it has a layer.	149	ASSERT(renderer->isRenderBlock() \|\| (renderer->isRenderInline() && renderer->hasLayer())); // The only way an inline could paint like this is if it has a layer.
156		150
157	// If we have no lines then we have no work to do.	151	// If we have no lines then we have no work to do.
158	if (!firstLineBox())	152	if (!firstLineBox())
159	return;	153	return;
160		154
		155	// Only paint during the foreground/selection phases if we have a layer. Otherwise we might have an anonymous inline block, so we can't short circuit.
		156	if (firstLineBox()->parent() && (paintInfo.phase != PaintPhaseForeground && paintInfo.phase != PaintPhaseSelection && paintInfo.phase != PaintPhaseOutline
		157	&& paintInfo.phase != PaintPhaseSelfOutline && paintInfo.phase != PaintPhaseChildOutlines && paintInfo.phase != PaintPhaseTextClip
		158	&& paintInfo.phase != PaintPhaseMask))
		159	return;
		160
161	// We can check the first box and last box and avoid painting if we don't	161	// We can check the first box and last box and avoid painting if we don't
162	// intersect. This is a quick short-circuit that we can take to avoid walking any lines.	162	// intersect. This is a quick short-circuit that we can take to avoid walking any lines.
163	// FIXME: This check is flawed in the following extremely obscure way:	163	// FIXME: This check is flawed in the following extremely obscure way:

Lines 316-331 void RenderObjectChildList::updateBefore WebCore/rendering/RenderObjectChildList.cpp_sec1
- WebCore/rendering/RenderObjectChildList.cpp -10 lines
316		316
317	// Whether or not we now want generated content.	317	// Whether or not we now want generated content.
318	bool newContentWanted = pseudoElementStyle && pseudoElementStyle->display() != NONE;	318	bool newContentWanted = pseudoElementStyle && pseudoElementStyle->display() != NONE;
319
320	// For <q><p/></q>, if this object is the inline continuation of the <q>, we only want to generate
321	// :after content and not :before content.
322	if (newContentWanted && type == BEFORE && owner->isRenderInline() && toRenderInline(owner)->isInlineContinuation())
323	newContentWanted = false;
324
325	// Similarly, if we're the beginning of a <q>, and there's an inline continuation for our object,
326	// then we don't generate the :after content.
327	if (newContentWanted && type == AFTER && owner->isRenderInline() && toRenderInline(owner)->continuation())
328	newContentWanted = false;
329		319
330	// If we don't want generated content any longer, or if we have generated content, but it's no longer	320	// If we don't want generated content any longer, or if we have generated content, but it's no longer
331	// identical to the new content data we want to build render objects for, then we nuke all	321	// identical to the new content data we want to build render objects for, then we nuke all

Lines 116-122 void RenderRubyBase::moveBlockChildren(R WebCore/rendering/RenderRubyBase.cpp_sec1
- WebCore/rendering/RenderRubyBase.cpp -2 lines
116	if (child->isAnonymousBlock()) {	116	if (child->isAnonymousBlock()) {
117	RenderBlock* anonBlock = toRenderBlock(child);	117	RenderBlock* anonBlock = toRenderBlock(child);
118	ASSERT(anonBlock->childrenInline());	118	ASSERT(anonBlock->childrenInline());
119	ASSERT(!anonBlock->inlineContinuation());
120	anonBlock->moveAllChildrenTo(toBase, toBase->children());	119	anonBlock->moveAllChildrenTo(toBase, toBase->children());
121	anonBlock->deleteLineBoxTree();	120	anonBlock->deleteLineBoxTree();
122	anonBlock->destroy();	121	anonBlock->destroy();
Lines 143-149 void RenderRubyBase::moveBlockChildren(R WebCore/rendering/RenderRubyBase.cpp_sec2
143		142
144	RenderBlock* anonBlock = toRenderBlock(child);	143	RenderBlock* anonBlock = toRenderBlock(child);
145	ASSERT(anonBlock->childrenInline());	144	ASSERT(anonBlock->childrenInline());
146	ASSERT(!anonBlock->inlineContinuation());
147	// Move inline children out of anonymous block.	145	// Move inline children out of anonymous block.
148	anonBlock->moveAllChildrenTo(this, children(), anonBlock);	146	anonBlock->moveAllChildrenTo(this, children(), anonBlock);
149	anonBlock->deleteLineBoxTree();	147	anonBlock->deleteLineBoxTree();

Lines 31-36 WebCore/rendering/RootInlineBox.cpp_sec1
- WebCore/rendering/RootInlineBox.cpp -1 / +57 lines
31	#include "Page.h"	31	#include "Page.h"
32	#include "RenderArena.h"	32	#include "RenderArena.h"
33	#include "RenderBlock.h"	33	#include "RenderBlock.h"
		34	#include "RenderView.h"
34		35
35	using namespace std;	36	using namespace std;
36		37
Lines 163-168 void RootInlineBox::paintCustomHighlight WebCore/rendering/RootInlineBox.cpp_sec2
163		164
164	void RootInlineBox::paint(RenderObject::PaintInfo& paintInfo, int tx, int ty)	165	void RootInlineBox::paint(RenderObject::PaintInfo& paintInfo, int tx, int ty)
165	{	166	{
		167	RenderBlock* child = anonymousInlineBlock();
		168	if (child) {
		169	// Treat painting of a special inline-block line like the painting of a normal block and go through all phases.
		170	PaintPhase newPhase = (paintInfo.phase == PaintPhaseChildOutlines) ? PaintPhaseOutline : paintInfo.phase;
		171	newPhase = (newPhase == PaintPhaseChildBlockBackgrounds) ? PaintPhaseChildBlockBackground : newPhase;
		172
		173	// We don't paint our own background, but we do let the child paint its background.
		174	RenderObject::PaintInfo info(paintInfo);
		175	info.phase = newPhase;
		176	info.paintingRoot = renderer()->paintingRootForChildren(paintInfo);
		177	bool isPrinting = renderer()->document()->printing();
		178
		179	// Check for page-break-before: always, and if it's set, break and bail.
		180	if (isPrinting && child->style()->pageBreakBefore() == PBALWAYS &&
		181	block()->inRootBlockContext() && (ty + child->y()) > paintInfo.rect.y() &&
		182	(ty + child->y()) < paintInfo.rect.bottom()) {
		183	renderer()->view()->setBestTruncatedAt(ty + child->y(), block(), true);
		184	return;
		185	}
		186
		187	if (!child->hasSelfPaintingLayer())
		188	child->paint(info, tx, ty);
		189
		190	// Check for page-break-after: always, and if it's set, break and bail.
		191	if (isPrinting && child->style()->pageBreakAfter() == PBALWAYS &&
		192	block()->inRootBlockContext() && (ty + child->y() + child->height()) > paintInfo.rect.y() &&
		193	(ty + child->y() + child->height()) < paintInfo.rect.bottom()) {
		194	renderer()->view()->setBestTruncatedAt(ty + child->y() + child->height() + max(0, child->collapsedMarginBottom()), block(), true);
		195	return;
		196	}
		197
		198	return;
		199	}
		200
		201	// Only paint during the foreground/selection phases if we don't have a special anonymous inline block.
		202	if (paintInfo.phase != PaintPhaseForeground && paintInfo.phase != PaintPhaseSelection && paintInfo.phase != PaintPhaseOutline
		203	&& paintInfo.phase != PaintPhaseSelfOutline && paintInfo.phase != PaintPhaseChildOutlines && paintInfo.phase != PaintPhaseTextClip
		204	&& paintInfo.phase != PaintPhaseMask)
		205	return;
		206
166	InlineFlowBox::paint(paintInfo, tx, ty);	207	InlineFlowBox::paint(paintInfo, tx, ty);
167	paintEllipsisBox(paintInfo, tx, ty);	208	paintEllipsisBox(paintInfo, tx, ty);
168	#if PLATFORM(MAC)	209	#if PLATFORM(MAC)
Lines 204-209 void RootInlineBox::childRemoved(InlineB WebCore/rendering/RootInlineBox.cpp_sec3
204		245
205	int RootInlineBox::verticallyAlignBoxes(int heightOfBlock)	246	int RootInlineBox::verticallyAlignBoxes(int heightOfBlock)
206	{	247	{
		248	RenderBlock* inlineBlock = anonymousInlineBlock();
		249	if (inlineBlock) {
		250	int lineTop = inlineBlock->y();
		251	int lineBottom = inlineBlock->y() + inlineBlock->height();
		252	firstChild()->setY(lineTop);
		253	setY(lineTop);
		254	computeVerticalOverflow(lineTop, lineBottom, true);
		255	setLineTopBottomPositions(lineTop, lineBottom);
		256	return heightOfBlock;
		257	}
		258
207	int maxPositionTop = 0;	259	int maxPositionTop = 0;
208	int maxPositionBottom = 0;	260	int maxPositionBottom = 0;
209	int maxAscent = 0;	261	int maxAscent = 0;
Lines 217-223 int RootInlineBox::verticallyAlignBoxes( WebCore/rendering/RootInlineBox.cpp_sec4
217	bool strictMode = (curr && curr->document()->inStrictMode());	269	bool strictMode = (curr && curr->document()->inStrictMode());
218		270
219	computeLogicalBoxHeights(maxPositionTop, maxPositionBottom, maxAscent, maxDescent, strictMode);	271	computeLogicalBoxHeights(maxPositionTop, maxPositionBottom, maxAscent, maxDescent, strictMode);
220
221	if (maxAscent + maxDescent < max(maxPositionTop, maxPositionBottom))	272	if (maxAscent + maxDescent < max(maxPositionTop, maxPositionBottom))
222	adjustMaxAscentAndDescent(maxAscent, maxDescent, maxPositionTop, maxPositionBottom);	273	adjustMaxAscentAndDescent(maxAscent, maxDescent, maxPositionTop, maxPositionBottom);
223		274
Lines 430-433 void RootInlineBox::attachLineBoxToRende WebCore/rendering/RootInlineBox.cpp_sec5
430	block()->lineBoxes()->attachLineBox(this);	481	block()->lineBoxes()->attachLineBox(this);
431	}	482	}
432		483
		484	RenderBlock* RootInlineBox::anonymousInlineBlock() const
		485	{
		486	return firstChild() && firstChild() == lastChild() && !firstChild()->isText() && firstChild()->renderer()->isAnonymousInlineBlock() ? toRenderBlock(firstChild()->renderer()) : 0;
		487	}
		488
433	} // namespace WebCore	489	} // namespace WebCore